[caml] ritornare elemento inesistente

[NA01]

devo creare una funzione che prenda una lista e mi restituisca in una coppia l'ultimo elemento e la lista senza l'ultimo elemento.

la prima soluzione che ho scritto è questa:

let rec tail = function(l) -> (tuttaMenoUna(l),ultimo(l));;

let rec tuttaMenoUna = function [] -> []
  |a::[] -> []
  |a::b -> a::tuttaMenoUna(b);;

let rec ultimo = function a::[] -> a
  |a::b -> ultimo(b)

a parte il fatto che si passa due volte la lista per risolvere il problema, c'è un problema ben più grave:
come segnala i compilatore il caso di un parametro lista vuota non è gestito, ed effettivamente in quel caso tira fuori cose senza alcun senso.

potrei mettere un caso vuoto che restituisce la coppia lista vuota e un valore a babbo (si era pensato a nan), ma in questo modo la funzione non prende più una a' list, ma una list di tipo ben fissato....
posso in qualche modo restituire un valore senza utilizzare eccezzioni o cose simili, e sopratutto senza andare a fissare il tipo della lista?

già che ci sono un'altra domanda, qualcuno sa in che campo è usato questo linguaggio (sempre che sia usato )?

ciao!

[NA01]

upete!

[/\/\@®¢Ø]

Non posso darti una soluzione in ocaml perche' non lo conosco.
Essendo un dialetto ML, dovrebbe avere pero' una struttura dati simile alla option di SML, che funziona al seguente modo: un dato di tipo 'a option' puo' valere NONE , oppure SOME x , con x di tipo 'a.
Nel tuo caso quindi dovresti cambiare la funzione in modo che ritorni "SOME x" in caso la lista sia non vuota, e NONE altrimenti.
In alternativa puoi usare un'altra lista, che sara' vuota nel caso la lista originale sia vuota, e sia invece una lista di un solo elemento altrimenti.
Per evitare la doppia scansione puoi "spezzare" il risultato della chiamata ricorsiva, ritornando sempre l'eventuale valore ritornato, e usando la lista parziale per ricostruire la finale.
Ti mostro un esempio con notazione Haskell, che pero' dovresti riuscire a capire comunque:

tail :: [a] -> ([a],[a])

tail [] = ([],[])
tail [x] = ([],[x])
tail (x:xs) 
  = let
      (testa,coda) = tail xs
    in
      (x:testa,coda)