haskell - Operando a partir de un retorno de Maybe que contiene "Just"

monads

Question

Tengo un algoritmo que devuelve ->Maybe ([(Int,Int)],(Int,Int))

Me gustaría llamar a esto desde otro método y realizar una operación en los datos.

Sin embargo, el valor de retorno contiene la palabra clave Just porque es un tal vez. El segundo método toma ([(Int,Int)],(Int,Int)) y por lo tanto no excepto Just ([(Int,Int)],(Int,Int)) .

¿Hay alguna manera de recortar el Just antes de aplicar el segundo método?

No entiendo completamente el uso de Just in Maybe - sin embargo, me han dicho que el tipo de devolución para el primer Método debe ser Maybe .

Answer 1

Está buscando desde fromJust . ¡Pero solo si está seguro de que su función Maybe no va a devolver Nothing !

Answer 2

Existen varias soluciones para su problema, todas basadas en la coincidencia de patrones. Supongo que tienes dos algoritmos (ya que no los nombras, lo haré):

algorithm1 :: a -> Maybe b
algorithm2 :: b -> c
input :: a

1) La coincidencia de patrones normalmente se realiza desde una declaración de caso (a continuación) o una función.

let val = algorithm1 input
in case val of
    Nothing -> defaultValue
    Just x  -> algorithm2 x

Todas las demás soluciones presentadas usan concordancia de patrones, solo presento funciones estándar que realizan la coincidencia de patrones por usted.

2) El preludio (y Data.Maybe) tienen algunas funciones incorporadas para tratar con Maybe s. La función tal vez sea ​​genial, te sugiero que la uses. Está definido en bibliotecas estándar como:

maybe :: c -> (b -> c) -> Maybe b -> c
maybe n _ Nothing  = n
maybe _ f (Just x) = f x

Tu código se vería así:

maybe defaultValue algorithm2 (algorithm1 input)

3) Dado que Maybe es un functor , podrías usar fmap . Esto tiene más sentido si no tiene un valor predeterminado. La definición:

instance  Functor Maybe  where
    fmap _ Nothing       = Nothing
    fmap f (Just a)      = Just (f a)

Entonces su código se vería así:

fmap algorithm2 (algorithm1 input)

Esta salida será un valor Maybe ( Nothing si el resultado del algoritmo 1 es Nothing ).

4) Finalmente, y fuertemente desaconsejado, es de fromJust . Solo úsela si está seguro de que el primer algoritmo devolverá Just x (y no Nothing ). ¡Ten cuidado! Si llama desde fromJust val cuando val = Nothing entonces obtiene una excepción, que no es apreciada en Haskell. Su definición:

fromJust          :: Maybe b -> b
fromJust Nothing  = error "Maybe.fromJust: Nothing" -- yuck
fromJust (Just x) = x

Dejando tu código para que se vea así:

algorithm2 (fromJust (algorithm1 input))