Control.Effect.NonDet

An effect modelling nondeterminism with choice and failure.

Nondeterministic operations are encapsulated by the Alternative class, where empty represents failure and <|> represents choice. This module re-exports the Alternative interface. If you can't or don't want to use Alternative, you can use the empty and <|> operations (from Control.Effect.Empty and Control.Effect.Choose respectively) directly, as the NonDet effect is the composition of Choose and Empty.

Predefined carriers:

• Control.Carrier.NonDet.Church, which collects all branches' results using an Alternative functor.
• If NonDet is the last effect in a stack, it can be interpreted directly into a [].

Since: 0.1.0.0

NonDet effects

type NonDet = Empty :+: Choose

The nondeterminism effect is the composition of Empty and Choose effects.

Since: 0.1.0.0

data Choose (m :: Type -> Type) k where

Since: 1.0.0.0

Constructors

Choose :: forall (m :: Type -> Type). Choose m Bool

Instances

Algebra Choose NonEmpty

Defined in Control.Algebra

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n NonEmpty -> Choose n a -> ctx () -> NonEmpty (ctx a)

Algebra NonDet []

Defined in Control.Algebra

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n [] -> NonDet n a -> ctx () -> [ctx a]

Algebra sig m => Algebra (Choose :+: sig) (ChooseC m)

Defined in Control.Carrier.Choose.Church

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (ChooseC m) -> (Choose :+: sig) n a -> ctx () -> ChooseC m (ctx a)

Algebra sig m => Algebra (Cull :+: (NonDet :+: sig)) (CullC m)

Defined in Control.Carrier.Cull.Church

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (CullC m) -> (Cull :+: (NonDet :+: sig)) n a -> ctx () -> CullC m (ctx a)

Algebra sig m => Algebra (Cut :+: (NonDet :+: sig)) (CutC m)

Defined in Control.Carrier.Cut.Church

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (CutC m) -> (Cut :+: (NonDet :+: sig)) n a -> ctx () -> CutC m (ctx a)

Algebra sig m => Algebra (NonDet :+: sig) (NonDetC m)

Defined in Control.Carrier.NonDet.Church

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (NonDetC m) -> (NonDet :+: sig) n a -> ctx () -> NonDetC m (ctx a)

data Empty (m :: Type -> Type) k where

Since: 1.0.0.0

Constructors

Empty :: forall (m :: Type -> Type) k. Empty m k

Instances

Algebra Empty Maybe

Defined in Control.Algebra

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n Maybe -> Empty n a -> ctx () -> Maybe (ctx a)

Algebra NonDet []

Defined in Control.Algebra

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n [] -> NonDet n a -> ctx () -> [ctx a]

Algebra sig m => Algebra (Cull :+: (NonDet :+: sig)) (CullC m)

Defined in Control.Carrier.Cull.Church

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (CullC m) -> (Cull :+: (NonDet :+: sig)) n a -> ctx () -> CullC m (ctx a)

Algebra sig m => Algebra (Cut :+: (NonDet :+: sig)) (CutC m)

Defined in Control.Carrier.Cut.Church

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (CutC m) -> (Cut :+: (NonDet :+: sig)) n a -> ctx () -> CutC m (ctx a)

Algebra sig m => Algebra (Empty :+: sig) (EmptyC m)

Defined in Control.Carrier.Empty.Church

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (EmptyC m) -> (Empty :+: sig) n a -> ctx () -> EmptyC m (ctx a)

Algebra sig m => Algebra (Empty :+: sig) (EmptyC m)

Defined in Control.Carrier.Empty.Maybe

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (EmptyC m) -> (Empty :+: sig) n a -> ctx () -> EmptyC m (ctx a)

Algebra sig m => Algebra (Empty :+: sig) (MaybeT m)

Defined in Control.Algebra

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (MaybeT m) -> (Empty :+: sig) n a -> ctx () -> MaybeT m (ctx a)

Algebra sig m => Algebra (NonDet :+: sig) (NonDetC m)

Defined in Control.Carrier.NonDet.Church

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (NonDetC m) -> (NonDet :+: sig) n a -> ctx () -> NonDetC m (ctx a)

oneOf :: (Foldable t, Alternative m) => t a -> m a

Nondeterministically choose an element from a Foldable collection. This can be used to emulate the style of nondeterminism associated with programming in the list monad:

  pythagoreanTriples = do
    a <- oneOf [1..10]
    b <- oneOf [1..10]
    c <- oneOf [1..10]
    guard (a^2 + b^2 == c^2)
    pure (a, b, c)

Since: 1.0.0.0

foldMapA :: (Foldable t, Alternative m) => (a -> m b) -> t a -> m b

Map a Foldable collection of values into a nondeterministic computation using the supplied action.

Since: 1.0.0.0

Re-exports

class Applicative f => Alternative (f :: Type -> Type) where

A monoid on applicative functors.

If defined, some and many should be the least solutions of the equations:

• some v = (:) <$> v <*> many v

• many v = some v <|> pure []

Examples

>>> Nothing <|> Just 42
Just 42

>>> [1, 2] <|> [3, 4]
[1,2,3,4]

>>> empty <|> print (2^15)
32768

Minimal complete definition

empty, (<|>)

Methods

empty :: f a

The identity of <|>

empty <|> a     == a
a     <|> empty == a

(<|>) :: f a -> f a -> f a infixl 3

An associative binary operation

some :: f a -> f [a]

One or more.

Examples

>>> some (putStr "la")
lalalalalalalalala... * goes on forever *

>>> some Nothing
nothing

>>> take 5 <$> some (Just 1)
* hangs forever *

Note that this function can be used with Parsers based on Applicatives. In that case some parser will attempt to parse parser one or more times until it fails.

many :: f a -> f [a]

Zero or more.

Examples

>>> many (putStr "la")
lalalalalalalalala... * goes on forever *

>>> many Nothing
Just []

>>> take 5 <$> many (Just 1)
* hangs forever *

Note that this function can be used with Parsers based on Applicatives. In that case many parser will attempt to parse parser zero or more times until it fails.

Instances

Alternative IO

Takes the first non-throwing IO action's result. empty throws an exception.

@since base-4.9.0.0

Defined in GHC.Internal.Base

Methods

empty :: IO a

(<|>) :: IO a -> IO a -> IO a

some :: IO a -> IO [a]

many :: IO a -> IO [a]

Alternative Maybe

Picks the leftmost Just value, or, alternatively, Nothing.

@since base-2.01

Defined in GHC.Internal.Base

Methods

empty :: Maybe a

(<|>) :: Maybe a -> Maybe a -> Maybe a

some :: Maybe a -> Maybe [a]

many :: Maybe a -> Maybe [a]

Alternative []

Combines lists by concatenation, starting from the empty list.

