# Haskell/Libraries/Maybe

The `Maybe`

data is used with functions that might be unsuccessful. The full description is in Maybe monad chapter.

## Definition[edit]

The Standard Prelude defines the `Maybe`

type as follows:

data Maybe a = Nothing | Just a

Recall that the type *a* is polymorphic and can contain complex types or even other monads (such as IO () types).

## Library functions[edit]

The module `Data.Maybe`

, in the standard hierarchical libraries, contains a wealth of functions for working with Maybe values.

### Querying[edit]

Two obvious functions give you information about a Maybe value:

`isJust`

[edit]

`isJust`

returns True if when given an argument in the form `Just _`

.

isJust :: Maybe a -> Bool isJust (Just _) = True isJust Nothing = False

`isNothing`

[edit]

`isNothing`

returns True if its argument is `Nothing`

.

isNothing :: Maybe a -> Bool isNothing (Just _) = False isNothing Nothing = True

### Getting out[edit]

There are a handful of functions for converting Maybe values to non-Maybe values.

`maybe`

[edit]

`maybe`

applies a given function to the internal value passed by a `Just`

but otherwise returns a default value when given `Nothing`

.

maybe :: b -> (a -> b) -> Maybe a -> b maybe _ f (Just x) = f x maybe z _ Nothing = z

`fromMaybe`

[edit]

We might want to use `maybe`

without applying any function to the `Just`

. We can do that by calling `maybe`

with the function `id`

. `Data.Maybe`

already has this as `fromMaybe`

:

fromMaybe :: a -> Maybe a -> a fromMaybe z = maybe z id

Note the use of point-free style. `maybe z id`

evaluates to a function that is ready to take a `Maybe`

value.

### Lists and Maybe[edit]

The many similarities between lists and `Maybe`

are discussed in the List monad chapter. Given the connections, there are a couple of functions for converting between one and the other:

`listToMaybe`

[edit]

Failed computations return `[]`

for lists and `Nothing`

for Maybe. `listToMaybe`

converts from the list to the Maybe monad. As `Maybe`

can only hold one value, `listToMaybe`

only takes the first solution from a list.

listToMaybe :: [a] -> Maybe a listToMaybe [] = Nothing listToMaybe (x:_) = Just x

`maybeToList`

[edit]

The reverse `listToMaybe`

is, of course, `maybeToList`

:

maybeToList :: Maybe a -> [a] maybeToList Nothing = [] maybeToList (Just x) = [x]

### Lists manipulation[edit]

There are a couple of functions which are analogues of the normal Prelude list manipulation functions but are specialized to Maybe values.

#### Continue on some failures[edit]

We might want an *OR* function that won't make a whole computation fail just because one part failed.

`catMaybes`

[edit]

Given a list of Maybe values, `catMaybes`

extracts all the values in the form `Just _`

, and strips off the `Just`

constructors. List comprehension does the job here (as we showed in the pattern matching chapter):

catMaybes :: [Maybe a] -> [a] catMaybes ms = [ x | Just x <- ms ]

`mapMaybe`

[edit]

`mapMaybe`

applies a function to a list and collects the successes. It can be understood as a composition of functions you already know:

mapMaybe :: (a -> Maybe b) -> [a] -> [b] mapMaybe f xs = catMaybes (map f xs)

However, the actual definition in `Data.Maybe`

traverses the list is potentially more efficient:

mapMaybe :: (a -> Maybe b) -> [a] -> [b] mapMaybe _ [] = [] mapMaybe f (x:xs) = case f x of Just y -> y : mapMaybe f xs Nothing -> mapMaybe f xs

#### Stop on failure[edit]

Rather than *OR*, we might want to collect values if and only if all succeed.

`sequence`

[edit]

sequence :: [Maybe a] -> Maybe [a] sequence [] = Just [] sequence (Nothing:xs) = Nothing sequence (Just x:xs) = case sequence xs of Just xs' -> Just (x:xs') _ -> Nothing