Documentation

Basic usage:

>>> maybe False odd (just 3)
True

>>> maybe False odd nothing
False

Read an integer from a string using readMaybe. If we succeed, return twice the integer; that is, apply (*2) to it. If instead we fail to parse an integer, return 0 by default:

>>> maybe 0 (*2) (fromBaseMaybe $ readMaybe "5")
10
>>> maybe 0 (*2) (fromBaseMaybe $ readMaybe "")
0

Apply show to a Maybe Int. If we have just n, we want to show the underlying Int n. But if we have nothing, we return the empty string instead of (for example) "Nothing":

>>> maybe "" show (just 5)
"5"
>>> maybe "" show nothing
""

Basic usage:

>>> isJust (just 3)
True

>>> isJust (just ())
True

>>> isJust nothing
False

Only the outer constructor is taken into consideration:

>>> isJust (just nothing)
True

Basic usage:

>>> isNothing (just 3)
False

>>> isNothing (just ())
False

>>> isNothing nothing
True

Only the outer constructor is taken into consideration:

>>> isNothing (just nothing)
False

Basic usage:

>>> fromJust (just 1)
1

>>> 2 * (fromJust (just 10))
20

>>> 2 * (fromJust nothing)
*** Exception: Data.Maybe.Unpacked.fromJust: Nothing

Basic usage:

>>> fromMaybe "" (just "Hello, World!")
"Hello, World!"

>>> fromMaybe "" nothing
""

Read an integer from a string using readMaybe. If we fail to parse an integer, we want to return 0 by default:

>>> import Text.Read ( readMaybe )
>>> let parse = fromBaseMaybe . readMaybe :: String -> Maybe Int
>>> fromMaybe 0 (parse "5")
5
>>> fromMaybe 0 (parse "")
0

Basic usage:

>>> listToMaybe []
Nothing

>>> listToMaybe [9]
Just 9

>>> listToMaybe [1,2,3]
Just 1

Composing maybeToList with listToMaybe should be the identity on singleton/empty lists:

>>> maybeToList $ listToMaybe [5]
[5]
>>> maybeToList $ listToMaybe []
[]

But not on lists with more than one element:

>>> maybeToList $ listToMaybe [1,2,3]
[1]

Basic usage:

>>> maybeToList (just 7)
[7]

>>> maybeToList nothing
[]

One can use maybeToList to avoid pattern matching when combined with a function that (safely) works on lists:

>>> import Text.Read ( readMaybe )
>>> let parse = fromBaseMaybe . readMaybe :: String -> Maybe Int
>>> sum $ maybeToList (parse "3")
3
>>> sum $ maybeToList (parse "")
0

This being said Maybe is an instance of the Foldable typeclass so the example above could also be written as:

>>> import Text.Read ( readMaybe )
>>> let parse = fromBaseMaybe . readMaybe :: String -> Maybe Int
>>> sum $ parse "3"
3
>>> sum $ parse ""
0

Basic usage:

>>> catMaybes [just 1, nothing, just 3]
[1,3]

When constructing a list of Maybe values, catMaybes can be used to return all of the "success" results (if the list is the result of a map, then mapMaybe would be more appropriate):

>>> import Text.Read ( readMaybe )
>>> let parse = fromBaseMaybe . readMaybe :: String -> Maybe Int
>>> [ parse x | x <- ["1", "Foo", "3"] ]
[Just 1,Nothing,Just 3]
>>> catMaybes $ [ parse x | x <- ["1", "Foo", "3"] ]
[1,3]

Using mapMaybe f x is a shortcut for catMaybes $ map f x in most cases:

>>> import Text.Read ( readMaybe )
>>> let parse = fromBaseMaybe . readMaybe :: String -> Maybe Int
>>> mapMaybe parse ["1", "Foo", "3"]
[1,3]
>>> catMaybes $ map parse ["1", "Foo", "3"]
[1,3]

If we map the just function, the entire list should be returned:

>>> mapMaybe just [1,2,3]
[1,2,3]

Basic usage:

>>> import Text.Read ( readMaybe )
>>> let parse = fromBaseMaybe . readMaybe :: String -> Maybe Int
>>> parse "3"
Just 3
>>> parse ""
Nothing

Basic usage:

>>> import Data.List (unfoldr)
>>> let ana n = if n == 5 then nothing else just (n+1,n+1)
>>> unfoldr (toBaseMaybe . ana) 0
[1,2,3,4,5]