Ajout info config TP1

tp/tp1.md

@@ -6,16 +6,16 @@ Les TPs s'effectueront sous Linux.
 
 Vérifier que `ocaml` est disponible.
 
-TODO: ajouter les instructions pour le opam partagé
+Configurer votre environnement selon le fichier [CONFIGURATION.md](../CONFIGURATION.md).
 
 Vérifier que l'extension "OCaml Platform" est installée dans VSCode, l'installer si besoin.
 
 Créer un fichier `tp1.ml`, ouvrir ce fichier avec Visual Studio Code.
-Le plugin OCaml permet d'exécuter un code sélectionné avec les touches Shift Enter.
+Le plugin OCaml permet d'exécuter un code sélectionné avec les touches `[Shift] + [Enter]`.
 
 ## 1. Premiers pas avec l'interpréteur
 
-Lancer l'interpréteur ocaml avec la commande
+Lancer l'interpréteur `ocaml` avec la commande
 
 ```bash
 rlwrap ocaml
@@ -32,7 +32,7 @@ si `rlwrap` n'est pas installé.
 ### 1.1. Types de base
 
 On va commencer par utiliser l'interpréteur comme une calculatrice avancée.
-Dans l'interpréteur, les expressions à calculer doivent se terminer par `;;`.
+Dans l'interpréteur, les expressions à calculer **doivent** se terminer par `;;`.
 
 > Saisir quelques opérations sur les entiers, par exemple:
 >
@@ -56,7 +56,7 @@ Il est évidement possible d'utiliser les booléens en OCaml. Les constantes son
 
 > Écrire une ou deux expressions booléennes dans l'interpréteur. Indiquer qui de `||` ou `&&` est prioritaire (c.-à-d. où sont les parenthèses dans une expression comme `a || b && c`)
 
-Les opérateurs de comparaison s'écrivent `=` (attention il y a bien un seul `=`), `!=`, `>`, `<`, `>=`, `<=`. Ils permettent de comparer des valeurs de même type.
+Les opérateurs de comparaison s'écrivent `=` (attention il y a bien un seul signe `=`), `!=`, `>`, `<`, `>=`, `<=`. Ils permettent de comparer des valeurs de même type.
 
 > Expliquer la différence de comportement entre ces deux expressions:
 >
@@ -85,7 +85,7 @@ La fonction `float_of_int` permet de transformer un `int` en `float`.
 
 > Dans l'interpréteur, appeler la fonction `float_of_int` en lui passant un `int` en argument.
 > Essayer ensuite avec un `float` et expliquer ce qui c'est passé.
-
+>
 > Entrer l'expression `int_of_float ;;` dans l'interpréteur.
 > Celui-ci affiche alors le type de la fonction.
 
@@ -98,7 +98,7 @@ La négation dans les booléens n'est pas un opérateur, mais simplement la fonc
 
 > Expliquer le résultat de l'évaluation de `not false && false` en ajoutant les parenthèses implicites au bon endroit.
 
-Remarque: les opérateurs en OCaml sont aussi des fonctions. En ajoutant des parenthèses directement autour d'un opérateur, il sera vu comme une fonction, par exemple on peut écrire `(&&) true false` au lieu de `true && false`.
+Remarque : les opérateurs en OCaml sont **aussi** des fonctions. En ajoutant des parenthèses directement autour d'un opérateur, il sera vu comme une fonction, par exemple on peut écrire `(&&) true false` au lieu de `true && false`.
 
 > Récrire l'expression suivante en utilisant les opérateurs comme des fonctions:
 >
@@ -121,9 +121,8 @@ let x1 = 3.5 +. float_of_int 2
 in x1 +. 3.0;;
 ```
 
-La construction `let in` est elle-même une expression et peut donc être utilisée
-dans d'autres expressions, y compris d'autres `let ... in ...`.
-Cela permet en particulier de définir plusieurs variables à la suite:
+La construction `let ... in ...` est elle-même une expression et peut donc être utilisée dans d'autres expressions, y compris d'autres `let ... in ...`.
+Cela permet en particulier de définir plusieurs variables à la suite :
 
 ```ocaml
 let x1 = 3.5 +. float_of_int 2 in
@@ -133,7 +132,7 @@ x2 *. 2.0 ;;
 
 ### 1.4 Conditionnelle
 
-La conditionnelle `if .. then ... else ...` est une **expression** et pas une _instruction_ en OCaml, c'est à dire qu'elle a un résultat.
+La conditionnelle `if ... then ... else ...` est une **expression** et pas une _instruction_ en OCaml, c'est-à-dire qu'elle a un résultat.
 
 > **Prédire** puis vérifier le résultat de l'expression suivante:
 >
@@ -143,7 +142,7 @@ La conditionnelle `if .. then ... else ...` est une **expression** et pas une _i
 
 ## 2. Définition de fonctions
 
-La construction `let` sans le `in` permet de définir des variables globales.
+La construction `let` _sans_ le `in` permet de définir des variables _globales_.
 On peut l'utiliser pour définir des fonctions comme suit:
 
 ```ocaml
@@ -162,7 +161,7 @@ let f x = x + 1;;
 >
 > Quel est le type affiché par OCaml à la définition de cette fonction ?
 
