Cours 1

Htmligure
Version & licenses
Creative Commons License

Un premier exemple

Guyslain
Thursday, 21 July 2016

Retour au sommaire.

Voici un premier exemple d'un fichier source en OCaml.

  1. (* Commentaire : ce fichier s'appelle geometry.ml *)


  4. type vector = float * float


  7. let origin = (0., 0.)

  9. let x_unit = (1., 0.)

  11. let y_unit = (0., 1.)

  13. let vector x y = (x,y)

  15. let translate ~by:(dx,dy) (x,y) = (x +. dx, y +. dy)

  17. let scale alpha (x,y) = (alpha *. x, alpha *. y)

  19. let rotate ~angle (x,y) =
  20. ( cos angle *. x -. sin angle *. y,
  21. sin angle *. x +. cos angle *. y
  22. )

  24. let abscissa = fst

  26. let ordinate = snd


  29. module Circle = struct

  31. type t = vector * float

  33. let unit = (origin, 1.)

  35. let create ~center ~radius = (center, radius)

  37. let translate ~by:vector (center, radius) =
  38. (translate ~by:vector center, radius)

  40. end

Ce fichier définit un type des vecteurs en 2 dimensions, avec quelques opérations associés, et définit ce qu'est un cercle. Sa structure est relativement simple, il s'agit d'une suite de définition de types (vector) introduits par type, de valeurs (origin, x_unit, create, move, etc.) introduites par let et de modules (Circle) introduits par module.

Un module est lui-même une suite de définitions de types, de valeurs et de modules. Les modules permettent de grouper le code en ensemble cohérent. En fait, le fichier lui-même, qui s'appelle ici geometry.ml, définit un module Geometry, contenant toutes les définition du fichier.

Le fichier geometry.ml est accompagné d'un fichier de même nom, mais d'extension mli, donc geometry.mli que voici :

  1. (* geometry.mli *)

  3. (** the type for 2-dimensional vectors. *)
  4. type vector

  6. (** The unit vector, whose coordinates are zero. *)
  7. val unit : vector

  9. (** The x-axis vector. *)
  10. val x_unit : vector

  12. (** The y-axis vector. *)
  13. val y_unit : vector

  15. (** [vector x y] is the vector of coordinates ([x],[y]). *)
  16. val vector : float -> float -> vector


  19. (** [translate ~by:displacement vector] is the vector obtained
  20. by translating [vector] by [displacement].
  21. *)
  22. val translate : by:vector -> vector -> vector


  25. (** [scale factor vector] is the vector obtained by multiplying
  26. each coordinates of [vector] by [factor].
  27. *)
  28. val scale : float -> vector -> vector

  30. (** [rotate ~angle:theta vector] is the voector obtained by
  31. rotation of [vector] by an angle [theta].
  32. *)
  33. val rotate : angle:float -> vector -> vector


  36. (** A module to represent and operate on circles in the plane. *)
  37. module Circle : sig

  39. (** The type of 2-dimensional circles. *)
  40. type t

  42. (** The unit circle, with center at origin, and radius 1. *)
  43. val unit : circle

  45. (** [create ~center ~radius] is a circle with given center and radius. *)
  46. val create : center:vector -> radius:float -> circle

  48. (** [translate ~by:displacement circle] is the circle obtained
  49. by translating the center of [circle] by [displacement]. *)
  50. val translate : by:vector -> circle -> circle

  52. end

Ce fichier décrit ce qui est défini par le module Geometry, sans surprise une liste de types, de valeurs et de modules. Chaque valeur et chaque module est décrit par son type. Les valeurs sont introduites par le mot-clé val, leur identifiant et leur type. Les modules sont décrits par la liste des types, valeurs et modules qu'ils contiennent, de la même façon.

On note que le fichier geometry.mli n'a pas déclaré toutes les valeurs définies dans geometry.ml. Ces valeurs ne sont en fait pas exportées : les valeurs déclarées pourront être utilisées par d'autres modules, celles non-déclarées ne peuvent être utilisées qu'au sein du module Geometry. De même, certains types ou modules auraient pu ne pas être déclarés dans le fichier geometry.mli. De fait, le 'i' de mli tient pour interface : ce fichier décrit comment peut être utilisé le module Geometry. Le fichier d'interface est commenté pour documenter l'utilisation du module associé.

Retour au sommaire.