Operando en un regreso de un Quizá que contiene "sólo"

Question

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

quisiera llamar a esto de otra función y realizar una operación sobre 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 dentro de Maybe - sin embargo, me han dicho que el tipo de devolución para el primer Método debe ser Maybe.

Answer 1

Está buscando fromJust. ¡Pero solamente si usted es cierto su función Maybe no va a devolver un Nothing!

Answer 2

Existen varias soluciones a su problema, todas basadas en la coincidencia de patrones. Estoy suponiendo que tiene dos algoritmos (ya que no dio el nombre de ellos, lo haré):

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

1) Pattern matching se realiza normalmente desde una declaración de caso (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 utilizan la coincidencia de patrones, solo presento las funciones estándar que realizan la coincidencia de patrones por usted.

2) El preludio (y Data.Maybe) tienen algunas funciones incorporadas para ocuparse de Maybe s. La función maybe es excelente, le sugiero que la use. Se define en las bibliotecas estándar como:

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

Su código se vería así:

maybe defaultValue algorithm2 (algorithm1 input) 

3) Desde Tal vez es una functor podría utilizar 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) 

lo que el código se vería así:

fmap algorithm2 (algorithm1 input) 

Esta salida será un valor Maybe (Nothing si el resultado de algorithm1 es Nothing).

4) Por último, y muy desaconsejado, es fromJust. Solo úsela si está seguro de que el primer algoritmo devolverá Just x (y no Nothing). ¡Ten cuidado! Si llama al fromJust val cuando val = Nothing, 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 su código para que parezca:

algorithm2 (fromJust (algorithm1 input))