ओकैम में 'और' कीवर्ड का क्या अर्थ है?

Question

मैं ओसीएमएल में and कीवर्ड द्वारा रहस्यमय हूं। this code के माध्यम से देख रहे हैं, मैं

type env = { 
    (* fields for a local environment described here *) 
} 

and genv { 
    (* fields for a global environment here *) 
} 

देख तो later,

let rec debug stack env (r, ty) = (* a function definition *) 

and debugl stack env x = (* another function definition *) 

यहाँ क्या हो रहा है? क्या and कीवर्ड सिर्फ अंतिम type, let, या let rec कथन की प्रतिलिपि बनाएँ? क्या and rec कथन जैसी कोई चीज है? let या type टाइप करने के बजाय, मैं अपने कोड को कम करने के लिए कम भंगुर बनाने के बजाय and का उपयोग क्यों करना चाहूंगा? क्या मुझे कुछ और पता होना चाहिए?

Answer 1

and कीवर्ड को कई let से बचने के लिए या तो प्रयोग किया जाता है या प्रकार, कार्य, मॉड्यूल की परस्पर पुनरावर्ती परिभाषा के लिए (पहला उदाहरण है, मैं इस पर क्यों नहीं करने के लिए इसका इस्तेमाल करते हैं कभी नहीं) ...

आप देख सकते हैं

let rec debug stack env (r, ty) = 
    ... 
    | Tunresolved tyl -> o "intersect("; debugl stack env tyl; o ")" 
    ... 

and debugl stack env x = 
    ... 
    | [x] -> debug stack env x 
    ... 

debug कॉल debugl और इसके विपरीत: अपने दूसरे उदाहरण में। तो and इसकी अनुमति दे रहा है।

[संपादित करें] यह मुझे परेशान एक उचित उदाहरण देने के लिए नहीं तो यहाँ एक उदाहरण है कि आप अक्सर देखेंगे:

let rec is_even x = 
    if x = 0 then true else is_odd (x - 1) 
and is_odd x = 
    if x = 0 then false else is_even (x - 1) 

परस्पर पुनरावर्ती के लिए (आप इस उदाहरण here पा सकते हैं) प्रकार, यह एक विन्यास लेकिन निम्नलिखित this wikipedia page हम trees और forests परिभाषित करेंगे खोजने के लिए कठिन है का पालन के रूप में

type 'a tree = Empty | Node of 'a * 'a forest 
and 'a forest = Nil | Cons of 'a tree * 'a forest 

उदाहरण के लिए, खाली पेड़ से बना एक जंगल, सिंगलटन पेड़ 'एक' लेबल और लेबल 'बी' और 'सी' के साथ एक दो नोड्स पेड़ तो के रूप में प्रतिनिधित्व किया जाएगा:

let f1 = Cons (Empty, (* Empty tree *) 
      Cons (Node ('a', (* Singleton tree *) 
         Nil), (* End of the first tree *) 
        Cons (Node ('b', (* Tree composed by 'b'... *) 
           Cons (Node ('c', (* and 'c' *) 
              Nil), 
            Nil) 
          ), 
         Nil (* End ot the second tree *) 
        ) 
       ) 
     );; 

और आकार समारोह (वन में नोड्स की संख्या की गणना) होगा:

let rec size_tree = function 
    | Empty -> 0 
    | Node (_, f) -> 1 + size_forest f 
and size_forest = function 
    | Nil -> 0 
    | Cons (t, f) -> size_tree t + size_forest f 

और हम

# size_forest f1;; 
- : int = 3 

मिल