Ocaml

Question

में कन्स्ट्रक्टर नामों का संक्षेप में मेरे पास दो मॉड्यूल हैं। एक एक प्रकार प्रकार परिभाषित करता है:

module A = struct 
    type foo = Bar of material | Baz | Boo 

    (* other stuff *) 
end 

और मैं foo उपयोग करने के लिए की दोनों निर्माताओं के रूप में और एक अन्य मॉड्यूल

module B = struct 
    type foo = A.foo (* I can abbreviate A.foo by assigning it a local alias *) 

    let f (x : foo) = match x with 
    | Bar m  -> Bar (g m) (* Any way to abbreviate Bar and friends? *) 
    | Baz | Boo -> x 
end 

में बाएं हाथ से पक्षों के रूप में लेकिन प्रति "referring to named objects" मैं वेरिएंट सक्षम होने के लिए चाहते हैं एक मॉड्यूल-पथ साथ संस्करण नाम उपसर्ग के लिए है:

let f (x : foo) = match x with 
    | A.Bar m   -> A.Bar (g m) 
    | A.Baz | A.Boo -> x 

वहाँ यू से बचने को छोड़ने के लिए कोई तरीका है मॉड्यूल पथ open आईएनजी से कम और A से अन्य सभी सामानों में खींचें?

Answer 1

आप एक स्थानीय रूप से खोल सकते हैं:

let f (x : foo) = A.(match x with 
    | Bar m  -> Bar (g m) 
    | Baz | Boo -> x) 

या

let f (x : foo) = 
    let open A in 
    match x with 
    | Bar m  -> Bar (g m) 
    | Baz | Boo -> x) 

आप एक submodule में Bar परिभाषित कर सकते हैं ताकि कम चीजों संपर्क में हैं:

module A = struct 
    module BasicDataAndOps = struct 
    type foo = Bar of material | Baz | Boo 
    end 
    open BasicDataAndOps 
    (* other stuff *) 
end 

module B = struct 
    open A.BasicDataAndOps 
    ... 

के बाहर उपयोग के लिए पैटर्न, आप बी में एक "स्मार्ट कन्स्ट्रक्टर" परिभाषित कर सकते हैं:

let bar m = A.Bar m 

ईटीए: मैं आशीष आर्गवाल के उत्तर में वर्णित टाइप परिभाषा को पुन: स्थापित करने की संभावना के बारे में भूल गया: type foo = A.foo = Bar of material | Baz | Boo। यह देखते हुए कि आपके पास पहले से ही आपके उदाहरण में संक्षिप्त नाम है, यह सबसे अच्छा जवाब है।

type-based label disambiguation पर कुछ काम है जो सहायक हो सकता है, लेकिन यह भाषा में स्वीकार नहीं किया जा सकता है।

Answer 2

लुकस्टफी के उत्तरों के अलावा, आप B.foo को परिभाषित करते समय रचनाकारों को फिर से बता सकते हैं।

module A = struct 
    type foo = Bar | Baz 
end 

module B = struct 
    type foo = A.foo = Bar | Baz 

let f (x : foo) = match x with 
    | Bar -> "bar" 
    | Baz -> "baz" 

end