@since base-2.01

Defined in GHC.Internal.Base

Methods

empty :: [a]

(<|>) :: [a] -> [a] -> [a]

some :: [a] -> [[a]]

many :: [a] -> [[a]]

MonadPlus m => Alternative (WrappedMonad m)

Since: base-2.1

Defined in Control.Applicative

Methods

empty :: WrappedMonad m a

(<|>) :: WrappedMonad m a -> WrappedMonad m a -> WrappedMonad m a

some :: WrappedMonad m a -> WrappedMonad m [a]

many :: WrappedMonad m a -> WrappedMonad m [a]

Alternative (CullC m)

Defined in Control.Carrier.Cull.Church

Methods

empty :: CullC m a

(<|>) :: CullC m a -> CullC m a -> CullC m a

some :: CullC m a -> CullC m [a]

many :: CullC m a -> CullC m [a]

Alternative (CutC m)

Defined in Control.Carrier.Cut.Church

Methods

empty :: CutC m a

(<|>) :: CutC m a -> CutC m a -> CutC m a

some :: CutC m a -> CutC m [a]

many :: CutC m a -> CutC m [a]

(Alternative m, Monad m) => Alternative (FailC m)

Defined in Control.Carrier.Fail.Either

Methods

empty :: FailC m a

(<|>) :: FailC m a -> FailC m a -> FailC m a

some :: FailC m a -> FailC m [a]

many :: FailC m a -> FailC m [a]

Alternative m => Alternative (FreshC m)

Defined in Control.Carrier.Fresh.Church

Methods

empty :: FreshC m a

(<|>) :: FreshC m a -> FreshC m a -> FreshC m a

some :: FreshC m a -> FreshC m [a]

many :: FreshC m a -> FreshC m [a]

(Alternative m, Monad m) => Alternative (FreshC m)

Defined in Control.Carrier.Fresh.Strict

Methods

empty :: FreshC m a

(<|>) :: FreshC m a -> FreshC m a -> FreshC m a

some :: FreshC m a -> FreshC m [a]

many :: FreshC m a -> FreshC m [a]

Alternative m => Alternative (LiftC m)

Defined in Control.Carrier.Lift

Methods

empty :: LiftC m a

(<|>) :: LiftC m a -> LiftC m a -> LiftC m a

some :: LiftC m a -> LiftC m [a]

many :: LiftC m a -> LiftC m [a]

Alternative (NonDetC m)

Defined in Control.Carrier.NonDet.Church

Methods

empty :: NonDetC m a

(<|>) :: NonDetC m a -> NonDetC m a -> NonDetC m a

some :: NonDetC m a -> NonDetC m [a]

many :: NonDetC m a -> NonDetC m [a]

Alternative m => Alternative (TraceC m)

Defined in Control.Carrier.Trace.Ignoring

Methods

empty :: TraceC m a

(<|>) :: TraceC m a -> TraceC m a -> TraceC m a

some :: TraceC m a -> TraceC m [a]

many :: TraceC m a -> TraceC m [a]

Alternative m => Alternative (TraceC m)

Defined in Control.Carrier.Trace.Printing

Methods

empty :: TraceC m a

(<|>) :: TraceC m a -> TraceC m a -> TraceC m a

some :: TraceC m a -> TraceC m [a]

many :: TraceC m a -> TraceC m [a]

(Alternative m, Monad m) => Alternative (TraceC m)

Defined in Control.Carrier.Trace.Returning

Methods

empty :: TraceC m a

(<|>) :: TraceC m a -> TraceC m a -> TraceC m a

some :: TraceC m a -> TraceC m [a]

many :: TraceC m a -> TraceC m [a]

(Has Choose sig m, Has Empty sig m) => Alternative (Choosing m)

Defined in Control.Effect.Choose

Methods

empty :: Choosing m a

(<|>) :: Choosing m a -> Choosing m a -> Choosing m a

some :: Choosing m a -> Choosing m [a]

many :: Choosing m a -> Choosing m [a]

Alternative (U1 :: Type -> Type)

@since base-4.9.0.0

Defined in GHC.Internal.Generics

Methods

empty :: U1 a

(<|>) :: U1 a -> U1 a -> U1 a

some :: U1 a -> U1 [a]

many :: U1 a -> U1 [a]

Alternative f => Alternative (Lift f)

A combination is Pure only either part is.

Defined in Control.Applicative.Lift

Methods

empty :: Lift f a

(<|>) :: Lift f a -> Lift f a -> Lift f a

some :: Lift f a -> Lift f [a]

many :: Lift f a -> Lift f [a]

(Functor m, Monad m) => Alternative (MaybeT m)

Defined in Control.Monad.Trans.Maybe

Methods

empty :: MaybeT m a

(<|>) :: MaybeT m a -> MaybeT m a -> MaybeT m a

some :: MaybeT m a -> MaybeT m [a]

many :: MaybeT m a -> MaybeT m [a]

(ArrowZero a, ArrowPlus a) => Alternative (WrappedArrow a b)

Since: base-2.1

Defined in Control.Applicative

Methods

empty :: WrappedArrow a b a0

(<|>) :: WrappedArrow a b a0 -> WrappedArrow a b a0 -> WrappedArrow a b a0

some :: WrappedArrow a b a0 -> WrappedArrow a b [a0]

many :: WrappedArrow a b a0 -> WrappedArrow a b [a0]

(Alternative m, Monad m, Monoid w) => Alternative (AccumC w m)

Defined in Control.Carrier.Accum.Church

Methods

empty :: AccumC w m a

(<|>) :: AccumC w m a -> AccumC w m a -> AccumC w m a

some :: AccumC w m a -> AccumC w m [a]

many :: AccumC w m a -> AccumC w m [a]

Alternative m => Alternative (AccumC w m)

Defined in Control.Carrier.Accum.IORef

Methods

empty :: AccumC w m a

(<|>) :: AccumC w m a -> AccumC w m a -> AccumC w m a

some :: AccumC w m a -> AccumC w m [a]

many :: AccumC w m a -> AccumC w m [a]

(Alternative m, Monad m, Monoid w) => Alternative (AccumC w m)

Defined in Control.Carrier.Accum.Strict

Methods

empty :: AccumC w m a

(<|>) :: AccumC w m a -> AccumC w m a -> AccumC w m a

some :: AccumC w m a -> AccumC w m [a]

many :: AccumC w m a -> AccumC w m [a]

Alternative m => Alternative (ErrorC e m)

Defined in Control.Carrier.Error.Church

Methods

empty :: ErrorC e m a

(<|>) :: ErrorC e m a -> ErrorC e m a -> ErrorC e m a

some :: ErrorC e m a -> ErrorC e m [a]

many :: ErrorC e m a -> ErrorC e m [a]

(Alternative m, Monad m) => Alternative (ErrorC e m)

ErrorC passes Alternative operations along to the underlying monad m, rather than combining errors à la ExceptT.

Defined in Control.Carrier.Error.Either

Methods

empty :: ErrorC e m a

(<|>) :: ErrorC e m a -> ErrorC e m a -> ErrorC e m a

some :: ErrorC e m a -> ErrorC e m [a]

many :: ErrorC e m a -> ErrorC e m [a]

Alternative m => Alternative (ReaderC r m)

Defined in Control.Carrier.Reader

Methods

empty :: ReaderC r m a

(<|>) :: ReaderC r m a -> ReaderC r m a -> ReaderC r m a

some :: ReaderC r m a -> ReaderC r m [a]

many :: ReaderC r m a -> ReaderC r m [a]

Alternative m => Alternative (StateC s m)

Defined in Control.Carrier.State.Church

Methods

empty :: StateC s m a

(<|>) :: StateC s m a -> StateC s m a -> StateC s m a

some :: StateC s m a -> StateC s m [a]

many :: StateC s m a -> StateC s m [a]

Alternative m => Alternative (StateC s m)

Defined in Control.Carrier.State.IORef

Methods

empty :: StateC s m a

(<|>) :: StateC s m a -> StateC s m a -> StateC s m a

some :: StateC s m a -> StateC s m [a]

many :: StateC s m a -> StateC s m [a]

(Alternative m, Monad m) => Alternative (StateC s m)

Defined in Control.Carrier.State.Lazy

Methods

empty :: StateC s m a

(<|>) :: StateC s m a -> StateC s m a -> StateC s m a

some :: StateC s m a -> StateC s m [a]

many :: StateC s m a -> StateC s m [a]

(Alternative m, Monad m) => Alternative (StateC s m)

Defined in Control.Carrier.State.Strict

Methods

empty :: StateC s m a

(<|>) :: StateC s m a -> StateC s m a -> StateC s m a

some :: StateC s m a -> StateC s m [a]

many :: StateC s m a -> StateC s m [a]

(Alternative m, Monad m) => Alternative (ThrowC e m)

Defined in Control.Carrier.Throw.Either

Methods

empty :: ThrowC e m a

(<|>) :: ThrowC e m a -> ThrowC e m a -> ThrowC e m a

some :: ThrowC e m a -> ThrowC e m [a]

many :: ThrowC e m a -> ThrowC e m [a]

Alternative m => Alternative (WriterC w m)

Defined in Control.Carrier.Writer.Church

Methods

empty :: WriterC w m a

(<|>) :: WriterC w m a -> WriterC w m a -> WriterC w m a

some :: WriterC w m a -> WriterC w m [a]

many :: WriterC w m a -> WriterC w m [a]

(Alternative m, Monad m) => Alternative (WriterC w m)

Defined in Control.Carrier.Writer.Strict

Methods

empty :: WriterC w m a

(<|>) :: WriterC w m a -> WriterC w m a -> WriterC w m a

some :: WriterC w m a -> WriterC w m [a]

many :: WriterC w m a -> WriterC w m [a]

Alternative f => Alternative (Ap f)

@since base-4.12.0.0

Defined in GHC.Internal.Data.Monoid

Methods

empty :: Ap f a

(<|>) :: Ap f a -> Ap f a -> Ap f a

some :: Ap f a -> Ap f [a]

many :: Ap f a -> Ap f [a]

Alternative f => Alternative (Alt f)

@since base-4.8.0.0

Defined in GHC.Internal.Data.Semigroup.Internal

Methods

empty :: Alt f a

(<|>) :: Alt f a -> Alt f a -> Alt f a

some :: Alt f a -> Alt f [a]

many :: Alt f a -> Alt f [a]

(Generic1 f, Alternative (Rep1 f)) => Alternative (Generically1 f)

@since base-4.17.0.0

Defined in GHC.Internal.Generics

Methods

empty :: Generically1 f a

(<|>) :: Generically1 f a -> Generically1 f a -> Generically1 f a

some :: Generically1 f a -> Generically1 f [a]

many :: Generically1 f a -> Generically1 f [a]

Alternative f => Alternative (Rec1 f)

@since base-4.9.0.0

Defined in GHC.Internal.Generics

Methods

empty :: Rec1 f a

(<|>) :: Rec1 f a -> Rec1 f a -> Rec1 f a

some :: Rec1 f a -> Rec1 f [a]

many :: Rec1 f a -> Rec1 f [a]

Alternative f => Alternative (Backwards f)

Try alternatives in the same order as f.

Defined in Control.Applicative.Backwards

Methods

empty :: Backwards f a

(<|>) :: Backwards f a -> Backwards f a -> Backwards f a

some :: Backwards f a -> Backwards f [a]

many :: Backwards f a -> Backwards f [a]

(Monoid w, Functor m, MonadPlus m) => Alternative (AccumT w m)

Defined in Control.Monad.Trans.Accum

Methods

empty :: AccumT w m a

(<|>) :: AccumT w m a -> AccumT w m a -> AccumT w m a

some :: AccumT w m a -> AccumT w m [a]

many :: AccumT w m a -> AccumT w m [a]

(Functor m, Monad m, Monoid e) => Alternative (ExceptT e m)

Defined in Control.Monad.Trans.Except

Methods

empty :: ExceptT e m a

(<|>) :: ExceptT e m a -> ExceptT e m a -> ExceptT e m a

some :: ExceptT e m a -> ExceptT e m [a]

many :: ExceptT e m a -> ExceptT e m [a]

Alternative m => Alternative (IdentityT m)

Defined in Control.Monad.Trans.Identity

Methods

empty :: IdentityT m a

(<|>) :: IdentityT m a -> IdentityT m a -> IdentityT m a

some :: IdentityT m a -> IdentityT m [a]

many :: IdentityT m a -> IdentityT m [a]

Alternative m => Alternative (ReaderT r m)

Defined in Control.Monad.Trans.Reader

Methods

empty :: ReaderT r m a

(<|>) :: ReaderT r m a -> ReaderT r m a -> ReaderT r m a

some :: ReaderT r m a -> ReaderT r m [a]

many :: ReaderT r m a -> ReaderT r m [a]

(Functor m, MonadPlus m) => Alternative (SelectT r m)

Defined in Control.Monad.Trans.Select

Methods

empty :: SelectT r m a

(<|>) :: SelectT r m a -> SelectT r m a -> SelectT r m a

some :: SelectT r m a -> SelectT r m [a]

many :: SelectT r m a -> SelectT r m [a]

(Functor m, MonadPlus m) => Alternative (StateT s m)

Defined in Control.Monad.Trans.State.Lazy

Methods

empty :: StateT s m a

(<|>) :: StateT s m a -> StateT s m a -> StateT s m a

some :: StateT s m a -> StateT s m [a]

many :: StateT s m a -> StateT s m [a]

(Functor m, MonadPlus m) => Alternative (StateT s m)

Defined in Control.Monad.Trans.State.Strict

Methods

empty :: StateT s m a

(<|>) :: StateT s m a -> StateT s m a -> StateT s m a

some :: StateT s m a -> StateT s m [a]

many :: StateT s m a -> StateT s m [a]

(Functor m, MonadPlus m) => Alternative (WriterT w m)

Defined in Control.Monad.Trans.Writer.CPS

Methods

empty :: WriterT w m a

(<|>) :: WriterT w m a -> WriterT w m a -> WriterT w m a

some :: WriterT w m a -> WriterT w m [a]

many :: WriterT w m a -> WriterT w m [a]

(Monoid w, Alternative m) => Alternative (WriterT w m)

Defined in Control.Monad.Trans.Writer.Lazy

Methods

empty :: WriterT w m a

(<|>) :: WriterT w m a -> WriterT w m a -> WriterT w m a

some :: WriterT w m a -> WriterT w m [a]

many :: WriterT w m a -> WriterT w m [a]

(Monoid w, Alternative m) => Alternative (WriterT w m)

Defined in Control.Monad.Trans.Writer.Strict

Methods

empty :: WriterT w m a

(<|>) :: WriterT w m a -> WriterT w m a -> WriterT w m a

some :: WriterT w m a -> WriterT w m [a]

many :: WriterT w m a -> WriterT w m [a]

Alternative f => Alternative (Reverse f)

Derived instance.

Defined in Data.Functor.Reverse

Methods

empty :: Reverse f a

(<|>) :: Reverse f a -> Reverse f a -> Reverse f a

some :: Reverse f a -> Reverse f [a]

many :: Reverse f a -> Reverse f [a]

(Alternative f, Alternative g) => Alternative (Product f g)

Since: base-4.9.0.0

Defined in Data.Functor.Product

Methods

empty :: Product f g a

(<|>) :: Product f g a -> Product f g a -> Product f g a

some :: Product f g a -> Product f g [a]

many :: Product f g a -> Product f g [a]

Alternative m => Alternative (InterpretC s sig m)

Defined in Control.Carrier.Interpret

Methods

empty :: InterpretC s sig m a

(<|>) :: InterpretC s sig m a -> InterpretC s sig m a -> InterpretC s sig m a

some :: InterpretC s sig m a -> InterpretC s sig m [a]

many :: InterpretC s sig m a -> InterpretC s sig m [a]

(Alternative f, Alternative g) => Alternative (f :*: g)

@since base-4.9.0.0

Defined in GHC.Internal.Generics

Methods

empty :: (f :*: g) a

(<|>) :: (f :*: g) a -> (f :*: g) a -> (f :*: g) a

some :: (f :*: g) a -> (f :*: g) [a]

many :: (f :*: g) a -> (f :*: g) [a]

(Alternative f, Applicative g) => Alternative (Compose f g)

Since: base-4.9.0.0

Defined in Data.Functor.Compose

Methods

empty :: Compose f g a

(<|>) :: Compose f g a -> Compose f g a -> Compose f g a

some :: Compose f g a -> Compose f g [a]

many :: Compose f g a -> Compose f g [a]

Alternative (sub m) => Alternative (Labelled label sub m)

Defined in Control.Effect.Labelled

Methods

empty :: Labelled label sub m a

(<|>) :: Labelled label sub m a -> Labelled label sub m a -> Labelled label sub m a

some :: Labelled label sub m a -> Labelled label sub m [a]

many :: Labelled label sub m a -> Labelled label sub m [a]

Alternative m => Alternative (UnderLabel label sub m)

Defined in Control.Effect.Labelled

Methods

empty :: UnderLabel label sub m a

(<|>) :: UnderLabel label sub m a -> UnderLabel label sub m a -> UnderLabel label sub m a

some :: UnderLabel label sub m a -> UnderLabel label sub m [a]

many :: UnderLabel label sub m a -> UnderLabel label sub m [a]

(Alternative f, Applicative g) => Alternative (f :.: g)

@since base-4.9.0.0

Defined in GHC.Internal.Generics

Methods

empty :: (f :.: g) a

(<|>) :: (f :.: g) a -> (f :.: g) a -> (f :.: g) a

some :: (f :.: g) a -> (f :.: g) [a]

many :: (f :.: g) a -> (f :.: g) [a]

Alternative f => Alternative (M1 i c f)

@since base-4.9.0.0

Defined in GHC.Internal.Generics

Methods

empty :: M1 i c f a

(<|>) :: M1 i c f a -> M1 i c f a -> M1 i c f a

some :: M1 i c f a -> M1 i c f [a]

many :: M1 i c f a -> M1 i c f [a]

(Functor m, MonadPlus m) => Alternative (RWST r w s m)

Defined in Control.Monad.Trans.RWS.CPS

Methods

empty :: RWST r w s m a

(<|>) :: RWST r w s m a -> RWST r w s m a -> RWST r w s m a

some :: RWST r w s m a -> RWST r w s m [a]

many :: RWST r w s m a -> RWST r w s m [a]

(Monoid w, Functor m, MonadPlus m) => Alternative (RWST r w s m)

Defined in Control.Monad.Trans.RWS.Lazy

Methods

empty :: RWST r w s m a

(<|>) :: RWST r w s m a -> RWST r w s m a -> RWST r w s m a

some :: RWST r w s m a -> RWST r w s m [a]

many :: RWST r w s m a -> RWST r w s m [a]

(Monoid w, Functor m, MonadPlus m) => Alternative (RWST r w s m)

Defined in Control.Monad.Trans.RWS.Strict

Methods

empty :: RWST r w s m a

(<|>) :: RWST r w s m a -> RWST r w s m a -> RWST r w s m a

some :: RWST r w s m a -> RWST r w s m [a]

many :: RWST r w s m a -> RWST r w s m [a]

class Monad m => Algebra (sig :: (Type -> Type) -> Type -> Type) (m :: Type -> Type) | m -> sig

The class of carriers (results) for algebras (effect handlers) over signatures (effects), whose actions are given by the alg method.

Since: 1.0.0.0

Minimal complete definition

alg

Instances

Algebra Choose NonEmpty

Defined in Control.Algebra

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n NonEmpty -> Choose n a -> ctx () -> NonEmpty (ctx a)

Algebra Empty Maybe

Defined in Control.Algebra

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n Maybe -> Empty n a -> ctx () -> Maybe (ctx a)

Algebra NonDet []

Defined in Control.Algebra

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n [] -> NonDet n a -> ctx () -> [ctx a]

Algebra sig m => Algebra sig (Choosing m)

Defined in Control.Effect.Choose

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (Choosing m) -> sig n a -> ctx () -> Choosing m (ctx a)

Algebra sig m => Algebra sig (Ap m)

This instance permits effectful actions to be lifted into the Ap monad given a monoidal return type, which can provide clarity when chaining calls to mappend.

mappend <$> act1 <*> (mappend <$> act2 <*> act3)

is equivalent to

getAp (act1 <> act2 <> act3)

Since: 1.0.1.0

Defined in Control.Algebra

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (Ap m) -> sig n a -> ctx () -> Ap m (ctx a)

Algebra sig m => Algebra sig (Alt m)

This instance permits effectful actions to be lifted into the Alt monad, which eases the invocation of repeated alternation with <|>:

a <|> b <|> c <|> d

is equivalent to

getAlt (mconcat [a, b, c, d])

Since: 1.0.1.0

Defined in Control.Algebra

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (Alt m) -> sig n a -> ctx () -> Alt m (ctx a)

Algebra sig m => Algebra sig (IdentityT m)

Defined in Control.Algebra

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (IdentityT m) -> sig n a -> ctx () -> IdentityT m (ctx a)

Algebra (Lift Identity) Identity

Defined in Control.Algebra

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n Identity -> Lift Identity n a -> ctx () -> Identity (ctx a)

Algebra (Lift IO) IO

Defined in Control.Algebra

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n IO -> Lift IO n a -> ctx () -> IO (ctx a)

Algebra (Error e) (Either e)

Defined in Control.Algebra

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (Either e) -> Error e n a -> ctx () -> Either e (ctx a)

Monad m => Algebra (Lift m) (LiftC m)

Defined in Control.Carrier.Lift

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (LiftC m) -> Lift m n a -> ctx () -> LiftC m (ctx a)

Monoid w => Algebra (Writer w) ((,) w)

Defined in Control.Algebra

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n ((,) w) -> Writer w n a -> ctx () -> (w, ctx a)

Algebra (Reader r) ((->) r)

Defined in Control.Algebra

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n ((->) r) -> Reader r n a -> ctx () -> r -> ctx a

Algebra sig m => Algebra (Choose :+: sig) (ChooseC m)

Defined in Control.Carrier.Choose.Church

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (ChooseC m) -> (Choose :+: sig) n a -> ctx () -> ChooseC m (ctx a)

Algebra sig m => Algebra (Cull :+: (NonDet :+: sig)) (CullC m)

Defined in Control.Carrier.Cull.Church

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (CullC m) -> (Cull :+: (NonDet :+: sig)) n a -> ctx () -> CullC m (ctx a)

Algebra sig m => Algebra (Cut :+: (NonDet :+: sig)) (CutC m)

Defined in Control.Carrier.Cut.Church

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (CutC m) -> (Cut :+: (NonDet :+: sig)) n a -> ctx () -> CutC m (ctx a)

Algebra sig m => Algebra (Empty :+: sig) (EmptyC m)

Defined in Control.Carrier.Empty.Church

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (EmptyC m) -> (Empty :+: sig) n a -> ctx () -> EmptyC m (ctx a)

Algebra sig m => Algebra (Empty :+: sig) (EmptyC m)

Defined in Control.Carrier.Empty.Maybe

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (EmptyC m) -> (Empty :+: sig) n a -> ctx () -> EmptyC m (ctx a)

Algebra sig m => Algebra (Empty :+: sig) (MaybeT m)

Defined in Control.Algebra

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (MaybeT m) -> (Empty :+: sig) n a -> ctx () -> MaybeT m (ctx a)

Algebra sig m => Algebra (Fail :+: sig) (FailC m)

Defined in Control.Carrier.Fail.Either

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (FailC m) -> (Fail :+: sig) n a -> ctx () -> FailC m (ctx a)

Algebra sig m => Algebra (Fresh :+: sig) (FreshC m)

Defined in Control.Carrier.Fresh.Church

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (FreshC m) -> (Fresh :+: sig) n a -> ctx () -> FreshC m (ctx a)

Algebra sig m => Algebra (Fresh :+: sig) (FreshC m)

Defined in Control.Carrier.Fresh.Strict

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (FreshC m) -> (Fresh :+: sig) n a -> ctx () -> FreshC m (ctx a)

Algebra sig m => Algebra (NonDet :+: sig) (NonDetC m)

Defined in Control.Carrier.NonDet.Church

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (NonDetC m) -> (NonDet :+: sig) n a -> ctx () -> NonDetC m (ctx a)

Algebra sig m => Algebra (Trace :+: sig) (TraceC m)

Defined in Control.Carrier.Trace.Ignoring

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (TraceC m) -> (Trace :+: sig) n a -> ctx () -> TraceC m (ctx a)

(MonadIO m, Algebra sig m) => Algebra (Trace :+: sig) (TraceC m)

Defined in Control.Carrier.Trace.Printing

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (TraceC m) -> (Trace :+: sig) n a -> ctx () -> TraceC m (ctx a)

Algebra sig m => Algebra (Trace :+: sig) (TraceC m)

Defined in Control.Carrier.Trace.Returning

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (TraceC m) -> (Trace :+: sig) n a -> ctx () -> TraceC m (ctx a)

(Algebra sig m, Monoid w) => Algebra (Accum w :+: sig) (AccumC w m)

Defined in Control.Carrier.Accum.Church

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (AccumC w m) -> (Accum w :+: sig) n a -> ctx () -> AccumC w m (ctx a)

(Algebra sig m, Semigroup w, MonadIO m) => Algebra (Accum w :+: sig) (AccumC w m)

Defined in Control.Carrier.Accum.IORef

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (AccumC w m) -> (Accum w :+: sig) n a -> ctx () -> AccumC w m (ctx a)

(Algebra sig m, Monoid w) => Algebra (Accum w :+: sig) (AccumC w m)

Defined in Control.Carrier.Accum.Strict

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (AccumC w m) -> (Accum w :+: sig) n a -> ctx () -> AccumC w m (ctx a)

(Algebra sig m, Monoid w) => Algebra (Accum w :+: sig) (AccumT w m)

Defined in Control.Algebra

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (AccumT w m) -> (Accum w :+: sig) n a -> ctx () -> AccumT w m (ctx a)

Algebra sig m => Algebra (Error e :+: sig) (ErrorC e m)

Defined in Control.Carrier.Error.Church

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (ErrorC e m) -> (Error e :+: sig) n a -> ctx () -> ErrorC e m (ctx a)

Algebra sig m => Algebra (Error e :+: sig) (ErrorC e m)

Defined in Control.Carrier.Error.Either

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (ErrorC e m) -> (Error e :+: sig) n a -> ctx () -> ErrorC e m (ctx a)

