¿Cómo comprobar que la próxima 'cabecera' en OCaml está vacía?

Question

Soy nuevo en OCaml (y todavía soy un novato en la programación de aprendizaje en general) y tengo una pregunta rápida sobre cómo verificar qué tipo de cadena es el siguiente elemento en la lista de cadenas.

Quiero que ponga un separador entre cada elemento de la cadena (excepto el último), pero no puedo averiguar cómo hacer que el programa 'sepa' que el último elemento es el último elemento.

Aquí está mi código como lo es ahora:

let rec join (separator: string) (l : string list) : string = 
begin match l with 
    | []->"" 
    | head::head2::list-> if head2=[] then head^(join separator list) else head^separator^(join separator list) 
end 


let test() : bool = 
(join "," ["a";"b";"c"]) = "a,b,c" 
;; run_test "test_join1" test 

Gracias de antemano!

Answer 1

Ya casi está allí. La idea es desglosar la lista en tres casos en los que tiene 0, 1 o al menos 2 elementos. Cuando la lista tenga más de un elemento, que está a salvo para insertar separator en la cadena de salida:

let rec join (separator: string) (l : string list) : string = 
    begin match l with 
    | [] -> "" 
    | head::[] -> head 
    | head::list-> head^separator^(join separator list) 
    end 

Tengo varios comentarios acerca de su función:

• tipo de anotación es redundante. Como (^) es un operador de concatenación de cadenas, el verificador de tipos puede inferir tipos de separator, l y la salida de la función fácilmente.
• No es necesario utilizar begin/and par. Como solo tiene un nivel de coincidencia de patrones, no hay confusión para el compilador.
• Puede usar function para eliminar match l with parte.

Por lo tanto, el código podría abreviarse como:

let rec join sep l = 
    match l with 
    | [] -> "" 
    | x::[] -> x 
    | x::xs -> x^sep^join sep xs 

o incluso más concisa:

let rec join sep = function 
    | [] -> "" 
    | x::[] -> x 
    | x::xs -> x^sep^join sep xs 

Answer 2

La lista vacía es [], la lista con un elemento es [h] y la lista con al menos un elemento es h::t. Por lo tanto, su función se puede escribir como:

let rec join separator = function 
    | [] -> "" 
    | [h] -> h 
    | h::t -> h^separator^join separator t