Flipped, infix version of withDefault.

head [] ? 0 == 0

Flattens nested Maybes

join (Just (Just 1)) == Just 1
join (Just Nothing)  == Nothing
join Nothing         == Nothing

Conveniently check if a Maybe matches Nothing.

isNothing (Just 42) == False
isNothing (Just []) == False
isNothing Nothing   == True

Conveniently check if a Maybe matches Just _.

isJust (Just 42) == True
isJust (Just []) == True
isJust Nothing   == False

Take a default value, a function and a Maybe. Return the default value if the Maybe is Nothing. If the Maybe is Just a, apply the function on a and return the b. That is, unwrap d f is equivalent to Maybe.map f >> Maybe.withDefault d.

A version of unwrap that is non-strict in the default value (by having it passed in a thunk).

Take a Maybe and a predicate function and return a Maybe with the original value when a predicate matches.

filter (\v -> v == 1) (Just 1) == Just 1
filter (\v -> v == 2) (Just 1) == Nothing

Apply the function that is inside Maybe to a value that is inside Maybe. Return the result inside Maybe. If one of the Maybe arguments is Nothing, return Nothing.

Just ((+) 2) |> andMap (Just 3) == Just 5
Nothing |> andMap (Just 3) == Nothing
Just ((+) 2) |> andMap Nothing == Nothing

Advanced functional programmers will recognize this as the implementation of <*> for Maybes from the Applicative typeclass.

Take two Maybe values. If the first one equals Nothing, return Nothing. Otherwise return the second value.

next (Just 1) (Just 2) == Just 2
next Nothing (Just 2) == Nothing
next (Just 1) Nothing == Nothing

Advanced functional programmers will recognize this as the implementation of *> for Maybes from the Applicative typeclass.

Take two Maybe values. If the second one equals Nothing, return Nothing. Otherwise return the first value.

prev (Just 1) (Just 2) == Just 1
prev Nothing (Just 2) == Nothing
prev (Just 1) Nothing == Nothing

Advanced functional programmers will recognize this as the implementation of <* for Maybes from the Applicative typeclass.

Like the boolean || this will return the first value that is positive (Just). However, unlike with ||, both values will be computed anyway (there is no short-circuiting).

or (Just 4) (Just 5) == Just 4
or (Just 4) Nothing  == Just 4
or Nothing (Just 5)  == Just 5
or Nothing Nothing   == Nothing

Advanced functional programmers will recognize this as the implementation of mplus for Maybes from the MonadPlus type class.

Non-strict version of or. The second argument will only be evaluated if the first argument is Nothing.

Piping-friendly version of orLazy. The first argument will only be evaluated if the second argument is Nothing. Example use:

List.head []
|> orElseLazy (\() -> List.head [4])

Strict version of orElseLazy (and at the same time, piping-friendly version of or).

orElse (Just 4) (Just 5)  == Just 5  -- crucial difference from `or`
orElse (Just 4) Nothing   == Just 4
orElse Nothing  (Just 5)  == Just 5
orElse Nothing  Nothing   == Nothing

Also:

List.head []
|> orElse (List.head [4])

Return an empty list on Nothing or a list with one element, where the element is the value of Just.

toList Nothing == []
toList (Just 1) == [1]

Return an empty array on Nothing or a list with one element, where the element is the value of Just.

toArray Nothing == Array.fromList []
toArray (Just 1) == Array.fromList [1]

Take a function that returns Maybe value and a list. Map a function over each element of the list. Collect the result in the list within Maybe.

traverse (\x -> Just (x*10)) [1,2,3,4,5] == Just [10,20,30,40,50]

Take a list of Maybes and return a Maybe with a list of values. combine == traverse identity.

combine [] == Just []
combine [Just 1, Just 2, Just 3] == Just [1,2,3]
combine [Just 1, Nothing, Just 3] == Nothing

Convet a list of Maybe a to a list of a only for the values different from Nothing.

values [ Just 1, Nothing, Just 2 ] == [1, 2]