Operando a partir de un retorno de Maybe que contiene “Just”

Tengo una función que tiene un tipo de retorno de Maybe ([(Int,Int)],(Int,Int))

Me gustaría llamar a esto desde otra función y realizar una operación en los datos.

Sin embargo, el valor de retorno está contenido en Just . El segundo método toma ([(Int,Int)],(Int,Int)) y, por lo tanto, no aceptará 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 .

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 statement 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) = fx 

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 (fa) 

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)) 

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