Come controllare il prossimo 'capo' in OCaml è vuoto?

Question

Sono nuovo in OCaml (e sono ancora un principiante nella programmazione dell'apprendimento in generale) e ho una rapida domanda su come controllare quale tipo di stringa sia l'elemento successivo nella lista delle stringhe.

Voglio mettere un separatore tra ogni elemento della stringa (eccetto per l'ultimo), ma non riesco a capire come far sapere al programma che l'ultimo elemento è l'ultimo elemento.

Ecco il mio codice come è ora:

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 

Grazie in anticipo!

Answer 1

Sei quasi arrivato. L'idea è scomporre l'elenco in tre casi in cui ha 0, 1 o almeno 2 elementi. Quando l'elenco ha più di un elemento, sei al sicuro da inserire separator nella stringa di uscita:

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

Ho diversi commenti sulla vostra funzione:

• tipo di annotazione è ridondante. Perché (^) è l'operatore di concatenazione di stringhe, il controllo di tipo può dedurre i tipi di separator, l e l'output della funzione facilmente.
• Non è necessario utilizzare la coppia begin/and. Dato che hai un solo livello di corrispondenza del modello, non c'è confusione nel compilatore.
• È possibile utilizzare function per eliminare la parte match l with.

Pertanto, il codice potrebbe essere abbreviata come:

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

o anche più concisa:

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

Answer 2

L'elenco vuoto è [], l'elenco con un elemento è [h] e l'elenco con almeno un elemento è h::t. Quindi la tua funzione può essere scritta come:

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