Comment faire correspondre sur les constructeurs de types de données abstraites OCAML

Question

1) J'ai ce type de module

module type MOD_SIG = sig type t val min val max;; 

2) Je crée deux modules basés sur la signature ci-dessus

module MOD_UINT8 = struct 
    type t = int32 
    let min = Int32.of_int 0 
    let max = Int32.of_int 255 end;; 

module MOD_UINT32 = struct 
    type t = int64 
    let min = Int64.zero 
    let max = Int64.of_int 4294967295 end ;; 

3) J'ai créé modules de première classe de 2

let uint_8 = (module MOD_UINT8:MOD_SIG);; 
let uint_32 = (module MOD_UINT32:MOD_SIG);; 

4) Je veux écrire une fonction qui accepte un module de premier ordre en tant que arg et tente de ma tch si une valeur particulière dans ce module était de Int32 ou Int64.

tels que

let module M=(val m:MOD_SIG) in match M.t with 
    | Int32 -> "Int32" 
    | Int64 -> "Int64" 

I appris de @octachron qu'il ne soit pas possible. Bien que je voulais juste soulever cette question pour comprendre, s'il pourrait y avoir une solution de contournement?

Answer 1

Eh bien, vous pourriez peut-être ajouter à vos modules une fonction qui indique que leur valeur particulière est:

type pv = I8 | I32 | I64 

module type MOD_SIG = sig 
    type t 
    val min 
    val max 
    val which_pv : pv 
;; 

module MOD_UINT8 = struct 
    type t = int32 
    let min = Int32.of_int 0 
    let max = Int32.of_int 255 
    let which_pv = I8 
end;; 

module MOD_UINT32 = struct 
    type t = int64 
    let min = Int64.zero 
    let max = Int64.of_int 4294967295 
    let which_pv = I64 
end;; 

---

En fait, parfois votre fonction dépend de ce que exactement le type t est et c'est là foncteurs apparaît. Disons, par exemple, que vous voulez implémenter un module sur des nombres qui peuvent être entiers, entiers non signés, flottants ... Dans ce cas, les opérations de base dépendent du type exact et un foncteur serait mieux ici:

module type NSig = sig 
    type t 
    val zero : t 
    val one : t 
    val min : t 
    val max : t 
    val add : t -> t -> t 
    val mult : t -> t -> t 
end;; 

module MNumb (N : NSig) = struct 
    type t = N.t 
    let min = N.min 
    let max = N.max 
    let add = N.add 
    let mult = N.mult 
    let rec pow t n = 
    if n = 0 then N.one 
    else if n = 1 then t 
    else let tt = pow t (n/2) in 
     if n mod 2 = 0 then tt else mult t tt 
end;; 

Comme vous pouvez le voir, pour créer pow je dois savoir comment 1 est représenté et mult aussi, mais depuis pow n'est pas une fonction de base , je crée dans le foncteur. Il vous suffit donc de donner à votre foncteur les bases de votre type (int8, int32, int64, float, fractions ...) et de l'alimenter au foncteur pour créer les fonctions les plus avancées.