Data.Maybe

haskell2010-1.1.1.0: Compatibility with Haskell 2010

Safe Haskell | Safe

Data.Maybe

Contents

- The `Maybe` type and operations
- Specification

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]

# The `Maybe` type and operations

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

Constructors

Nothing |
Just a |

Instances

Monad Maybe |
Functor Maybe |
MonadPlus Maybe |
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 -> 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.

# Specification

     module Data.Maybe(
         Maybe(Nothing, Just),
         isJust, isNothing,
         fromJust, fromMaybe, listToMaybe, maybeToList,
         catMaybes, mapMaybe,
         maybe
       ) where

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

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

     isNothing              :: Maybe a -> Bool
     isNothing              =  not . isJust

     fromJust               :: Maybe a -> a
     fromJust (Just a)      =  a
     fromJust Nothing       =  error "Maybe.fromJust: Nothing"

     fromMaybe              :: a -> Maybe a -> a
     fromMaybe d Nothing    =  d
     fromMaybe d (Just a)   =  a

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

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

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

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