定义模块的递归签名

Question

我知道可以定义递归模块，是否有人知道如何定义递归签名？例如，我想知道：

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 

任何人都可以帮忙吗？

Answer 1

你不能，据我可以告诉。最接近的解决方案是限制“递归”位，实际需要的表达单独每个签名：当你定义模块

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 

然后细化：

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，可能会觉得它应该可以通过使用递归的模块来表达递归式签名（有多少重复）：

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 

然而，这并不工作：

Error: Unbound module type BB.T 

Answer 2

你可以写这样的事情：

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