Fiche du langage Caml
Nom : Caml (Categorical Abstract Machine Language).
Auteurs : INRIA, 1985.
Versions utilisées : OCaml (ou OCamlWin) 4.01.0.
Sites webs : Caml à l'INRIA.
Paradigme : Langage fonctionnel (fortement et) strictement typé à inférence de types,
avec fonctionnalités impératives.
Compilation : Interpréteurs pour Linux, Windows, Unix, MacOS X.
Terminateur d'instruction : ;;
Commentaire : (* *)
Arrêt de l'interpréteur : exit(0);;
Types de données élémentaires :
unit :
Valeur unique : ()
ce type est utilisé formellement pour une fonction de zéro variable :
let f()=...
- Booléen (voir la comparaison dans le schéma alternatif) :
Nom : bool
Valeurs : true false
Opérateurs logiques : not
|| (OU)
&& (ET, ne pas utiliser and !!)
- Entier :
Nom : int
Valeurs : [–2n-1..2n-1[ (pour un codage sur n bits)
Constantes : min_int max_int
Opérateurs : + –
* / (DIV)
mod
Fonctions : float_of_int
char_of_int ...
- Réel :
Nom : float
Valeurs : [min_float;max_float] (précision dépendant du processeur)
Opérateurs : +. –.
*. /. (ne pas oublier le point!)
** (puissance réelle)
Fonctions : int_of_float (partie entière) ...
- Caractère :
Nom : char
Valeurs : caractères de code ASCII étendu 0 à 255 (N.B. problème des caractères accentués)
Délimiteur de constante : apostrophe (exemple : 'a')
Constantes : \n \t
etc.
Fonctions : int_of_char ...
- Chaîne de caractère :
Nom : string
Délimiteur de constante : guillemets (exemple : "abcdef")
Opérateurs : ^ (concaténation)
.[n] (n+1-ième caractère de la chaîne :
"bonjour".[0];; → - : char = 'b')
Fonctions : String.length
Variables :
- Nommage : un identificateur de variable commence par une lettre minuscule
non accentuée (lexique sensible à la casse)
- Affectation :
let v=4;;
→ val v : int = 4
avec inférence de type :
let w=v+3;; (w est de type entier)
let w="abcdef";; (w devient de type chaîne)
avec typage stricte : 5+3.2;; →
Error: This expression has type float but an expression
was expected of type int
- Affectation locale (contextuelle) :
let v=5 in v+9;;
(la valeur 5 pour v n'est utilisée que dans l'expression v+9)
- Affectation parallèle :
let v=5 and w=6;; →
val v : int = 5 val w : int = 6
let v=5 and w=6 in v+w;;
let x=10 in let y=20 and z=x in x+y+z;;
Le type fonction ( f : x→f(x) ) :
- Opérateur de fonction :
->
(associatif à droite : int->int->int est interprété comme
int ->(int->int))
- Fonction anonyme :
function x-> x+1;;
fun x-> x+1;;
→ -: int->int = <fun>
- Fonction nommée (quatre formes de définition) :
let f = function x -> x+1;;
let f = fun x -> x+1;;
let f(x) = x+1;;
let f x = x+1;;
→ val f : int->int = <fun>
- Fonctions de plusieurs variables :
let g(x,y) = x+y;;
→ val g : int * int -> int = <fun>
(forme cartésienne : (x,y) est un produit cartésien)
let g x y = x+y;;
→val g : int -> int -> int = <fun>
(forme curryfiée : sous forme de liste g x y).
- Récursivité :
let rec fact n = if n=0 then 1 else fact (n-1);;
- Fonctions d'ordre supérieur :
définies comme des fonctions prenant en paramètre une fonction :
let compose f g x = f(g(x));
Fonctions d'ordre supérieur prédéfinies sur les listes :
–
List.map (fun x->x*10) [1;2;3;4]
→ [10;20;30;40]
– List.filter (fun x->x>0) [-1;1;-2;2;-3;3]
→ [1;2;3]
– List.fold_right
– List.fold_left
Types de données élaborés :
- Type énuméré (type somme) :
- Type énuméré simple
type unique = Val;;
(N.B. les constructeurs [càd valeurs du type] commencent par une majuscule : Val)
let x=Vallee;;
→ val x : unique = Vallee
type multiple = Vallee | Montagne | Plateau;;
let y=Montagne;;
→ val y : multiple = Montagne
let z=Vallee;;
→ val z : multiple = Vallee
let (t:unique)=Vallee;;
→ val t : unique = Vallee
(forçage de type)
- Type énuméré avec valuation(s)
type humain = Femme | Homme of int;;
let h = Homme(18);;
type animal = Chien of string | Chat of String;;
let monchien = Chien("Medor")
→ val monchien = Chien "Medor"
- Type produit cartésien :
- Utilisation implicite :
let p = (1.1, 2.2);;
→ val m : float * float = (1.1,2.2)
- Définition et utilisation d'un type :
type point = float * float;;
→ type point = float * float
let p = (1.1, 2.2);;
→ val p : float * float = (1.1,2.2)
let (p:point) = (1.1, 2.2);;
→ val p : point = (1.1,2.2)
(forçage de type)
- Emboitage de type possible :
type adoption = humain * animal;;
type triangle = point * point * point;;
- Fonctions de sélection dans un doublet :
fst(1,2) → - : int = 1
snd(1,2) → - : int = 2
Attention : fst(1,2,3)
→ Error: ...
- Types paramétrés (
'a, 'b, 'c, ...) :
- Type polymorphe :
type 'a boite = Vide | Contient of 'a;;
→ type 'a boite = Vide | Contient of 'a
Contient(6);;
→ - : int boite = Contient 6
Contient('A');;
→ - : char boite = Contient 'A'
Vide;;
→ - : 'a boite = Vide
- Type anonyme (inférence de type impossible)
let f x y = x<y;;
→ val f : 'a -> 'a -> bool = <fun>
let g x y z t = (x<y)||(z<t);;
→ val f : 'a -> 'a -> 'b -> 'b -> bool = <fun>
- Types récursifs :
type poupeerusse = Vide | Contient of poupeerusse;;
let p= Vide;;
let q= Contient (Contient (Contient Vide));;
Le type liste ('a list : liste d'objet d'un même type)
Liste vide : []
Eléments d'un même type séparés par des point-virgules :
[10;-1;3]
['g';'m';'a']
["a";"de";"par";"pour"]
[(1,2);(9,1);(2;7)]
[[1;8;2];[4;6;7]]
Opérateur de concaténation @ :
[1;2]@[3;4;5];; → [1;2;3;4;5]
Opérateur d'ajout en tête :: :
1::[2;3;4];; → [1;2;3;4;]
Schémas de programmation :
-
Schéma alternatif :
- Comparaisons :
une comparaison est une expression valide de type booléen. Exemple :
5>=0;; → -: bool = true
- Opérateurs de comparaison :
= (ne pas utiliser ==)
<> (ne pas utiliser !=)
<= <
>= >
N.B. les mêmes symboles sont utilisés pour int, float, char & string, mais
une comparaison ne peut concerner que deux objets de même type !
- Conditionnelle :
if condition
then conséquence
else alternative
La condition est un booléen correspondant normalement à une comparaison
N.B. L'alternative est obligatoire et doit être du même type que la conséquence :
if v==5 then "cinq" else "autre";;
mais pas if c=='a' then 'A' else "autre";;
-
Schéma sélectif (=filtrage) :
match (x mod 2) with 0 -> "pair" | 1 -> "impair";;
match b with Vide -> 0 | Contient(n) -> n;;
match v with (0,0) -> "origine" | _ -> "autre";;;
match p with (0,0) -> 0 | (0,m) -> m | (n,0) -> n | (n,m) -> n*m ;;;
N.B. le schéma doit être complet en prévoyant tous les cas possibles
(au besoin en utilisant le motif générique _)
Commande optionnelle when :
match s with [] -> 0
| a::b when a<0 -> 1
| a::b -> 0;;
-
Schémas itératifs : ils existent en Caml mais ne doivent pas être utilisées en TD
(Tantque, Répéter, Pour)
...
© 2017-07-01 – A. Sigayret