Précédent Index Suivant

Modules paramétrés

Les modules paramétrés sont aux modules ce que les fonctions sont aux valeurs. Tout comme une fonction construit une nouvelle valeur à partir de valeurs paramètres, un module paramétré permet de construire un nouveau module à partir de modules déjà construits. On donne également le nom de foncteurs aux modules paramétrés.

L'introduction des foncteurs dans le langage des modules permet accroître les possibilités de réutilisation du code défini dans les structures.

Un foncteur se définit avec une syntaxe fonctionnelle.

Syntaxe

functor   ( M : MSIG )    -> Mstruct 

# module Couple = functor ( Q : sig type t end ) -> 
   struct type couple = Q.t * Q.t end ;;
module Couple :
  functor(Q : sig type t end) -> sig type couple = Q.t * Q.t end


Comme pour les fonctions, il existe une syntaxe alternative à la déclaration de foncteurs.

Syntaxe

Module   Nom   ( M : MSIG )   =   Mstruct 

# module Couple ( Q : sig type t end ) =  struct type couple = Q.t * Q.t end ;;
module Couple :
  functor(Q : sig type t end) -> sig type couple = Q.t * Q.t end


Les foncteurs étant des modules, on peut considérer les foncteurs construisant des foncteurs avec des foncteurs à plusieurs paramètres.

Syntaxe

functor ( MStruct1 : MSIG1 )    ->   ...
    functor ( MStructn : MSIGn )    ->       struct ... end
ou

Syntaxe

module Nom (MStruct1 : MSIG1 ) ...... ( MStructn : MSIGn ) =
    struct ...... end


L'application d'un foncteur à ses paramètres se fait selon le schéma syntaxique suivant :

Syntaxe

module M = Fonct (MStruct1) ...(MStructn)
Le résultat de l'application peut être un module simple ou, à nouveau un foncteur, selon le nombre de paramètres réclamés par le foncteur Fonct.

Warning

Il n'est pas possible de créer une signature par application d'une signature << fonctorielle >> à d'autres signatures.


Un foncteur qui explicite complètement sa communication avec d'autres modules, c'est à dire qui ne fait pas référence directement à un élément d'un autre module hormis ses paramètres, est facilement réutilisable. On peut effectivement l'appliquer à différents arguments selon le cadre de son emploi. Il y a un parallèle entre une fonction complètement paramétrée (sans variables libres) et un foncteur complètement paramétré.

Foncteurs et réutilisabilité

La distribution d'Objective CAML fournit trois modules définissant des foncteurs. Deux d'entre eux, prennent comme argument un module fournissant un type de donné totalement ordonné; c'est à dire respectant la signature suivante. 

# module type OrderedType =
   sig
     type t
     val compare: t -> t -> int
   end ;;
module type OrderedType = sig type t val compare : t -> t -> int end
compare prend deux arguments et rend une valeur négative si le premier est inférieur au second, une valeur nulle si ils sont égaux, et une valeur positive si le premier supérieur au second. Voici un exemple de type ordonné. 

# module OrderedIntPair = 
   struct  
     type t = int * int 
     let compare (x1,x2) (y1,y2) = let q = x1-y1 in if q=0 then x2-y2 else q 
   end ;;
module OrderedIntPair :
  sig type t = int * int val compare : int * int -> int * int -> int end
Le foncteur Make du module Map construit un module permettant de construire des tables d'associations ayant comme clés le type ordonné passé en argument. Ce module fournit des services comparables à ceux des listes d'associations du module List mais en utilisant une structure de données légèrement plus complexes (des arbres binaires équilibrés). 

