Agda-2.6.2.2: A dependently typed functional programming language and proof assistant

Safe Haskell | Safe-Inferred
Language | Haskell2010

Agda.Utils.Maybe

Description

Extend `Maybe` by common operations for the `Maybe` type.

Note: since this module is usually imported unqualified, we do not use short names, but all names contain `Maybe`, `Just`, or 'Nothing.

Synopsis

- boolToMaybe :: Bool -> a -> Maybe a
- unionMaybeWith :: (a -> a -> a) -> Maybe a -> Maybe a -> Maybe a
- unionsMaybeWith :: (a -> a -> a) -> [Maybe a] -> Maybe a
- unzipMaybe :: Maybe (a, b) -> (Maybe a, Maybe b)
- filterMaybe :: (a -> Bool) -> a -> Maybe a
- forMaybe :: [a] -> (a -> Maybe b) -> [b]
- caseMaybe :: Maybe a -> b -> (a -> b) -> b
- ifJust :: Maybe a -> (a -> b) -> b -> b
- maybeM :: Monad m => m b -> (a -> m b) -> m (Maybe a) -> m b
- fromMaybeM :: Monad m => m a -> m (Maybe a) -> m a
- caseMaybeM :: Monad m => m (Maybe a) -> m b -> (a -> m b) -> m b
- ifJustM :: Monad m => m (Maybe a) -> (a -> m b) -> m b -> m b
- whenJust :: Monad m => Maybe a -> (a -> m ()) -> m ()
- whenNothing :: Monoid m => Maybe a -> m -> m
- whenJustM :: Monad m => m (Maybe a) -> (a -> m ()) -> m ()
- whenNothingM :: Monad m => m (Maybe a) -> m () -> m ()
- allJustM :: Monad m => [m (Maybe a)] -> m (Maybe [a])
- liftMaybe :: Alternative f => Maybe a -> f a
- module Data.Maybe

# Documentation

boolToMaybe :: Bool -> a -> Maybe a Source #

Retain object when tag is `True`.

unionMaybeWith :: (a -> a -> a) -> Maybe a -> Maybe a -> Maybe a Source #

`unionWith` for collections of size <= 1.

unionsMaybeWith :: (a -> a -> a) -> [Maybe a] -> Maybe a Source #

`unionsWith` for collections of size <= 1.

unzipMaybe :: Maybe (a, b) -> (Maybe a, Maybe b) Source #

Unzipping a list of length <= 1.

filterMaybe :: (a -> Bool) -> a -> Maybe a Source #

Filtering a singleton list.

    filterMaybe p a = listToMaybe (filter p [a])

forMaybe :: [a] -> (a -> Maybe b) -> [b] Source #

Version of `mapMaybe` with different argument ordering.

caseMaybe :: Maybe a -> b -> (a -> b) -> b Source #

Version of `maybe` with different argument ordering. Often, we want to case on a `Maybe`, do something interesting in the `Just` case, but only a default action in the `Nothing` case. Then, the argument ordering of `caseMaybe` is preferable.

    caseMaybe m d f = flip (maybe d) m f

ifJust :: Maybe a -> (a -> b) -> b -> b Source #

`caseMaybe` with flipped branches.

maybeM :: Monad m => m b -> (a -> m b) -> m (Maybe a) -> m b Source #

Monadic version of `maybe`.

fromMaybeM :: Monad m => m a -> m (Maybe a) -> m a Source #

Monadic version of `fromMaybe`.

caseMaybeM :: Monad m => m (Maybe a) -> m b -> (a -> m b) -> m b Source #

Monadic version of `caseMaybe`. That is, `maybeM` with a different argument ordering.

ifJustM :: Monad m => m (Maybe a) -> (a -> m b) -> m b -> m b Source #

`caseMaybeM` with flipped branches.

whenJust :: Monad m => Maybe a -> (a -> m ()) -> m () Source #

A more telling name for `forM_` for the `Maybe` collection type. Or: `caseMaybe` without the `Nothing` case.

whenNothing :: Monoid m => Maybe a -> m -> m Source #

`caseMaybe` without the `Just` case.

whenJustM :: Monad m => m (Maybe a) -> (a -> m ()) -> m () Source #

`caseMaybeM` without the `Nothing` case.

whenNothingM :: Monad m => m (Maybe a) -> m () -> m () Source #

`caseMaybeM` without the `Just` case.

allJustM :: Monad m => [m (Maybe a)] -> m (Maybe [a]) Source #

Lazy version of `allJust . sequence`. (`allJust = mapM` for the `Maybe` monad.) Only executes monadic effect while `isJust`.

liftMaybe :: Alternative f => Maybe a -> f a Source #

Lift a maybe to an Alternative.

module Data.Maybe