Langage des modules simples

Langage des modules simples

Le langage Objective CAML possède un sous-langage de modules qui vient s'ajouter au noyau du langage. Dans ce cadre, l'interface d'un module est appelée sa signature et son implantation est appelée structure. Lorsqu'il n'y a pas d'ambiguïté, nous utiliserons plutôt le terme << module >> pour désigner la structure.

La syntaxe de déclaration des signatures et des structures est la suivante :

Syntaxe

module type NOM =

sig

déclarations de l'interface

end

Syntaxe

module Nom =

struct

définition de l'implantation

end

Warning

Le nom d'un module doit impérativement commencer par une majuscule. Celui d'une signature est libre, mais par convention on utilise des noms en majuscules.

On peut également utiliser les signatures ou des structures anonymes. On écrit alors simplement :

Syntaxe

sig déclarations end

Syntaxe

struct définitions end

Nous utiliserons les expressions signature et structure pour désigner soit des noms de signature et de structure, soit leur expression anonyme.

Toute structure a par défaut une signature calculée par l'inférence de types qui reprend l'intégralité des définitions contenues dans la structure. On peut lors de la définition d'une structure, préciser quelle est la signature attendue en rajoutant une contrainte selon l'une des deux syntaxes suivantes :

Syntaxe

module Nom : signature = structure

Syntaxe

module Nom = (structure : signature)

Lorsqu'une signature attendue est précisée, le système vérifie que tout ce qui est déclaré dans la signature est défini dans la structure Nom et que les types sont cohérents. En d'autres termes, la signature attendue est incluse dans la signature par défaut. Si tel est le cas, Nom devient un module de signature signature et, de façon analogue à ce qui se passait avec les fichiers d'interface, seules les déclarations apparaissant dans la signature sont accessibles à l'utilisateur du module.

L'accès aux entités déclarées d'un module se fait en utilisant la notation pointée :

Syntaxe

Nom₁.nom₂

On dit alors que le nom nom₂ est qualifié.

On peut rendre implicite le nom du module en utilisant la directive d'ouverture des modules :

Syntaxe

open Nom

Dès lors, on peut utiliser les noms des entités sans les qualifier. L'ouverture d'un module provoque, en cas d'identité de nom, le masquage des entités préalablement définies, à la façon des redéfinitions d'identificateurs.

Deux modules pour les piles

Reprenons les piles en utilisant le langage des modules. Nous commençons par définir la signature d'une pile en reprenant les déclarations du fichier stack.mli :


