Error de sintaxis de Ocaml

Question

Estoy usando una implementación de listas perezosas donde el tipo puede ser Nil o Cons (value, thunk) , donde thunk es una función de la unidad al resto de la lista.

Estoy tratando de escribir una función cross , que funcionaría como lo hace List.combine . Lamentablemente, tengo errores de sintaxis.

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 ())))

Esto produce el error:

Error: Unbound value seq1

¿Qué estoy haciendo mal?

UPDATE:

Este tipo verifica, pero no es del tipo que estoy buscando.

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>

Este no es el tipo de cruz que quiero. Estoy buscando:

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

Answer 1

te vas a patear a ti mismo ... ¿dónde se define seq1?

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

Define el tipo de cruz, pero no vincula las variables a nada (supongo, puede decir eso).

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

EDIT:

Creo que tu coincidencia está bien, no coincide. Usa bloques begin ... end alrededor de los casos, creo que lo que está sucediendo (y como no tengo Sequence, no puedo verificar) es que los casos de coincidencia que pretendes para la coincidencia externa están siendo aplicado al interior, haciendo coincidir seq2. por ejemplo,

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

Aunque, espacialmente, se ve bien, la segunda coincidencia, match y con está vinculada con | 2 - > ... mayúsculas y minúsculas. Aquí hay una versión con las palabras clave being ... end que rodean los casos de coincidencia. El segundo comienzo ... el final no es necesario, pero probablemente sea una buena idea hacerlo de todos modos para mayor claridad.

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

en la primera línea, está intentando hacer coincidir con seq1, pero este valor no está consolidado, lo que significa que no se encuentra en ningún lado.

Eso es exactamente lo mismo que:

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

Tienes que nombrar tus argumentos.

Answer 3

Para su pregunta actualizada, la razón por la que los tipos son 'a Sequence.t Sequence.t se debe a la línea

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

Recuerde que Nil es una secuencia en sí misma, por lo que al poner eso obliga a todos los elementos de las secuencias de entrada a ser secuencias también.

Answer 4

Este error ocurre cuando ha mencionado un nombre que no ha sido definido (técnicamente & # 8220; vinculado a un valor & # 8221;). Esto puede suceder si ha escrito mal el nombre.