Operating on a return from a Maybe that contains “Just”

by

There are several solutions to your problem, all based around pattern matching. I’m assuming you have two algorithms (since you didn’t name them, I will):

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

1) Pattern matching is typically done from either a case statement (below) or a function.

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

All other presented solutions use pattern matching, I’m just presenting standard functions that perform the pattern matching for you.

2) The prelude (and Data.Maybe) have some built-in functions to deal with Maybes. The maybe function is a great one, I suggest you use it. It’s defined in standard libraries as:

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

Your code would look like:

maybe defaultValue algorithm2 (algorithm1 input)

3) Since Maybe is a functor you could use fmap. This makes more sense if you don’t have a default value. The definition:

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

So your code would look like:

fmap algorithm2 (algorithm1 input)

This output will be a Maybe value (Nothing if the result of algorithm1 is Nothing).

4) Finally, and strongly discouraged, is fromJust. Only use it if you are positive the first algorithm will return Just x (and not Nothing). Be careful! If you call fromJust val when val = Nothing then you get an exception, which is not appreciated in Haskell. Its definition:

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

Leaving your code to look like:

algorithm2 (fromJust (algorithm1 input))

More Related Contents:

  1. Good examples of Not a Functor/Functor/Applicative/Monad?
  2. Applicatives compose, monads don’t
  3. Monads with Join() instead of Bind()
  4. A monad is just a monoid in the category of endofunctors, what’s the problem?
  5. A Haskell function of type: IO String-> String
  6. Is monad bind (>>=) operator closer to function composition (chaining) or function application?
  7. IO happens out of order when using getLine and putStr
  8. What is indexed monad?
  9. How to extract value from monadic action
  10. Large-scale design in Haskell? [closed]
  11. What is the purpose of the reader monad?
  12. Is Haskell truly pure (is any language that deals with input and output outside the system)?
  13. Should do-notation be avoided in Haskell?
  14. Euler 43 – is there a monad to help write this list comprehension?
  15. Haskell: I/O and Returning From a Function
  16. Expressing do block using only monadic bind syntax
  17. Why do we need monads?
  18. Defining a new monad in haskell raises no instance for Applicative
  19. Concrete example showing that monads are not closed under composition (with proof)?
  20. How to use (->) instances of Monad and confusion about (->)
  21. What are free monads?
  22. Converting IO Int to Int
  23. How to interpret bind/>>= of the function instance?
  24. Is there a monad that doesn’t have a corresponding monad transformer (except IO)?
  25. Why should Applicative be a superclass of Monad?
  26. How to enumerate a recursive datatype in Haskell?
  27. How to handle side effect with Applicative?
  28. Haskell – depth for each node in binary tree using Reader monad
  29. How to return a pure value from a impure method
  30. How does the ST monad work?

Leave a Comment