# module AssocIntPair = Map.Make (OrderedIntPair) ;;
module AssocIntPair :
  sig
    type key = OrderedIntPair.t
    and 'a t = 'a Map.Make(OrderedIntPair).t
    val empty : 'a t
    val add : key -> 'a -> 'a t -> 'a t
    val find : key -> 'a t -> 'a
    val remove : key -> 'a t -> 'a t
    val mem : key -> 'a t -> bool
    val iter : (key -> 'a -> unit) -> 'a t -> unit
    val map : ('a -> 'b) -> 'a t -> 'b t
    val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
  end
Le foncteur Make permet de construire des tables d'associations ayant pour clé n'importe quel type de données dont on saura écrire une fonction compare.

Le module Set fournit lui aussi un foncteur Make prenant en argument un type ordonné et construisant un module implantant les ensembles de valeurs de ce type. 

# module SetIntPair = Set.Make (OrderedIntPair) ;;
module SetIntPair :
  sig
    type elt = OrderedIntPair.t
    and t = Set.Make(OrderedIntPair).t
    val empty : t
    val is_empty : t -> bool
    val mem : elt -> t -> bool
    val add : elt -> t -> t
    val singleton : elt -> t
    val remove : elt -> t -> t
    val union : t -> t -> t
    val inter : t -> t -> t
    val diff : t -> t -> t
    val compare : t -> t -> int
    val equal : t -> t -> bool
    val subset : t -> t -> bool
    val iter : (elt -> unit) -> t -> unit
    val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
    val cardinal : t -> int
    val elements : t -> elt list
    val min_elt : t -> elt
    val max_elt : t -> elt
    val choose : t -> elt
  end
Nous avons avec SetIntPair.t un type pour les ensembles de couples d'entiers avec toutes les fonctions classiques sur les ensembles. L'illustration de la réutilisabilité nous est donné en construisant les ensembles d'ensembles de pairs d'entiers. 

# module SetofSet = Set.Make (SetIntPair) ;;

# let x = SetIntPair.singleton (1,2) ;;           (* x = { (1,2) }        *)
val x : SetIntPair.t = <abstr>
# let y = SetofSet.singleton SetIntPair.empty ;;  (* y = { {} }           *)
val y : SetofSet.t = <abstr>
# let z = SetofSet.add x y ;;                     (* z = { {(1,2)} ; {} } *)
val z : SetofSet.t = <abstr>


Le foncteur Make du module Hashtbl fonctionne de manière similaire à celui du module Map mais en construisant des tables de hashage à la place d'arbres équilibrés. L'argument de ce foncteur est un peu différent; outre le type des clés de la table de hash, il doit fournir simplement une fonction testant l'égalité entre deux clés à la place d'une fonction de comparaison. Par contre, il est nécessaire de donner la fonction de hash, c'est à dire une fonction associant un entier à une clé. 

# module type HashedType =
   sig
     type t
     val equal: t -> t -> bool
     val hash: t -> int
   end ;;
module type HashedType =
  sig type t val equal : t -> t -> bool val hash : t -> int end
# module IntMod13 = 
   struct 
     type t = int 
     let equal = (=) 
     let hash x = x mod 13 
   end ;;
module IntMod13 :
  sig type t = int val equal : 'a -> 'a -> bool val hash : int -> int end
# module TblInt = Hashtbl.Make (IntMod13) ;;
module TblInt :
  sig
    type key = IntMod13.t
    and 'a t = 'a Hashtbl.Make(IntMod13).t
    val create : int -> 'a t
    val clear : 'a t -> unit
    val add : 'a t -> key -> 'a -> unit
    val remove : 'a t -> key -> unit
    val find : 'a t -> key -> 'a
    val find_all : 'a t -> key -> 'a list
    val mem : 'a t -> key -> bool
    val iter : (key -> 'a -> unit) -> 'a t -> unit
  end


Déclarations locales de modules

Parmi les extensions du langage, existe la possibilité de déclarer localement un module.

Syntaxe

let module M = Mstruct in expr


Cette construction est principalement utile pour rendre plus clair le code en nommant les modules locaux ou pour instancier un foncteur sans créer de modules.

Par exemple, nous souhaitons utiliser le module Set pour écrire une fonction de tri sur les listes d'entiers en insérant chaque élément de la liste dans un ensemble et en récupérant à la fin la liste des éléments de l'ensemble obtenu. 

# let sort l =
   let module M = 
      struct 
        type t = int  
        let compare = (-) 
      end 
  in
   let module MSet = Set.Make(M) 
  in 
   MSet.elements (List.fold_right MSet.add l MSet.empty) ;;
val sort : int list -> int list = <fun>

# sort [ 5 ; 3 ; 8 ; 7 ; 2 ; 6 ; 1 ; 4 ] ;; 
- : int list = [1; 2; 3; 4; 5; 6; 7; 8]


Objective CAML ne permet pas de faire sortir d'un module local, une valeur ayant un type qui n'est pas connu à l'extérieure de l'expression. 

# let test = 
   let module Foo = 
     struct 
       type t 
       let id x = (x:t)
     end
   in Foo.id ;;
Characters 15-101:
This `let module' expression has type Foo.t -> Foo.t
In this type, the locally bound module name Foo escapes its scope


Précédent Index Suivant