Copyright | (c) Samuel Schlesinger 2020 |
---|---|
License | MIT |
Maintainer | sgschlesinger@gmail.com |
Stability | experimental |
Portability | POSIX, Windows |
Safe Haskell | Safe-Inferred |
Language | Haskell2010 |
Synopsis
- data CommanderT state f a
- = Action (state -> f (CommanderT state f a, state))
- | Defeat
- | Victory a
- runCommanderT :: Monad m => CommanderT state m a -> state -> m (Maybe a)
- hoistToFunctor :: Functor g => (forall a. f a -> g a) -> CommanderT state f a -> CommanderT state g a
- hoistFromFunctor :: Functor f => (forall a. f a -> g a) -> CommanderT state f a -> CommanderT state g a
The CommanderT Monad
The CommanderT
monad is stateful and has the ability to backtrack.
data CommanderT state f a Source #
A CommanderT
action is a metaphor for a military commander. At each
step, we have a new Action
to take, or we could have experienced
Defeat
, or we can see Victory
. While a real life commander
worries about moving his troops around in order to achieve a victory in
battle, a CommanderT
worries about iteratively transforming a state
to find some value.
In more practical terms, a term of type CommanderT
can be thought of
as a backtracking, stateful computation which can either result in
a result being produced, or nothing being produced. It is a
Monad
for any base Functor
you want to use as the effect inside of
the stateful computation, similarly to the free monad.
Action (state -> f (CommanderT state f a, state)) | |
Defeat | |
Victory a |
Instances
runCommanderT :: Monad m => CommanderT state m a -> state -> m (Maybe a) Source #
We can run a CommanderT
on some state and see if it has
a successful campaign.
hoistToFunctor :: Functor g => (forall a. f a -> g a) -> CommanderT state f a -> CommanderT state g a Source #
We can go from a non-Functor
to a Functor
inside of a CommanderT
action. This does the transformation "top to bottom", as opposed to
hoistFromFunctor
, which does it "bottom to top". If your natural
transformation is lessening, i.e. it trims branching structure, then you
probably want to use this function.
hoistFromFunctor :: Functor f => (forall a. f a -> g a) -> CommanderT state f a -> CommanderT state g a Source #
We can go from a Functor
to a non-Functor
inside of a CommanderT
action. This does the transformation "bottom to top", as opposed to
hoistToFunctor
, which does it "top to bottom". If your natural
transformation is increasing, i.e. it adds branching structure, then you
probably want to use this function.