| Haskell Hierarchical Libraries (base package) | Source code | Contents | Index

Data.Maybe |

Portability | portable
Stability | stable
Maintainer | libraries@haskell.org

Description
The Maybe type, and associated operations.
Synopsis

data Maybe a

= Nothing
| Just a

maybe :: b -> (a -> b) -> Maybe a -> b
isJust :: Maybe a -> Bool
isNothing :: Maybe a -> Bool
fromJust :: Maybe a -> a
fromMaybe :: a -> Maybe a -> a
listToMaybe :: [a] -> Maybe a
maybeToList :: Maybe a -> [a]
catMaybes :: [Maybe a] -> [a]
mapMaybe :: (a -> Maybe b) -> [a] -> [b]

Documentation
data Maybe a

The `Maybe` type encapsulates an optional value. A value of type ``Maybe` a` either contains a value of type `a` (represented as ``Just` a`), or it is empty (represented as `Nothing`). Using `Maybe` is a good way to deal with errors or exceptional cases without resorting to drastic measures such as `error`.

The `Maybe` type is also a monad. It is a simple kind of error monad, where all errors are represented by `Nothing`. A richer error monad can be built using the `Either` type.

Constructors

Nothing |
Just a |

Instances

Alternative Maybe
Applicative Maybe
Foldable Maybe
Functor Maybe
FunctorM Maybe
Monad Maybe
MonadFix Maybe
MonadPlus Maybe
Traversable Maybe
Typeable1 Maybe
Data a => Data (Maybe a)
Eq a => Eq (Maybe a)
Ord a => Ord (Maybe a)
Read a => Read (Maybe a)
Show a => Show (Maybe a)

maybe :: b -> (a -> b) -> Maybe a -> b
The `maybe` function takes a default value, a function, and a `Maybe` value. If the `Maybe` value is `Nothing`, the function returns the default value. Otherwise, it applies the function to the value inside the `Just` and returns the result.
isJust :: Maybe a -> Bool
The `isJust` function returns `True` iff its argument is of the form `Just _`.
isNothing :: Maybe a -> Bool
The `isNothing` function returns `True` iff its argument is `Nothing`.
fromJust :: Maybe a -> a
The `fromJust` function extracts the element out of a `Just` and throws an error if its argument is `Nothing`.
fromMaybe :: a -> Maybe a -> a
The `fromMaybe` function takes a default value and and `Maybe` value. If the `Maybe` is `Nothing`, it returns the default values; otherwise, it returns the value contained in the `Maybe`.
listToMaybe :: [a] -> Maybe a
The `listToMaybe` function returns `Nothing` on an empty list or ``Just` a` where `a` is the first element of the list.
maybeToList :: Maybe a -> [a]
The `maybeToList` function returns an empty list when given `Nothing` or a singleton list when not given `Nothing`.
catMaybes :: [Maybe a] -> [a]
The `catMaybes` function takes a list of `Maybe`s and returns a list of all the `Just` values.
mapMaybe :: (a -> Maybe b) -> [a] -> [b]
The `mapMaybe` function is a version of `map` which can throw out elements. In particular, the functional argument returns something of type ``Maybe` b`. If this is `Nothing`, no element is added on to the result list. If it just ``Just` b`, then `b` is included in the result list.
Produced by Haddock version 0.8