Skip to content
Snippets Groups Projects
Commit 59a76468 authored by COQUERY EMMANUEL's avatar COQUERY EMMANUEL
Browse files

Ajout info config TP1

parent 3c3d25c0
No related branches found
No related tags found
No related merge requests found
......@@ -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
......
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment