Safe Haskell	Safe-Inferred
Language	Haskell2010

Agda.Utils.Maybe.Strict

Contents

Orphan instances

Description

A strict version of the Maybe type.

Import qualified, as in import qualified Agda.Utils.Maybe.Strict as Strict

Synopsis

module Data.Strict.Maybe
module Data.Strict.Classes
forMaybe :: [a] -> (a -> Maybe b) -> [b]
caseMaybeM :: Monad m => m (Maybe a) -> m b -> (a -> m b) -> m b
fromMaybeM :: Monad m => m a -> m (Maybe a) -> m a
filterMaybe :: (a -> Bool) -> a -> Maybe a
whenJust :: Monad m => Maybe a -> (a -> m ()) -> m ()
unionMaybeWith :: (a -> a -> a) -> Maybe a -> Maybe a -> Maybe a
unzipMaybe :: Maybe (a, b) -> (Maybe a, Maybe b)
caseMaybe :: Maybe a -> b -> (a -> b) -> b
maybeM :: Monad m => m b -> (a -> m b) -> m (Maybe a) -> m b
ifJustM :: Monad m => m (Maybe a) -> (a -> m b) -> m b -> m b
whenJustM :: Monad m => m (Maybe a) -> (a -> m ()) -> m ()

Documentation

module Data.Strict.Maybe

module Data.Strict.Classes

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

Version of mapMaybe with different argument ordering.

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.

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

Monadic version of fromMaybe.

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

Filtering a singleton list.

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

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.

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

unionWith for collections of size <= 1.

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

Unzipping a list of length <= 1.

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 err f = flip (maybe err) m f

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

Monadic version of maybe.

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

caseMaybeM with flipped branches.

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

caseMaybeM without the Nothing case.

Orphan instances

Applicative Maybe Source #	Note that strict Maybe is an `Applicative` only modulo strictness. The laws only hold in the strict semantics. Eg. `pure f * pure _\|_ = _\|_`, but according to the laws for `Applicative` it should be `pure (f _\|_)`. We ignore this issue here, it applies also to `Foldable` and `Traversable`.
Instance details Methods pure :: a -> Maybe a # (<>) :: Maybe (a -> b) -> Maybe a -> Maybe b # liftA2 :: (a -> b -> c) -> Maybe a -> Maybe b -> Maybe c # (>) :: Maybe a -> Maybe b -> Maybe b # (<*) :: Maybe a -> Maybe b -> Maybe a #
Null (Maybe a) Source #
Instance details Methods empty :: Maybe a Source # null :: Maybe a -> Bool Source #