Algebra sig m => Algebra (Error e :+: sig) (ExceptT e m)

Defined in Control.Algebra

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (ExceptT e m) -> (Error e :+: sig) n a -> ctx () -> ExceptT e m (ctx a)

Algebra sig m => Algebra (Reader r :+: sig) (ReaderC r m)

Defined in Control.Carrier.Reader

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (ReaderC r m) -> (Reader r :+: sig) n a -> ctx () -> ReaderC r m (ctx a)

Algebra sig m => Algebra (Reader r :+: sig) (ReaderT r m)

Defined in Control.Algebra

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (ReaderT r m) -> (Reader r :+: sig) n a -> ctx () -> ReaderT r m (ctx a)

Algebra sig m => Algebra (State s :+: sig) (StateC s m)

Defined in Control.Carrier.State.Church

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (StateC s m) -> (State s :+: sig) n a -> ctx () -> StateC s m (ctx a)

(MonadIO m, Algebra sig m) => Algebra (State s :+: sig) (StateC s m)

Defined in Control.Carrier.State.IORef

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (StateC s m) -> (State s :+: sig) n a -> ctx () -> StateC s m (ctx a)

Algebra sig m => Algebra (State s :+: sig) (StateC s m)

Defined in Control.Carrier.State.Lazy

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (StateC s m) -> (State s :+: sig) n a -> ctx () -> StateC s m (ctx a)

Algebra sig m => Algebra (State s :+: sig) (StateC s m)

Defined in Control.Carrier.State.Strict

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (StateC s m) -> (State s :+: sig) n a -> ctx () -> StateC s m (ctx a)

Algebra sig m => Algebra (State s :+: sig) (StateT s m)

Defined in Control.Algebra

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (StateT s m) -> (State s :+: sig) n a -> ctx () -> StateT s m (ctx a)

Algebra sig m => Algebra (State s :+: sig) (StateT s m)

Defined in Control.Algebra

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (StateT s m) -> (State s :+: sig) n a -> ctx () -> StateT s m (ctx a)

Algebra sig m => Algebra (Throw e :+: sig) (ThrowC e m)

Defined in Control.Carrier.Throw.Either

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (ThrowC e m) -> (Throw e :+: sig) n a -> ctx () -> ThrowC e m (ctx a)

(Algebra sig m, Monoid w) => Algebra (Writer w :+: sig) (WriterC w m)

Defined in Control.Carrier.Writer.Church

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (WriterC w m) -> (Writer w :+: sig) n a -> ctx () -> WriterC w m (ctx a)

(Monoid w, Algebra sig m) => Algebra (Writer w :+: sig) (WriterC w m)

Defined in Control.Carrier.Writer.Strict

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (WriterC w m) -> (Writer w :+: sig) n a -> ctx () -> WriterC w m (ctx a)

(Algebra sig m, Monoid w) => Algebra (Writer w :+: sig) (WriterT w m)

Defined in Control.Algebra

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (WriterT w m) -> (Writer w :+: sig) n a -> ctx () -> WriterT w m (ctx a)

(Algebra sig m, Monoid w) => Algebra (Writer w :+: sig) (WriterT w m)

Defined in Control.Algebra

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (WriterT w m) -> (Writer w :+: sig) n a -> ctx () -> WriterT w m (ctx a)

(Algebra sig m, Monoid w) => Algebra (Writer w :+: sig) (WriterT w m)

Defined in Control.Algebra

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (WriterT w m) -> (Writer w :+: sig) n a -> ctx () -> WriterT w m (ctx a)

(Reifies s (Interpreter eff m), Algebra sig m) => Algebra (eff :+: sig) (InterpretC s eff m)

Defined in Control.Carrier.Interpret

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (InterpretC s eff m) -> (eff :+: sig) n a -> ctx () -> InterpretC s eff m (ctx a)

Algebra (eff :+: sig) (sub m) => Algebra (Labelled label eff :+: sig) (Labelled label sub m)

Defined in Control.Effect.Labelled

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (Labelled label sub m) -> (Labelled label eff :+: sig) n a -> ctx () -> Labelled label sub m (ctx a)

(Algebra sig m, Monoid w) => Algebra (Reader r :+: (Writer w :+: (State s :+: sig))) (RWST r w s m)

Defined in Control.Algebra

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (RWST r w s m) -> (Reader r :+: (Writer w :+: (State s :+: sig))) n a -> ctx () -> RWST r w s m (ctx a)

(Algebra sig m, Monoid w) => Algebra (Reader r :+: (Writer w :+: (State s :+: sig))) (RWST r w s m)

Defined in Control.Algebra

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (RWST r w s m) -> (Reader r :+: (Writer w :+: (State s :+: sig))) n a -> ctx () -> RWST r w s m (ctx a)

(Algebra sig m, Monoid w) => Algebra (Reader r :+: (Writer w :+: (State s :+: sig))) (RWST r w s m)

Defined in Control.Algebra

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (RWST r w s m) -> (Reader r :+: (Writer w :+: (State s :+: sig))) n a -> ctx () -> RWST r w s m (ctx a)

(LabelledMember label sub sig, Algebra sig m) => Algebra (sub :+: sig) (UnderLabel label sub m)

Defined in Control.Effect.Labelled

Methods

alg :: forall ctx (n :: Type -> Type) a. Functor ctx => Handler ctx n (UnderLabel label sub m) -> (sub :+: sig) n a -> ctx () -> UnderLabel label sub m (ctx a)

type Has (eff :: (Type -> Type) -> Type -> Type) (sig :: (Type -> Type) -> Type -> Type) (m :: Type -> Type) = (Members eff sig, Algebra sig m)

m is a carrier for sig containing eff.

Note that if eff is a sum, it will be decomposed into multiple Member constraints. While this technically allows one to combine multiple unrelated effects into a single Has constraint, doing so has two significant drawbacks:

1. Due to a problem with recursive type families, this can lead to significantly slower compiles.
2. It defeats ghc’s warnings for redundant constraints, and thus can lead to a proliferation of redundant constraints as code is changed.

Since: 1.0.0.0

class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type) where

Monads that also support choice and failure.

Minimal complete definition

Nothing

Methods

mzero :: m a

The identity of mplus. It should also satisfy the equations

mzero >>= f  =  mzero
v >> mzero   =  mzero

The default definition is

mzero = empty

mplus :: m a -> m a -> m a

An associative operation. The default definition is

mplus = (<|>)

Instances

MonadPlus IO

Takes the first non-throwing IO action's result. mzero throws an exception.

@since base-4.9.0.0

Defined in GHC.Internal.Base

Methods

mzero :: IO a

mplus :: IO a -> IO a -> IO a

MonadPlus Maybe

Picks the leftmost Just value, or, alternatively, Nothing.

