Co oznacza słowo kluczowe "i" w OCaml?

Question

Jestem mistyfikowany przez słowo kluczowe and w OCaml. Patrząc przez this code widzę

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

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

następnie later,

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

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

Co tu się dzieje? Czy słowo kluczowe and po prostu kopiuje ostatnie oświadczenie type, let lub let rec? Czy istnieje coś takiego jak instrukcja and rec? Dlaczego miałbym używać and zamiast po prostu wpisywać let lub type, czyniąc mój kod mniej kruchym w refaktoryzacji? Czy jest coś jeszcze, o czym powinienem wiedzieć?

Answer 1

and słowo kluczowe jest stosowane zarówno w celu uniknięcia wielokrotnego let (pierwszy przykład, nigdy nie używać go do tego, ale dlaczego nie) lub wzajemnie rekurencyjnych definicji typów, funkcji, modułów ...

Jak widać w drugim przykładzie:

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 połączeń debugl i odwrotnie. Tak więc pozwala na to and.

[EDIT] To nie przeszkadza mi dać odpowiedni przykład tak tutaj jest jednym z przykładów, że będziesz często zobaczyć:

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) 

(Można znaleźć ten przykład here)

Dla wzajemnie rekurencyjne typy, to trudniej znaleźć konfigurację ale po this wikipedia page chcemy zdefiniować trees i forests jak postępować

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

Przykładowo las składa się z pustego drzewa, pojedyncza drzewa oznaczone „A” i dwóch węzłów drzewa etykietami „b” i „c” będzie następnie przedstawiony jako:

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 *) 
        ) 
       ) 
     );; 

i wielkość funkcja (zliczanie liczby węzłów w lesie) byłoby:

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 

i otrzymujemy

# size_forest f1;; 
- : int = 3