Safe Haskell | Safe-Inferred |
---|---|
Language | Haskell2010 |
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
Synopsis
- type NonDet = Empty :+: Choose
- data Choose (m :: Type -> Type) k where
- data Empty (m :: Type -> Type) k where
- oneOf :: (Foldable t, Alternative m) => t a -> m a
- foldMapA :: (Foldable t, Alternative m) => (a -> m b) -> t a -> m b
- class Applicative f => Alternative (f :: Type -> Type) where
- class Monad m => Algebra sig m | m -> sig
- type Has eff sig m = (Members eff sig, Algebra sig m)
- class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type) where
- guard :: Alternative f => Bool -> f ()
- optional :: Alternative f => f a -> f (Maybe a)
- run :: Identity a -> a
NonDet effects
data Choose (m :: Type -> Type) k where Source #
Since: 1.0.0.0
Instances
Algebra Choose NonEmpty Source # | |
Algebra NonDet List Source # | |
Algebra sig m => Algebra (Choose :+: sig) (ChooseC m) Source # | |
Algebra sig m => Algebra (Cull :+: (NonDet :+: sig)) (CullC m) Source # | |
Algebra sig m => Algebra (Cut :+: (NonDet :+: sig)) (CutC m) Source # | |
Algebra sig m => Algebra (NonDet :+: sig) (NonDetC m) Source # | |
data Empty (m :: Type -> Type) k where Source #
Since: 1.0.0.0
Instances
Algebra Empty Maybe Source # | |
Algebra NonDet List Source # | |
Algebra sig m => Algebra (Cull :+: (NonDet :+: sig)) (CullC m) Source # | |
Algebra sig m => Algebra (Cut :+: (NonDet :+: sig)) (CutC m) Source # | |
Algebra sig m => Algebra (Empty :+: sig) (EmptyC m) Source # | |
Algebra sig m => Algebra (Empty :+: sig) (EmptyC m) Source # | |
Algebra sig m => Algebra (Empty :+: sig) (MaybeT m) Source # | |
Algebra sig m => Algebra (NonDet :+: sig) (NonDetC m) Source # | |
oneOf :: (Foldable t, Alternative m) => t a -> m a Source #
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 Source #
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:
The identity of <|>
(<|>) :: f a -> f a -> f a infixl 3 #
An associative binary operation
One or more.
Zero or more.
Instances
class Monad m => Algebra sig m | m -> sig Source #
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
Instances
Algebra Choose NonEmpty Source # | |
Algebra Empty Maybe Source # | |
Algebra NonDet List Source # | |
Algebra sig m => Algebra sig (Choosing m) Source # | |
Algebra sig m => Algebra sig (Ap m) Source # | This instance permits effectful actions to be lifted into the mappend <$> act1 <*> (mappend <$> act2 <*> act3) is equivalent to getAp (act1 <> act2 <> act3) Since: 1.0.1.0 |
Algebra sig m => Algebra sig (Alt m) Source # | This instance permits effectful actions to be lifted into the a <|> b <|> c <|> d is equivalent to getAlt (mconcat [a, b, c, d]) Since: 1.0.1.0 |
Algebra sig m => Algebra sig (IdentityT m) Source # | |
Algebra (Lift Identity) Identity Source # | |
Algebra (Lift IO) IO Source # | |
Algebra (Error e) (Either e) Source # | |
Monad m => Algebra (Lift m) (LiftC m) Source # | |
Monoid w => Algebra (Writer w) ((,) w) Source # | |
Algebra (Reader r) ((->) r) Source # | |
Algebra sig m => Algebra (Choose :+: sig) (ChooseC m) Source # | |
Algebra sig m => Algebra (Cull :+: (NonDet :+: sig)) (CullC m) Source # | |
Algebra sig m => Algebra (Cut :+: (NonDet :+: sig)) (CutC m) Source # | |
Algebra sig m => Algebra (Empty :+: sig) (EmptyC m) Source # | |
Algebra sig m => Algebra (Empty :+: sig) (EmptyC m) Source # | |
Algebra sig m => Algebra (Empty :+: sig) (MaybeT m) Source # | |
Algebra sig m => Algebra (Fail :+: sig) (FailC m) Source # | |
Algebra sig m => Algebra (Fresh :+: sig) (FreshC m) Source # | |
Algebra sig m => Algebra (Fresh :+: sig) (FreshC m) Source # | |
Algebra sig m => Algebra (NonDet :+: sig) (NonDetC m) Source # | |
Algebra sig m => Algebra (Trace :+: sig) (TraceC m) Source # | |
(MonadIO m, Algebra sig m) => Algebra (Trace :+: sig) (TraceC m) Source # | |
Algebra sig m => Algebra (Trace :+: sig) (TraceC m) Source # | |
(Algebra sig m, Monoid w) => Algebra (Accum w :+: sig) (AccumC w m) Source # | |
(Algebra sig m, Semigroup w, MonadIO m) => Algebra (Accum w :+: sig) (AccumC w m) Source # | |
(Algebra sig m, Monoid w) => Algebra (Accum w :+: sig) (AccumC w m) Source # | |
(Algebra sig m, Monoid w) => Algebra (Accum w :+: sig) (AccumT w m) Source # | |
Algebra sig m => Algebra (Error e :+: sig) (ErrorC e m) Source # | |
Algebra sig m => Algebra (Error e :+: sig) (ErrorC e m) Source # | |
Algebra sig m => Algebra (Error e :+: sig) (ExceptT e m) Source # | |
Algebra sig m => Algebra (Reader r :+: sig) (ReaderC r m) Source # | |
Algebra sig m => Algebra (Reader r :+: sig) (ReaderT r m) Source # | |
Algebra sig m => Algebra (State s :+: sig) (StateC s m) Source # | |
(MonadIO m, Algebra sig m) => Algebra (State s :+: sig) (StateC s m) Source # | |
Algebra sig m => Algebra (State s :+: sig) (StateC s m) Source # | |
Algebra sig m => Algebra (State s :+: sig) (StateC s m) Source # | |
Algebra sig m => Algebra (State s :+: sig) (StateT s m) Source # | |
Algebra sig m => Algebra (State s :+: sig) (StateT s m) Source # | |
Algebra sig m => Algebra (Throw e :+: sig) (ThrowC e m) Source # | |
(Algebra sig m, Monoid w) => Algebra (Writer w :+: sig) (WriterC w m) Source # | |
(Monoid w, Algebra sig m) => Algebra (Writer w :+: sig) (WriterC w m) Source # | |
(Algebra sig m, Monoid w) => Algebra (Writer w :+: sig) (WriterT w m) Source # | |
(Algebra sig m, Monoid w) => Algebra (Writer w :+: sig) (WriterT w m) Source # | |
(Algebra sig m, Monoid w) => Algebra (Writer w :+: sig) (WriterT w m) Source # | |
(Reifies s (Interpreter eff m), Algebra sig m) => Algebra (eff :+: sig) (InterpretC s eff m) Source # | |
Defined in Control.Carrier.Interpret 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) Source # | |
Algebra (eff :+: sig) (sub m) => Algebra (Labelled label eff :+: sig) (Labelled label sub m) Source # | |
(Algebra sig m, Monoid w) => Algebra (Reader r :+: (Writer w :+: (State s :+: sig))) (RWST r w s m) Source # | |
(Algebra sig m, Monoid w) => Algebra (Reader r :+: (Writer w :+: (State s :+: sig))) (RWST r w s m) Source # | |
(Algebra sig m, Monoid w) => Algebra (Reader r :+: (Writer w :+: (State s :+: sig))) (RWST r w s m) Source # | |
(LabelledMember label sub sig, Algebra sig m) => Algebra (sub :+: sig) (UnderLabel label sub m) Source # | |
Defined in Control.Effect.Labelled 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) Source # |
type Has eff sig m = (Members eff sig, Algebra sig m) Source #
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:
- Due to a problem with recursive type families, this can lead to significantly slower compiles.
- 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.
Nothing
The identity of mplus
. It should also satisfy the equations
mzero >>= f = mzero v >> mzero = mzero
The default definition is
mzero = empty
An associative operation. The default definition is
mplus = (<|>
)
Instances
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 signaling an error in
an error monad and conditionally rejecting the current choice in an
Alternative
-based parser.
As an example of signaling 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
otherwise. For example:Just
(x `div`
y)
>>>
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