Perché la sostituzione distruttiva è disabilitata nell'imballaggio del modulo di prima classe?

Question

Supponiamo questi:

module type Foo = sig 
    type t 
    val foo : t -> t 
end 

module M = struct 
    type t = int 
    let foo t = t + 1 
end 

---

poi faccio:

module type Goo = Foo with type t = int 

module type Hoo = Foo with type t := int 

let x = (module M : Goo) (* correct *) 

let y = (module M : Hoo) (* correct *) 

let z = (module M : Foo with type t = int) (* correct *) 

Soprattutto corretto, nessun problema.

---

Tuttavia, se faccio

let z = (module M : Foo with type t := int) (* wrong *) 

è sbagliato, e l'errore è dato

Error: Parse error: "=" expected after [ident] (in [package_type_cstr])

---

Perché non posso usare := in imballaggio primo modulo di classe ?

Answer 1

In OCaml 4.01 e precedenti, i moduli di prima classe sono nominati nominativamente. In altre parole, il loro tipo è basato sul nome del tipo di modulo utilizzato, non sulla sua struttura. Ad esempio:

 OCaml version 4.01.0 

# module type T = sig type t end;; 
module type T = sig type t end 
# module type S = sig type t end;; 
module type S = sig type t end 
# let f (x : (module T)) : (module S) = x;; 
Characters 38-39: 
    let f (x : (module T)) : (module S) = x;; 
             ^
Error: This expression has type (module T) 
     but an expression was expected of type (module S) 

Ciò richiede che il tipo di modulo ha un nome:

# type t = (module sig type t end);; 
Characters 17-20: 
    type t = (module sig type t end);; 
        ^^^ 
Error: Syntax error 

sostituzione distruttiva è annullato perché crea un nuovo tipo di modulo senza nome. La sostituzione regolare va bene perché S with type t = int, è ancora un S, ne sappiamo solo di più sulla sua definizione. S with type t := int non è un S ha diversi componenti di un S poiché manca un tipo t.

recenti (Mantis, SVN), il controllo tipo di moduli di prima classe è modificata per essere strutturali anziché nominativo:

 OCaml version 4.02.0+dev5-2014-04-29 

# module type T = sig type t end;; 
module type T = sig type t end 
# module type S = sig type t end;; 
module type S = sig type t end 
# let f (x : (module T)) : (module S) = x;; 
val f : (module T) -> (module S) = <fun> 

Ciò significa che i moduli di prim'ordine potrebbero essere creati per i tipi che non avere nome Tuttavia, questo non è stato ancora fatto e non sarà disponibile nella 4.02. Quindi, nelle versioni successive alla 4.02 potrebbe essere effettivamente possibile utilizzare la sostituzione distruttiva nei tipi di moduli di prima classe.