-Il est possible d'imposer les types des arguments avec la syntaxe suivante:
+Il est possible d'imposer les types des arguments avec la syntaxe suivante :
 
 ```ocaml
 let f (a1:t1) (a2:t2): type_retour = valeur_de_retour;;
@@ -175,7 +174,7 @@ Récrire une deuxième fois cette fonction en changeant le type de `a` en `int`
 
 > Dans la suite de ce TP et dans les TPs suivants, on prendra soin de **toujours indiquer le type des fonctions** définies globalement.
 
-OCaml est muni d'un outil, ocamldoc, qui permet de générer de la documentation à partir de commentaires spéciaux.
+OCaml est muni d'un outil, `ocamldoc`, qui permet de générer de la documentation à partir de commentaires spéciaux.
 
 Voici une exemple de documentation à placer juste avant la définition de discriminant:
 
@@ -190,13 +189,14 @@ Cette fonction est utile pour trouver les racines d'un trinôme.
 *)
 ```
 
-> Dans la suite de ce TP et pour les autres TP, on écrira toujours un commentaire spécial avant la définition d'une fonction définie globalement. Et on écrira toujours ce **commentaire avant de commencer à coder** la fonction.
+**Dans la suite de ce TP et pour les autres TP**, on écrira _toujours_ un commentaire spécial avant la définition d'une fonction définie globalement. Et on écrira toujours ce **commentaire avant de commencer à coder** la fonction.
 
 ## 3. Types somme
 
 ### 3.1 Définitions de types somme
 
-Les types somme en OCaml sont des types dont les valeurs peuvent être construites de différentes manières. L'exemple suivant illustre la syntaxe de définition de ces types:
+Les types somme en OCaml sont des types dont les valeurs peuvent être construites de différentes manières.
+L'exemple suivant illustre la syntaxe de définition de ces types :
 
 ```ocaml
 type couleur = Rouge | Jaune | Bleu;;
@@ -239,7 +239,7 @@ DeuxInt (3,4);;
 
 Remarque: quand on passe plusieurs arguments à un constructeur, ils sont passés sous forme de n-uplet (une paire pour `DeuxInt` et un triplet pour `RJB`). Les n-uplets sont prédéfinis en OCaml et possèdent leur propre type dont la syntaxe est `*`
 
-> En utilisant l'interpréteur, indiquer quel est le type de `(3, 5.6)`. Quelle est la différence avec `(3,5,6)` ?
+> En utilisant l'interpréteur, indiquer quel est le type de `(3, 5.6)`. Quelle est la différence avec `(3, 5, 6)` ?
 
 ### 3.2 Pattern matching
 
@@ -258,7 +258,7 @@ s'évalue en `"rouge"` si `c` contient `Rouge` ou encore sur `"mélange"` si `c`
 > Définir une fonction `nom_couleur` qui donne le nom d'une couleur sous forme de `string` si c'est une des 6 couleurs nommées ou la chaîne "mélange" par défaut, c'est-à-dire si la couleur est définie par le constructeur `RJB`.
 >
 > Réécrire la fonction `nom_couleur` en supprimant le dernier cas associé à la valeur "mélange", quelle erreur survient ?
-
+>
 > Faire une nouvelle version en plaçant le cas `_` en premier, quel avertissement l'interpréteur affiche-t-il ? Que peut-on en déduire sur l'ordre des cas dans un `match` ?
 
 Dans le cas d'un constructeur avec des arguments, il est souvent utile de pouvoir récupérer la valeur de ceux-ci dans le pattern matching.
@@ -343,14 +343,14 @@ let rec longueur (l: string list): int =
   ;;
 ```
 
-> Expliquer pourquoi on a indiqué \_ au lieu d'une variable dans le deuxième cas du `match`.
-
-> Écrire une fonction sum_f qui fait la somme des éléments d'une `float list`.
+> Expliquer pourquoi on a indiqué `_` au lieu d'une variable dans le deuxième cas du `match`.
+>
+> Écrire une fonction `sum_f` qui fait la somme des éléments d'une `float list`.
 
 Il peut parfois être utile dans un `match` sur une liste pour faire un cas
 particulier avec des liste de taille 1, 2, etc.
 
-> Utiliser la possibilité de faire un `match` avec une cas pour les listes de
+> Utiliser la possibilité de faire un `match` avec un cas pour les listes de
 > taille 1 (en plus du cas liste vide et du cas liste de taille >= 2) pour
 > écrire une fonction `join_s` qui prend en argument un séparateur (de type
 > `string`) et une liste de `string` et renvoie les éléments de la liste
@@ -370,7 +370,7 @@ valeur de liste par cas avec un `match` et fabriquer une liste comme résultat.
 > la liste composée des paragraphes de la chanson _99 bottles of beer_
 > correspondant à chacun des éléments de la liste passée en paramètre. On pourra
 > bien entedu réutiliser la fonction `paragraphe_bottles`.
-
+>
 > Créer une variable globale `chanson_99_bottles` dont la valeur est les paroles
 > complètes de la chanson _99 bottles of beer_. On séparera chaque paragraphe du
 > suivant avec "\n\n". Vérifier que la variable a la bonne valeur en l'affichant