Affinement de la signature d'un module imbriqué dans la signature du parent

Question

J'ai un fichier ML qui contient un module imbriqué. Par exemple:

let f n = n + 1 

module type M_type = sig 
    val g : int -> int 
    val h : int -> int 
end 

module M : M_type = struct 
    let g n = n + 2 
    let h n = n + 3 
end 

let j n = n |> M.h |> M.g |> f 

Lorsque vous rédigez un MLI pour cette ML, je souhaite ne pas exposer M.h, mais je ne veux exposer M.g.

tels que les suivants:

module type M_type = sig 
    val g : int -> int 
end 

module M : M_type 

val j : int -> int 

La combinaison ci-dessus de ML et MLI ne compile pas.

L'idée est que mon module imbriqué M contient certaines fonctions que je souhaite exposer à d'autres fonctions dans le module parent, mais pas à un utilisateur du module parent.

Existe-t-il un moyen légal d'y parvenir? S'il n'y en a pas, quelle est la meilleure alternative pour réaliser ce genre de rétrécissement de la signature?

Merci!

Answer 1

Si vous regardez attentivement l'erreur du compilateur:

Module type declarations do not match: 
     module type M_type = sig val g : int -> int val h : int -> int end 
     does not match 
     module type M_type = sig val g : int -> int end 

vous verrez que le compilateur ne se plaint pas du module M, mais sur le type de module M_type.

En effet, la définition des deux type de module ne correspond pas:

module type M_type = sig 
    val g : int -> int 
    val h : int -> int 
end 

est pas compatible avec

module type M_type = sig 
    val g : int -> int 
end 

Il y a plusieurs façons de résoudre ce problème. Une possibilité est de ne pas utiliser le type de module comme contrainte de signature lorsque unneccessary: ​​

(* a.ml *) 
module M = struct 
    let g n = n + 2 
    let h n = n + 3 
end 

De même, le fichier MLI peut être écrit comme

(*a.mli*)  
module M : sig val g: int -> int end 

Une autre possibilité est de ne définir le type de module contraint

(* a.ml *) 
module type M_type = sig val g: int -> int end 
module M: sig include M_type val h: int -> int end = 
(* Note that the signature constraint above is not necessary *) 
struct 
    let g n = n + 2 
    let h n = n + 3 
end 

avec le fichier associé MLI:

(*a.mli*) 
module type M_type = sig val h: int -> int end  
module M : sig val g: int -> int end 

Il est également possible de définir un type de module étendu EXT pour le fichier .ml:

module type M_type = sig val g: int -> int end 
module type EXT = sig include M_type val h: int -> int end 
module M: EXT = struct 
    let g n = n + 2 
    let h n = n + 3 
end