valor inferior en Haskell

Question

He escrito una función Haskell que se divide en una lista xs(init xs, last xs) así:

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

Desde una lista vacía no se puede dividir de esta manera, no hay ninguna coincidencia para la lista vacía. Sin embargo, no quería simplemente la función error .... Por lo tanto he definido lo siguiente:

split [] = ([], undefined) 

Gracias a la evaluación perezosa por lo tanto puedo definir un seguro init cual simplemente devuelve la lista vacía de la lista vacía:

init' = fst . split 

¿Hay alguna manera de cómo podría detectar lo indefinido si trataba de acceder a él, de manera que

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

sí sé sobre Maybe y Either, y que esas son una mejor opción para expresar lo que quiero. Sin embargo, me preguntaba si hay una manera de detectar un valor real de indefinido, es decir, en términos de errores de captura, como capturar excepciones.

Answer 1

Debido inferior subsume no terminación, la función isUndefined habría que resolver el problema de la parada y por lo tanto no puede existir

Pero tenga en cuenta que incluso si existiera, aún no podría decir si el valor indefinido en el 2º elemento de su tupla se puso allí a través de su función split o si el último elemento de la lista ya no estaba definido.

Answer 2

La función error no hace nada hasta que se evalúa, por lo que puede hacer algo como:

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

last' = snd . split 

Answer 3

undefined no es mejor que usar error. De hecho, undefined en preámbulo es defined como

undefined = error "Prelude.undefined" 

Ahora, una función que no puede resultar en un error se llama una "función Total", es decir, es válido para todos los valores de entrada.

La función split ha implementado actualmente tiene la firma

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

Este es un problema, ya que el tipo de firma promete que el resultado siempre contiene una lista y un elemento, que es claramente imposible prever listas vacías de tipo genérico.

La manera canónica en Haskell de abordar esto es cambiar el tipo de firma para indicar que a veces no tenemos un valor válido para el segundo elemento.

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

Ahora usted puede escribir una aplicación adecuada para el caso en el que se obtiene una lista vacía

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

Ahora se puede detectar el caso de valor perdido por el patrón de coincidencia

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

De el Haskell 2010 Language Report > Introduction # Values and Types

Los errores en Haskell son semánticamente equivalentes a ⊥ ("abajo"). Técnicamente, son indistinguibles de la no determinación, por lo que el lenguaje no incluye ningún mecanismo para detectar o actuar sobre los errores.

Para ser claros, undefined pretende ser una forma de insertar ⊥ en su programa, y ​​dado que (como se señaló Shang) undefined se define en términos de error, no hay, por lo tanto, "ningún mecanismo para detectar o actuando al undefined ".

Answer 5

Aunque semánticamente hablando, la respuesta de Ingo es correcta, si está usando GHC, hay una forma de usar un par de funciones "inseguras" que, aunque no son perfectas, le pasan un cálculo de tipo IO a que contiene una excepción que devolverá True, funciona. Aunque es un poco engañoso :).

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) 

Sé que esto es horrible, pero no obstante funciona. No va a detectar la no terminación sin embargo;)