Errore di sintassi di Ocaml

Question

Sto utilizzando un'implementazione di liste pigre in cui il tipo può essere Nil o Contro (valore, thunk) , dove thunk è una funzione dall'unità al resto dell'elenco.

Sto provando a scrivere una funzione cross , che funzionerebbe come List.combine . Sfortunatamente, sto riscontrando errori di sintassi.

open Sequence;;
    let rec (cross : 'a Sequence.t -> 'b Sequence.t -> ('a * 'b) Sequence.t) = match seq1 with
        Nil -> match seq2 with
            Cons (value2, thunk2) -> Cons ((Nil, value2), function () -> (cross Nil (thunk2 ())))
      | Cons (value1, thunk1) -> match seq2 with
            Nil -> Cons ((value1, Nil), function() -> (cross Nil (thunk1 ())))
          | Cons (value2, thunk2) -> Cons ((value1, value2), function() -> (cross (thunk1 ()) (thunk2 ())))

Questo produce l'errore:

Error: Unbound value seq1

cosa sto sbagliando?

UPDATE:

Questo tipo verifica, ma non è del tipo che sto cercando.

let rec cross (seq1 : 'a Sequence.t) (seq2 : 'b Sequence.t) : ('a * 'b) Sequence.t = match seq1 with
    Nil -> match seq2 with
        Cons (value2, thunk2) -> Cons ((Nil, value2), function () -> (cross Nil (thunk2 ())))
  | Cons (value1, thunk1) -> match seq2 with
        Nil -> Cons ((value1, Nil), function() -> (cross Nil (thunk1 ())))
      | Cons (value2, thunk2) -> Cons ((value1, value2), function() -> (cross (thunk1 ()) (thunk2 ())))

val cross :
  'a Sequence.t Sequence.t ->
  'a Sequence.t Sequence.t -> ('a Sequence.t * 'a Sequence.t) Sequence.t =
  <fun>

Questo non è il tipo di croce che voglio. Sto cercando:

'a Sequence.t -> 'b Sequence.t -> ('a * 'b) Sequence.t

Answer 1

ti prenderai a calci ... dove è definito seq1?

let rec (cross : 'a Sequence.t -> 'b Sequence.t -> ('a * 'b) Sequence.t) =

Definisci il tipo di croce, ma non leghi le variabili a nulla (immagino, puoi dirlo).

let rec cross (seq1:'a Sequence.t) (seq2:'a Sequence.t) :('a * 'b) Sequence.t =

EDIT:

Penso che la tua corrispondenza sia corretta, errata. Usa i blocchi inizia ... fine attorno ai casi, penso che ciò che sta accadendo (e poiché non ho Sequenza, non posso verificare) è che i casi di corrispondenza che intendi per la corrispondenza esterna sono in corso applicato a quello interno, corrispondente a seq2. ad esempio,

match x with
| 0 -> match y with
    | 1 -> "x:0, y:1"
| 2 -> match y with
    | 0 -> "y:0, x:2"

Anche se, spazialmente, sembra a posto, la seconda corrispondenza, abbina y con è associata a | 2 - > ... maiuscole / minuscole. Ecco una versione con le parole chiave essendo ... end che circondano i casi di corrispondenza. Il secondo inizio ... fine non è necessario, ma è probabilmente una buona idea farlo comunque per chiarezza.

match x with 
| 0 -> begin match y with
    | 1 -> "x:0, y:1" end
| 2 -> begin match y with
    | 0 -> "y:0, x:2" end

Answer 2

nella prima riga, stai provando a trovare una corrispondenza con seq1, ma questo valore non è associato, il che significa che non si trova da nessuna parte.

È esattamente lo stesso di:

# let t =
  match t1 with
  _ -> ();;
Error: Unbound value t1

Devi dare un nome ai tuoi argomenti.

Answer 3

Per la tua domanda aggiornata, il motivo per cui i tipi sono 'a Sequence.t Sequence.t è dovuto alla linea

Cons ((Nil, value2), ...)

Ricorda che Nil è una sequenza stessa, quindi mettendola lì costringe anche tutti gli elementi delle sequenze di input ad essere sequenze.

Answer 4

Questo errore si verifica quando hai citato un nome che non è stato definito (tecnicamente “associato a a valore"). Ciò potrebbe accadere se hai digitato male il nome.