Éléments de syntaxe d'Ocaml

Version & licenses
Creative Commons License

Un peu de syntaxe de base

Guyslain Naves
Définir une variable
  1. (* a : int *)
  2. let a = 42

  4. (* almost_pi : float *)
  5. let almost_pi = 3.14
  6. let google = 1e100
  7. (* Les littéraux flottants se reconnaissent au point ou à l'exposant.
  8. * Les noms de variables se composent avec des _ de préférence
  9. *)

  11. (* cheers : string *)
  12. let cheers = "Hello world!"

  14. (* définition de variables locales a et b *)
  15. let result =
  16. let a = 28 in
  17. let b = 14 in
  18. a + b
Définir une fonction
  1. (* plusieurs syntaxes absolument équivalentes *)
  2. let sum = fun a -> fun b -> a + b (* la forme générale *)
  3. let sum = fun a b -> a + b
  4. let sum a b = a + b (* plus concis et plus lisible *)

  6. (* Il n'est pas nécessaire de donner un nom aux fonctions en Ocaml : *)
  7. let result = (fun x -> 2 * x) 21 (* result = 42 *)

  9. (* pour une fonction récursive, ajouter rec après le let *)
  10. let rec fact n =
  11. if n = 0 then 1
  12. else n * fact (n-1)
Appliquer une fonction
  1. (* une fonction à trois arguments *)
  2. let f x y z = (x + y) * z

  4. let result = f 1 4 3 (* result = 15 *)
  5. let result = f 1 (2 * 2) (f 3 (-2) 3) (* result = 15 *)
  6. (* Les parenthèses délimitent chaque argument individuellement.
  7. * Elles sont nécessaires dès qu'un argument est non-élémentaire.
  8. *)

  10. (* Quelques fonctions *)
  11. let incr x = x + 1
  12. let double x = 2 * x
  13. let mult x y = x * y
  14. (* Et leur utilisation : *)

  16. let a = (* syntaxe parenthésée (suffit en général) *)
  17. mult 3 (double (incr 6))
  18. let a = (* syntaxe avec pipes (pour enchaîner des fonctions) *)
  19. 6
  20. |> incr
  21. |> double
  22. |> mult 3
  23. let a = (* syntaxe avec application explicite *)
  24. mult 3 @@ double @@ incr @@ 6
Utiliser des labels pour les arguments

Avantage désiré : meilleure lisibilité au niveau du code appelant la fonction. Nous utilisons donc les labels dès que nous avons une fonction prenant des arguments nombreux et/ou compliqués, ou pouvant être confondu facilement (par exemple hauteur et largeur). Permet aussi de pouvoir mettre les arguments dans n'importe quel ordre, s'ils sont tous nommés.

  1. (* apply : f:('any -> 'result) -> argument:'any -> 'result *)
  2. let apply ~f ~x = f x
  3. (* Pour créer des arguments avec label, il suffit d'ajouter ~ devant leur nom.
  4. * Attention, pas de ~ dans le type, mais on indique les noms des arguments.
  5. *)

  7. let result = apply ~f:sqrt ~argument:4. (* result = 2.0 *)
  8. (* Pour appliquer la fonction, on indique les labels. *)

  10. let result = apply ~argument:9. ~f:sqrt (* result = 3.0 *)
  11. (* Un avantage est de pouvoir changer l'ordre des arguments *)

  13. let f = sqrt
  14. let argument = 16.
  15. let result = apply ~f ~argument
  16. (* si le label porte le même nom qu'une variable contenant la
  17. * valeur à passer en argument, on l'écrit plus simplement.
  18. *)
Couples et uplets.
  1. let vector = (1.,-2.)
  2. (* La syntaxe [(<expr>,<expr>)] permet de créer un couple *)

  4. let left (x,y) = x
  5. (* la même syntaxe peut être utilisé en place d'un argument,
  6. * pour accéder aux deux valeurs du couple.
  7. *)

  9. let right couple =
  10. let (x,y) = couple in y
  11. (* Ici, [couple] est le nom d'une variable qui contient un couple.
  12. * On peut utiliser une variable locale pour récupérer
  13. * le contenu d'un couple.
  14. *)

  16. (* La même syntaxe s'étend aux triplets, etc. *)
  17. let triplet = ("John", "Doe", 1992)
  18. (* Les couples et triplets peuvent avoir leurs
  19. * composantes de types différents
  20. *)
Les listes

En programmation fonctionnelle, les tableaux ne sont pas une structure fondamentale et élémentaire. Pour coder des ensembles d'éléments, on utilise les listes.

  1. (* :: est l'opérateur d'insertion en début de liste,
  2. * [] est la liste vide.
  3. *)
  4. let ints = 1::2::3::4::[]

  6. (* Pour donner une liste explicitement, une autre syntaxe est possible : *)
  7. let chars = ['a';'b';'c';'d']

  9. (* Attention, la liste suivante ne contient qu'un élément, un triplet *)
  10. let erroneous = ['a','b','c'] (* = [('a','b','c')] *)

  12. (* Les éléments d'une liste doivent être du même type *)
  13. let forbidden = ['a';1;0.0] (* erreur *)

Pour obtenir le contenu d'une liste, il faut utiliser la construction match <expr> with. Souvent, on préfère utiliser les fonctions du module List.

  1. let rec length list =
  2. match list with
  3. | [] -> 0
  4. | first::others -> 1 + length others
  5. (* [first] prend la valeur du premier élément,
  6. * [others] est la liste des éléments suivants
  7. *)