@since base-2.01

Defined in GHC.Internal.Base

Methods

mzero :: Maybe a

mplus :: Maybe a -> Maybe a -> Maybe a

MonadPlus []

Combines lists by concatenation, starting from the empty list.

@since base-2.01

Defined in GHC.Internal.Base

Methods

mzero :: [a]

mplus :: [a] -> [a] -> [a]

MonadPlus (CullC m)

Defined in Control.Carrier.Cull.Church

Methods

mzero :: CullC m a

mplus :: CullC m a -> CullC m a -> CullC m a

MonadPlus (CutC m)

Defined in Control.Carrier.Cut.Church

Methods

mzero :: CutC m a

mplus :: CutC m a -> CutC m a -> CutC m a

(Alternative m, Monad m) => MonadPlus (FailC m)

Defined in Control.Carrier.Fail.Either

Methods

mzero :: FailC m a

mplus :: FailC m a -> FailC m a -> FailC m a

(Alternative m, Monad m) => MonadPlus (FreshC m)

Defined in Control.Carrier.Fresh.Church

Methods

mzero :: FreshC m a

mplus :: FreshC m a -> FreshC m a -> FreshC m a

(Alternative m, Monad m) => MonadPlus (FreshC m)

Defined in Control.Carrier.Fresh.Strict

Methods

mzero :: FreshC m a

mplus :: FreshC m a -> FreshC m a -> FreshC m a

MonadPlus m => MonadPlus (LiftC m)

Defined in Control.Carrier.Lift

Methods

mzero :: LiftC m a

mplus :: LiftC m a -> LiftC m a -> LiftC m a

MonadPlus (NonDetC m)

Defined in Control.Carrier.NonDet.Church

Methods

mzero :: NonDetC m a

mplus :: NonDetC m a -> NonDetC m a -> NonDetC m a

MonadPlus m => MonadPlus (TraceC m)

Defined in Control.Carrier.Trace.Ignoring

Methods

mzero :: TraceC m a

mplus :: TraceC m a -> TraceC m a -> TraceC m a

MonadPlus m => MonadPlus (TraceC m)

Defined in Control.Carrier.Trace.Printing

Methods

mzero :: TraceC m a

mplus :: TraceC m a -> TraceC m a -> TraceC m a

(Alternative m, Monad m) => MonadPlus (TraceC m)

Defined in Control.Carrier.Trace.Returning

Methods

mzero :: TraceC m a

mplus :: TraceC m a -> TraceC m a -> TraceC m a

(Has Choose sig m, Has Empty sig m) => MonadPlus (Choosing m)

Defined in Control.Effect.Choose

Methods

mzero :: Choosing m a

mplus :: Choosing m a -> Choosing m a -> Choosing m a

MonadPlus (U1 :: Type -> Type)

@since base-4.9.0.0

Defined in GHC.Internal.Generics

Methods

mzero :: U1 a

mplus :: U1 a -> U1 a -> U1 a

Monad m => MonadPlus (MaybeT m)

Defined in Control.Monad.Trans.Maybe

Methods

mzero :: MaybeT m a

mplus :: MaybeT m a -> MaybeT m a -> MaybeT m a

(MonadPlus m, Monoid w) => MonadPlus (AccumC w m)

Defined in Control.Carrier.Accum.Church

Methods

mzero :: AccumC w m a

mplus :: AccumC w m a -> AccumC w m a -> AccumC w m a

(Alternative m, Monad m) => MonadPlus (AccumC w m)

Defined in Control.Carrier.Accum.IORef

Methods

mzero :: AccumC w m a

mplus :: AccumC w m a -> AccumC w m a -> AccumC w m a

(MonadPlus m, Monoid w) => MonadPlus (AccumC w m)

Defined in Control.Carrier.Accum.Strict

Methods

mzero :: AccumC w m a

mplus :: AccumC w m a -> AccumC w m a -> AccumC w m a

(Alternative m, Monad m) => MonadPlus (ErrorC e m)

Defined in Control.Carrier.Error.Church

Methods

mzero :: ErrorC e m a

mplus :: ErrorC e m a -> ErrorC e m a -> ErrorC e m a

(Alternative m, Monad m) => MonadPlus (ErrorC e m)

ErrorC passes MonadPlus operations along to the underlying monad m, rather than combining errors à la ExceptT.

Defined in Control.Carrier.Error.Either

Methods

mzero :: ErrorC e m a

mplus :: ErrorC e m a -> ErrorC e m a -> ErrorC e m a

(Alternative m, Monad m) => MonadPlus (ReaderC r m)

Defined in Control.Carrier.Reader

Methods

mzero :: ReaderC r m a

mplus :: ReaderC r m a -> ReaderC r m a -> ReaderC r m a

(Alternative m, Monad m) => MonadPlus (StateC s m)

Defined in Control.Carrier.State.Church

Methods

mzero :: StateC s m a

mplus :: StateC s m a -> StateC s m a -> StateC s m a

(Alternative m, Monad m) => MonadPlus (StateC s m)

Defined in Control.Carrier.State.IORef

Methods

mzero :: StateC s m a

mplus :: StateC s m a -> StateC s m a -> StateC s m a

(Alternative m, Monad m) => MonadPlus (StateC s m)

Defined in Control.Carrier.State.Lazy

Methods

mzero :: StateC s m a

mplus :: StateC s m a -> StateC s m a -> StateC s m a

(Alternative m, Monad m) => MonadPlus (StateC s m)

Defined in Control.Carrier.State.Strict

Methods

mzero :: StateC s m a

mplus :: StateC s m a -> StateC s m a -> StateC s m a

(Alternative m, Monad m) => MonadPlus (ThrowC e m)

Defined in Control.Carrier.Throw.Either

Methods

mzero :: ThrowC e m a

mplus :: ThrowC e m a -> ThrowC e m a -> ThrowC e m a

(Alternative m, Monad m) => MonadPlus (WriterC w m)

Defined in Control.Carrier.Writer.Church

Methods

mzero :: WriterC w m a

mplus :: WriterC w m a -> WriterC w m a -> WriterC w m a

(Alternative m, Monad m) => MonadPlus (WriterC w m)

Defined in Control.Carrier.Writer.Strict

Methods

mzero :: WriterC w m a

mplus :: WriterC w m a -> WriterC w m a -> WriterC w m a

MonadPlus f => MonadPlus (Ap f)

@since base-4.12.0.0

Defined in GHC.Internal.Data.Monoid

Methods

mzero :: Ap f a

mplus :: Ap f a -> Ap f a -> Ap f a

MonadPlus f => MonadPlus (Alt f)

@since base-4.8.0.0

Defined in GHC.Internal.Data.Semigroup.Internal

Methods

mzero :: Alt f a

