Definir firmas recursivas para módulos

Question

Sé que es posible definir módulos recursivas, ¿alguien sabe cómo definir firmas recursivas? Por ejemplo, me gustaría realizar:

module type AAA = sig 
    module Bbb : BBB 
    type 'a t 
    val f : 'a Bbb.t -> 'a t 
end 

module type BBB = sig 
    module Aaa : AAA 
    type 'a t 
    val g : 'a Aaa.t -> 'a t 
end 

¿Alguien podría ayudar?

Answer 1

No se puede, por lo que yo puedo decir. La solución más cercana es la de limitar los bits "recursivos" a lo que realmente se necesita para expresar cada firma por separado:

module type AA = 
sig 
    module B : sig type t end 
    type t 
    val f : unit -> B.t 
end 

module type BB = 
sig 
    module A : sig type t end 
    type t 
    val g : unit -> A.t 
end 

Y luego refinar cuando se definen los módulos:

module rec A : AA with module B = B = 
struct 
    module B = B 
    type t = int 
    let f() = B.g() 
end 
and B : BB with module A = A = 
struct 
    module A = A 
    type t = int 
    let g() = A.f() 
end 

Fwiw, uno podría pensar que debe ser posible expresar firmas recursivas (con mucha repetición) mediante el uso de módulos recursivas:

module rec AA : 
sig 
    module type T = sig module B : BB.T end 
end = 
struct 
    module type T = sig module B : BB.T end 
end 
and BB : 
sig 
    module type T = sig module A : AA.T end 
end = 
struct 
    module type T = sig module A : AA.T end 
end 

sin embargo, eso no funciona:

Error: Unbound module type BB.T 

Answer 2

se puede escribir algo así:

module rec Aaa : sig 
    type 'a t 
    val f : 'a Bbb.t -> 'a t 
end = Aaa 
and Bbb : sig 
    type 'a t 
    val g : 'a Aaa.t -> 'a t 
end = Bbb