Control.Effects.List

Add non-determinism to your monad. Uses the ListT transformer under the hood.

Documentation

data NonDeterminism

Instances

Effect NonDeterminism

Associated Types

data EffMethods NonDeterminism (m :: * -> *) :: *

type CanLift NonDeterminism (t :: (* -> *) -> * -> *) :: Constraint

Methods

liftThrough :: (CanLift NonDeterminism t, Monad m, Monad (t m)) => EffMethods NonDeterminism m -> EffMethods NonDeterminism (t m)

mergeContext :: Monad m => m (EffMethods NonDeterminism m) -> EffMethods NonDeterminism m

Monad m => MonadEffect NonDeterminism (ListT m)

Methods

effect :: EffMethods NonDeterminism (ListT m)

data EffMethods NonDeterminism

data EffMethods NonDeterminism = NonDeterminismMethods {

• _choose :: forall a. [a] -> m a

}

type CanLift NonDeterminism t

type CanLift NonDeterminism t = MonadTrans t

choose :: forall a m. MonadEffect NonDeterminism m => [a] -> m a

Get a value from the list. The choice of which value to take is non-deterministic in a sense that the rest of the computation will be ran once for each of them.

deadEnd :: MonadEffect NonDeterminism m => m a

Signals that this branch of execution failed to produce a result.

evaluateToList :: Monad m => ListT m a -> m [a]

Execute all the effects and collect the result in a list. Note that this forces all the results, no matter which elements of the result list you end up actually using. For lazyer behavior use the other handlers.

traverseAllResults :: Monad m => (a -> m ()) -> ListT m a -> m ()

Given a function, apply it to all the results.

foldAllResults :: Monad m => (r -> a -> m r) -> r -> ListT m a -> m r

Given a folding function, fold over every result. If you want to terminate eary, use the foldWithEarlyTermination instead.

foldWithEarlyTermination :: Monad m => (r -> a -> m (Maybe r)) -> r -> ListT m a -> m r

Same as foldAllResults but the folding function has the ability to terminate early by returning Nothing.

evaluateNResults :: Monad m => Int -> ListT m a -> m [a]

Executes only the effects needed to produce the first n results.

evaluateOneResult :: Monad m => ListT m a -> m (Maybe a)

Executes only the effects needed to produce a single result.

evaluateAll :: Monad m => ListT m a -> m ()

Execute all the effects but discard their results.

module ListT