# 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
```