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.