कैसे एक मॉड्यूल हस्ताक्षर जिसका मॉड्यूल कार्यान्वयन एक functor द्वारा parameterized है परिभाषित करने

Question

चलो कहते हैं कि मैं एक मॉड्यूल M एक मॉड्यूल F द्वारा parameterized करते हैं:

module M (F : sig type id type data end) = 
struct 
type idtype = F.id 
type datatype = F.data 
type component = { id : idtype; data : datatype } 
let create id data = { id; data } 
let get_comp_data comp = comp.data 
let get_comp_id comp = comp.id 
end 

इसलिए मैं इसे इस तरह का उपयोग करें:

module F1 = struct type id = int type data = float end 
module MF1 = M(F1) 

let comp = MF1.create 2 5.0 
let id = MF1.get_comp_id comp 

अब, अगर मैं हस्ताक्षर S से मिलान करने के लिए M चाहता हूं:

module type S = 
sig 
    type idtype 
    type datatype 
    type component 
    val create : idtype -> datatype -> component 
    val get_comp_data : component -> datatype 
    val get_comp_id : component -> idtype 
end 

module F1 = struct type id = int type data = float end 
module MF1 = (M(F1) : S) 

let comp = MF1.create 2 5.0 
let id = MF1.get_comp_id comp 

get_comp_data और get_comp_id को परिभाषित करने के लिए मुझे यहां परेशान करता है, मुझे idtype और datatype मॉड्यूल S में निर्दिष्ट करने की आवश्यकता है; अब कल्पना करें कि मेरे पास अन्य प्रकार के M में अपने प्रकार के प्रकार हैं, मेरे पास S में निर्दिष्ट करने के लिए एक दर्जन प्रकार होंगे? क्या इससे बचने का कोई आसान तरीका है?

Answer 1

ऐसा करने का प्राकृतिक तरीका परिभाषा साइट पर मॉड्यूल को सील करना है, उपयोग साइट नहीं। तो फिर तुम सिर्फ एक बार प्रकार साझा करने को व्यक्त करने की जरूरत है:

module M (F : sig type id type data end) : 
    S with type idtype = F.id and datatype = F.data 
    = struct ... end 

यदि आपका functor पैरामीटर अधिक जटिल है तो आप भी सिर्फ एक पूरे मॉड्यूल के बजाय अलग-अलग प्रकार के साझा कर सकते हैं।

module type TYPES = sig type id type data (* ...and more... *) end 

module type S = 
sig 
    module Types : TYPES 
    type component 
    val create : Types.id -> Types.data -> component 
    val get_comp_data : component -> Types.data 
    val get_comp_id : component -> Types.id 
end 

module M (F : TYPES) : S with module Types = F 
    = struct ... end 

या आप भी, हस्ताक्षर ही parameterise कर सकते हैं एक और functor में घोंसले बनाने के: उदाहरण के लिए:

module type TYPES = sig type id type data (* ...and more... *) end 

module S (F : TYPES) = 
struct 
    module type S = 
    sig 
    type component 
    val create : F.id -> F.data -> component 
    val get_comp_data : component -> F.data 
    val get_comp_id : component -> F.id 
    end 
end 

module M (F : TYPES) : S(F).S 
    = struct ... end