Rileva valore di fondo in Haskell

Question

ho scritto una funzione Haskell che divide un elenco xs in (init xs, last xs) in questo modo:

split xs = split' [] xs 
    where 
     split' acc (x:[]) = (reverse acc, x) 
     split' acc (x:xs) = split' (x:acc) xs 

Da una lista vuota non può essere divisa in questo modo, non v'è alcuna corrispondenza per la lista vuota. Tuttavia, non volevo semplicemente la funzione error .... Così ho definito il seguente:

split [] = ([], undefined) 

Grazie alla valutazione pigra posso quindi definire una cassaforte init che restituisce semplicemente la lista vuota per la lista vuota:

init' = fst . split 

C'è qualche modo come ho potuto rilevare l'indefinito se ho cercato di accedervi, in modo tale che

last' xs 
    | isUndefined (snd xs) = ... 
    | otherwise   = ... 

so circa Maybe e Either, e che quelli sono una scelta migliore per esprimere ciò che voglio. Tuttavia mi sono chiesto se c'è un modo per rilevare un valore reale non definito, cioè in termini di errori di cattura, come la cattura di eccezioni.

Answer 1

A causa di fondo sussume non terminazione, la funzione isUndefined avrebbe dovuto risolvere il problema della terminazione e, quindi, non può esistere

Tuttavia, anche se esistesse, non si poteva ancora sapere se il valore indefinito nel 2 ° elemento della tupla era stato inserito nella funzione split o se l'ultimo elemento della lista era già indefinito.

Answer 2

La funzione error non fa nulla fino a quando non viene valutata, in modo da poter fare qualcosa di simile:

split [] = ([], error "split: empty list") 

last' = snd . split 

Answer 3

undefined non è migliore di utilizzare error. Infatti, in undefined Prelude è defined come

undefined = error "Prelude.undefined" 

Ora, una funzione che non può risultare in un error è chiamato "funzione totale", cioè esso è valido per tutti i valori di ingresso.

La funzione split che avete attualmente implementato ha la firma

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

Questo è un problema, dal momento che la firma di tipo promette che il risultato contiene sempre una lista e un elemento, che è chiaramente impossibile da prevedere liste vuote di tipo generico.

Il modo canonico in Haskell per risolvere questo è modificare la firma del tipo per indicare che a volte non abbiamo un valore valido per il secondo elemento.

split :: [a] -> ([a], Maybe a) 

Ora è possibile scrivere una corretta applicazione per il caso in cui si ottiene una lista vuota

split [] = ([], Nothing) 
split xs = split' [] xs 
    where 
     split' acc (x:[]) = (reverse acc, Just x) 
     split' acc (x:xs) = split' (x:acc) xs 

Ora è in grado di rilevare il caso valore mancante dal modello-matching

let (init', last') = split xs 
in case last' of 
    Nothing -> ... -- do something if we don't have a value 
    Just x -> ... -- do something with value x 

Answer 4

Da the Haskell 2010 Language Report > Introduction # Values and Types

Gli errori in Haskell sono semanticamente equivalenti a ⊥ ("in basso"). Tecnicamente, sono indistinguibili da non terminazione, quindi il linguaggio non include alcun meccanismo per rilevare o agire sugli errori.

Per chiarezza, undefined è destinato ad essere un modo per inserire ⊥ nel programma, e dato che (come osservato shang) undefined è definito in termini di error, v'è, pertanto, "alcun meccanismo per rilevare o agendo su undefined ".

Answer 5

Sebbene la risposta di Ingo semantica sia corretta, se si utilizza GHC, è possibile utilizzare un paio di funzioni "non sicure" che, sebbene non proprio perfette come se si passasse a un calcolo di tipo IO a che contiene un'eccezione restituirà True, funziona. È un po 'un trucco però :).

import Control.Exception 
import System.IO.Unsafe 
import Unsafe.Coerce 

isUndefined :: a -> Bool 
isUndefined x = unsafePerformIO $ catch ((unsafeCoerce x :: IO()) >> return False) (const $ return True :: SomeException -> IO Bool) 

So che questo è orribile, ma nondimeno funziona. Non rileverà però nessuna terminazione;)