# module type STACK =
   sig
     type 'a t
     exception Empty
     val create: unit -> 'a t
     val push: 'a -> 'a t -> unit
     val pop: 'a t -> 'a
     val clear : 'a t -> unit
     val length: 'a t -> int
     val iter: ('a -> unit) -> 'a t -> unit
   end ;;
module type STACK =
  sig
    type 'a t
    exception Empty
    val create : unit -> 'a t
    val push : 'a -> 'a t -> unit
    val pop : 'a t -> 'a
    val clear : 'a t -> unit
    val length : 'a t -> int
    val iter : ('a -> unit) -> 'a t -> unit
  end

On obtient une première implantation des piles en utilisant le module de la bibliothèque standard :


# module Stack_distrib = Stack ;;
module Stack_distrib :
  sig
    type 'a t = 'a Stack.t
    exception Empty
    val create : unit -> 'a t
    val push : 'a -> 'a t -> unit
    val pop : 'a t -> 'a
    val clear : 'a t -> unit
    val length : 'a t -> int
    val iter : ('a -> unit) -> 'a t -> unit
  end

On en définit une seconde utilisant des tableaux :


# module Stack_perso =
   struct
     type 'a t = { mutable sp : int; mutable c : 'a array }
     exception Empty
     let create () = { sp=0 ; c = [||] }
     let clear s = s.sp <- 0; s.c <- [||]
     let size = 5 
     let increase s =  s.c <- Array.append s.c (Array.create size s.c.(0))
     let push x s = 
       if s.c = [||] then ( s.c <- Array.create size x; s.sp <- succ s.sp )
       else  ( (if s.sp = Array.length s.c then increase s) ; 
               s.c.(s.sp) <- x ; 
               s.sp <- succ s.sp  )
     let pop s = if s.sp =0 then raise Empty
                 else let x = s.c.(s.sp) in s.sp <- pred s.sp ; x
     let length s = s.sp
     let iter f s = for i=0 to pred s.sp do f s.c.(i) done
   end ;;
module Stack_perso :
  sig
    type 'a t = { mutable sp: int; mutable c: 'a array }
    exception Empty
    val create : unit -> 'a t
    val clear : 'a t -> unit
    val size : int
    val increase : 'a t -> unit
    val push : 'a -> 'a t -> unit
    val pop : 'a t -> 'a
    val length : 'a t -> int
    val iter : ('a -> 'b) -> 'a t -> unit
  end

Les deux modules utilisent un type concret différent pour implanter le type t.


# Stack_distrib.create () ;;
- : '_a Stack_distrib.t = <abstr>
# Stack_perso.create () ;;
- : '_a Stack_perso.t = {Stack_perso.sp=0; Stack_perso.c=[||]}

On retrouve l'abstraction de type en forçant la signature du second module.


# module Stack_perso = (Stack_perso : STACK) ;;
module Stack_perso : STACK
# Stack_perso.create() ;;
- : '_a Stack_perso.t = <abstr>

Les deux modules Stack_perso et Stack_distrib n'ont en commun que le nom des fonctions qu'ils implantent. Par contre, leurs types sont différents; il n'est donc pas possible d'utiliser les fonctions de l'un pour manipuler les valeurs de l'autre :


# let s = Stack_distrib.create() ;;
val s : '_a Stack_distrib.t = <abstr>
# Stack_perso.push 0 s ;;
Characters 19-20:
This expression has type 'a Stack_distrib.t = 'a Stack.t
but is here used with type int Stack_perso.t

Même si les deux modules avaient possédé un type t de même implantation, le fait d'abstraire ce type en contraignant le module avec la signature STACK interdit la possibilité de partager les valeurs entre les deux modules.


# module S1 = ( Stack_perso : STACK ) ;;
module S1 : STACK
# module S2 = ( Stack_perso : STACK ) ;;
module S2 : STACK
# let s = S1.create () ;;
val s : '_a S1.t = <abstr>
# S2.push 0 s ;;
Characters 10-11:
This expression has type 'a S1.t but is here used with type int S2.t

Objective CAML ne dispose pour vérifier la compatibilité des types que de leur nom (leur implantation étant abstraite) et ici ils sont différents : S1.t et S2.t. C'est précisément cette restriction qui permet l'abstraction de type en interdisant l'accès à la définition des types dont on veut masquer l'implantation.

Modules et portée lexicale

Nous donnons dans ce paragraphe deux exemples d'utilisation de signatures pour masquer certaines déclarations.

Masquage de types

Abstraire un type permet de restreindre ses valeurs à celles qu'il est possible de construire avec les fonctions que déclare la signature du module où ce type est définit. Dans l'exemple suivant, nous obtenons des entiers dont la construction nous assure qu'ils sont obligatoirement différents de 0.

 
# module Int_Star = 
   ( struct
       type t = int 
       exception Isnul
       let of_int = function 0 -> raise Isnul | n -> n
       let mult = (+) 
     end
   : 
     sig
       type t
       exception Isnul
       val of_int : int -> t 
       val mult : t -> t -> t 
     end
   ) ;;
module Int_Star :
  sig type t exception Isnul val of_int : int -> t val mult : t -> t -> t end

Masquage de valeurs

Le masquage d'une valeur permet de réaliser un générateur de symboles analogue à celui vu page ??.

On définit la signature GENSYM contenant seulement deux déclarations de fonctions pour la génération de symboles.


# module type GENSYM = 
   sig
     val reset : unit -> unit
     val next : string -> string 
   end ;;

On implante ensuite une structure cohérente pour une telle signature :


# module Gensym : GENSYM = 
   struct 
     let c = ref 0
     let reset () = c:=0
     let next s = incr c ; s ^ (string_of_int !c)
  end;;
module Gensym : GENSYM

La référence c de la structure Gensym n'est pas accessible en dehors des deux fonctions exportées.


# Gensym.reset();;
- : unit = ()
# Gensym.next "T";;
- : string = "T1"
# Gensym.next "X";;
- : string = "X2"
# Gensym.reset();;
- : unit = ()
# Gensym.next "U";;
- : string = "U1"
# Gensym.c;;
Characters 0-8:
Unbound value Gensym.c

La déclaration de c peut être considérée comme locale à la structure module Gensym puisqu'elle est masquée par la signature associée au module. La contrainte de signature nous a permis de reproduire plus simplement la définition des fonctions reset_s et new_s qui utilisaient une déclaration locale (voir page ??).

Différentes vues d'un même module

Le langage de module avec contraintes de signature permet d'offrir plusieurs vues d'une même structure. On pourra, par exemple avoir un << super-utilisateur >> du module Gensym qui est capable de remettre à jour le compteur et un utilisateur ordinaire qui ne peut que créer un nouveau symbole sans maîtriser le compteur. Pour obtenir ce dernier, il suffit de poser la signature :


# module type USER_GENSYM =
   sig
     val next : string -> string 
   end;;

On crée ensuite le module correspondant par la déclaration :


# module UserGensym = (Gensym : USER_GENSYM) ;;
module UserGensym : USER_GENSYM
# UserGensym.next "U" ;;
- : string = "U2"
# UserGensym.reset() ;;
Characters 0-16:
Unbound value UserGensym.reset

Pour réaliser ce nouveau module on a réutilisé le module Gensym. De plus, les deux modules partagent le même compteur :


# Gensym.next "U" ;;
- : string = "U3"
# Gensym.reset() ;;
- : unit = ()
# UserGensym.next "V" ;;
- : string = "V1"

Partage de types entre modules

L'incompatibilité entre types abstraits signalée un peu avant (page ??) pose problème lorsque l'on désire partager un type abstrait entre plusieurs modules. Nous examinons deux façons de procéder au partage. L'une est une construction explicite du langage de modules, l'autre utilise la structure de bloc lexical des modules.

Partage par contrainte

Illustrons le problème à l'aide du petit exemple suivant. On définit un module M qui fournit un type abstrait M.t. Nous le restreignons ensuite selon deux signatures différentes n'autorisant pas les mêmes opérations.


# module M = 
 ( 
   struct
     type t = int ref
     let create() = ref 0
     let add x = incr x
     let get x = if !x>0 then (decr x; 1) else failwith "Empty"
   end
   :
   sig
     type t
     val create : unit -> t
     val add : t -> unit
     val get : t -> int 
   end 
 ) ;;

# module type S1 = 
   sig
     type t
     val create : unit -> t
     val add : t -> unit
   end ;;

# module type S2 =
   sig
     type t
     val get : t -> int
   end ;;
# module M1 = (M:S1) ;;
module M1 : S1
# module M2 = (M:S2) ;;
module M2 : S2

Pour obtenir l'identification désirée des types M1.t et M2.t, Objective CAML dispose d'une syntaxe pour contraindre un type normalement abstrait dans une signature.

Syntaxe

NOM with type t₁ = t₂ and ...

Il s'agit d'une contrainte de type forçant le type t₁ déclaré par la signature NOM à être égal au type t₂.

On peut poser des contraintes globales sur tous les types d'un module en utilisant la contrainte :

Syntaxe

with module Nom₁ = Nom₂

En utilisant de telles contraintes de partage, on peut déclarer les deux modules M1 et M2 comme manipulant la même structure de données.


# module M1 = (M:S1 with type t = M.t) ;;
module M1 : sig type t = M.t val create : unit -> t val add : t -> unit end
# module M2 = (M:S2 with type t = M.t) ;;
module M2 : sig type t = M.t val get : t -> int end
# let x = M1.create() in M1.add x ;  M2.get x ;;
- : int = 1

Partage et sous-modules

Une autre solution pour assurer le partage de type est d'utiliser le mécanisme des sous-modules. En définissant deux sous-modules (M1 et M2) partageant un type de données abstrait d'un module englobant M, nous pouvons parvenir au résultat souhaité.


# module M = 
   ( struct 
       type t = int ref 
       module M_hide = 
         struct 
           let create() = ref 0
           let add x = incr x
           let get x = if !x>0 then (decr x; 1) else failwith"Empty"
         end 
       module M1 = M_hide 
       module M2 = M_hide 
     end 
    :
     sig
       type t
       module M1 : sig  val create : unit -> t  val add : t -> unit end
       module M2 : sig  val get : t -> int  end 
     end ) ;;
module M :
  sig
    type t
    module M1 : sig val create : unit -> t val add : t -> unit end
    module M2 : sig val get : t -> int end
  end

On obtient bien le résultat voulu et une valeur créée par M1 peut être manipulée par M2 :


# let x = M.M1.create() ;;
val x : M.t = <abstr>
# M.M1.add x ; M.M2.get x ;;
- : int = 1

On rajoute cependant un peu de lourdeur par rapport à la solution précédente : l'accès aux fonctions de M1 et M2 se fait via le module englobant M.

Modules simples et extension

Un module est une entité définie une fois pour toutes. En particulier, lorsque nous définissons un type abstrait à l'aide du mécanisme de modules nous ne pouvons plus en étendre les traitements. En particulier, s'il n'a pas été défini de fonction de création, on ne pourra jamais obtenir de valeur de ce type !

Une façon brutale d'augmenter les traitements fournis par un module est d'éditer les sources et de rajouter ce que l'on désire dans la signature et la structure. Mais alors, on n'a plus du tout affaire au même module et toutes les applications qui utilisaient la version originale du module sont à recompiler. Notons cependant que si la redéfinition des composants du module n'a pas modifié les éléments de l'interface originale, il suffit uniquement de recompiler l'ensemble de l'application sans avoir à modifier ce qui avait été écrit.