Portability	portable
Stability	stable
Maintainer	libraries@haskell.org

Data.Maybe

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 Source

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 Data.Either.Either type.

Constructors

Nothing

Just a

Instances

Monad Maybe

Eq a => Eq (Maybe a)

Data a => Data (Maybe a)

Ord a => Ord (Maybe a)

Read a => Read (Maybe a)

Show a => Show (Maybe a)

Generic (Maybe a)

Monoid a => Monoid (Maybe a)

Lift a semigroup into Maybe forming a Monoid according to http://en.wikipedia.org/wiki/Monoid: "Any semigroup S may be turned into a monoid simply by adjoining an element e not in S and defining e*e = e and e*s = s = s*e for all s S." Since there is no "Semigroup" typeclass providing just mappend , we use Monoid instead.

maybe :: b -> (a -> b) -> Maybe a -> bSource

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 Source

The isJust function returns True iff its argument is of the form Just _.

isNothing :: Maybe a -> Bool Source

The isNothing function returns True iff its argument is Nothing .

fromJust :: Maybe a -> aSource

The fromJust function extracts the element out of a Just and throws an error if its argument is Nothing .

fromMaybe :: a -> Maybe a -> aSource

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 aSource

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]Source

The maybeToList function returns an empty list when given Nothing or a singleton list when not given Nothing .

catMaybes :: [Maybe a] -> [a]Source

The catMaybes function takes a list of Maybe s and returns a list of all the Just values.

mapMaybe :: (a -> Maybe b) -> [a] -> [b]Source

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.