mplus :: Alt f a -> Alt f a -> Alt f a

MonadPlus f => MonadPlus (Rec1 f)

@since base-4.9.0.0

Defined in GHC.Internal.Generics

Methods

mzero :: Rec1 f a

mplus :: Rec1 f a -> Rec1 f a -> Rec1 f a

(Monoid w, Functor m, MonadPlus m) => MonadPlus (AccumT w m)

Defined in Control.Monad.Trans.Accum

Methods

mzero :: AccumT w m a

mplus :: AccumT w m a -> AccumT w m a -> AccumT w m a

(Monad m, Monoid e) => MonadPlus (ExceptT e m)

Defined in Control.Monad.Trans.Except

Methods

mzero :: ExceptT e m a

mplus :: ExceptT e m a -> ExceptT e m a -> ExceptT e m a

MonadPlus m => MonadPlus (IdentityT m)

Defined in Control.Monad.Trans.Identity

Methods

mzero :: IdentityT m a

mplus :: IdentityT m a -> IdentityT m a -> IdentityT m a

MonadPlus m => MonadPlus (ReaderT r m)

Defined in Control.Monad.Trans.Reader

Methods

mzero :: ReaderT r m a

mplus :: ReaderT r m a -> ReaderT r m a -> ReaderT r m a

MonadPlus m => MonadPlus (SelectT r m)

Defined in Control.Monad.Trans.Select

Methods

mzero :: SelectT r m a

mplus :: SelectT r m a -> SelectT r m a -> SelectT r m a

MonadPlus m => MonadPlus (StateT s m)

Defined in Control.Monad.Trans.State.Lazy

Methods

mzero :: StateT s m a

mplus :: StateT s m a -> StateT s m a -> StateT s m a

MonadPlus m => MonadPlus (StateT s m)

Defined in Control.Monad.Trans.State.Strict

Methods

mzero :: StateT s m a

mplus :: StateT s m a -> StateT s m a -> StateT s m a

(Functor m, MonadPlus m) => MonadPlus (WriterT w m)

Defined in Control.Monad.Trans.Writer.CPS

Methods

mzero :: WriterT w m a

mplus :: WriterT w m a -> WriterT w m a -> WriterT w m a

(Monoid w, MonadPlus m) => MonadPlus (WriterT w m)

Defined in Control.Monad.Trans.Writer.Lazy

Methods

mzero :: WriterT w m a

mplus :: WriterT w m a -> WriterT w m a -> WriterT w m a

(Monoid w, MonadPlus m) => MonadPlus (WriterT w m)

Defined in Control.Monad.Trans.Writer.Strict

Methods

mzero :: WriterT w m a

mplus :: WriterT w m a -> WriterT w m a -> WriterT w m a

MonadPlus m => MonadPlus (Reverse m)

Derived instance.

Defined in Data.Functor.Reverse

Methods

mzero :: Reverse m a

mplus :: Reverse m a -> Reverse m a -> Reverse m a

(MonadPlus f, MonadPlus g) => MonadPlus (Product f g)

Since: base-4.9.0.0

Defined in Data.Functor.Product

Methods

mzero :: Product f g a

mplus :: Product f g a -> Product f g a -> Product f g a

MonadPlus m => MonadPlus (InterpretC s sig m)

Defined in Control.Carrier.Interpret

Methods

mzero :: InterpretC s sig m a

mplus :: InterpretC s sig m a -> InterpretC s sig m a -> InterpretC s sig m a

(MonadPlus f, MonadPlus g) => MonadPlus (f :*: g)

@since base-4.9.0.0

Defined in GHC.Internal.Generics

Methods

mzero :: (f :*: g) a

mplus :: (f :*: g) a -> (f :*: g) a -> (f :*: g) a

MonadPlus (sub m) => MonadPlus (Labelled label sub m)

Defined in Control.Effect.Labelled

Methods

mzero :: Labelled label sub m a

mplus :: Labelled label sub m a -> Labelled label sub m a -> Labelled label sub m a

MonadPlus m => MonadPlus (UnderLabel label sub m)

Defined in Control.Effect.Labelled

Methods

mzero :: UnderLabel label sub m a

mplus :: UnderLabel label sub m a -> UnderLabel label sub m a -> UnderLabel label sub m a

MonadPlus f => MonadPlus (M1 i c f)

@since base-4.9.0.0

Defined in GHC.Internal.Generics

Methods

mzero :: M1 i c f a

mplus :: M1 i c f a -> M1 i c f a -> M1 i c f a

(Functor m, MonadPlus m) => MonadPlus (RWST r w s m)

Defined in Control.Monad.Trans.RWS.CPS

Methods

mzero :: RWST r w s m a

mplus :: RWST r w s m a -> RWST r w s m a -> RWST r w s m a

(Monoid w, MonadPlus m) => MonadPlus (RWST r w s m)

Defined in Control.Monad.Trans.RWS.Lazy

Methods

mzero :: RWST r w s m a

mplus :: RWST r w s m a -> RWST r w s m a -> RWST r w s m a

(Monoid w, MonadPlus m) => MonadPlus (RWST r w s m)

Defined in Control.Monad.Trans.RWS.Strict

Methods

mzero :: RWST r w s m a

mplus :: RWST r w s m a -> RWST r w s m a -> RWST r w s m a

guard :: Alternative f => Bool -> f ()

Conditional failure of Alternative computations. Defined by

guard True  = pure ()
guard False = empty

Examples

Common uses of guard include conditionally signalling an error in an error monad and conditionally rejecting the current choice in an Alternative-based parser.

As an example of signalling an error in the error monad Maybe, consider a safe division function safeDiv x y that returns Nothing when the denominator y is zero and Just (x `div` y) otherwise. For example:

>>> safeDiv 4 0
Nothing

>>> safeDiv 4 2
Just 2

A definition of safeDiv using guards, but not guard:

safeDiv :: Int -> Int -> Maybe Int
safeDiv x y | y /= 0    = Just (x `div` y)
            | otherwise = Nothing

A definition of safeDiv using guard and Monad do-notation:

safeDiv :: Int -> Int -> Maybe Int
safeDiv x y = do
  guard (y /= 0)
  return (x `div` y)

optional :: Alternative f => f a -> f (Maybe a)

One or none.

It is useful for modelling any computation that is allowed to fail.

Examples

Using the Alternative instance of Control.Monad.Except, the following functions:

>>> import Control.Monad.Except

>>> canFail = throwError "it failed" :: Except String Int
>>> final = return 42                :: Except String Int

Can be combined by allowing the first function to fail:

>>> runExcept $ canFail *> final
Left "it failed"

>>> runExcept $ optional canFail *> final
Right 42

run :: Identity a -> a

Run an action exhausted of effects to produce its final result value.

Since: 1.0.0.0