मॉड्यूल के लिए रिकर्सिव हस्ताक्षर परिभाषित करें

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