Decir que tengotipos de datos desenvolver en Haskell sin código extraño
x = Just 2
¿Hay alguna manera (preferiblemente un mecanismo/función incorporada) para utilizar x en un estado único de tal manera que si se trata de una solución justa, entonces el 2 se desenrolla y usa automáticamente, y si es Nothing, se genera una excepción?
Es decir,
(f x) + 2 == 4 si x == Just 2, y lanza una excepción si x == Nothing.
Data.Maybe.fromJust ha sido mencionado por los ya otras respuestas:
fromJust :: Maybe a -> a
fromJust Nothing = error "Maybe.fromJust: Nothing"
fromJust (Just x) = x
También hay maybe (encontradas tanto en Prelude y Data.Maybe):
maybe :: b -> (a -> b) -> Maybe a -> b
maybe n _ Nothing = n
maybe _ f (Just x) = f x
fromJust se puede escribir usando maybe:
fromJust = maybe (error "Maybe.fromJust: Nothing") id
Como se puede ver, maybe que permite flexibilidad en el manejo de los dos casos, sin necesidad de coincidencia de patrones:
\x -> maybe 0 (+ 2) x -- Nothing -> 0, Just 2 -> 4
Del mismo modo, Prelude y Data.Either tienen either :: (a -> c) -> (b -> c) -> Either a b -> c:
\x -> either (subtract 1) (* 2) x -- Left 5 -> 4, Right 3 -> 6
Si se define un conjunto de datos tipo
data MyDataType
= TypeA { foo :: Int, bar :: String }
| TypeB { foo :: Int, baz ::() }
| TypeC { bar :: String, baz ::() }
de esta manera, terminas con funciones parciales para los accesorios.
foo :: MyDataType -> Int
bar :: MyDataType -> String
baz :: MyDataType ->()
Se denominan funciones parciales, a diferencia de las funciones totales, porque solo devuelven resultados para un subconjunto de sus entradas.
foo (TypeA { foo = 15, bar = "hello!" }) -- 15
bar (TypeB { foo = 12345679, baz =() }) -- error
fromJust debe hacer lo que desee.
Para este caso en particular, fromJust. En general
let Just k = x in f k + 2 == 4
Este truco funciona con cualquier tipo de datos y el constructor se utiliza con gran frecuencia a (:) para las listas no vacías.