Safe Haskell | Safe-Infered |
---|

The data definition of a TardisT as well as its primitive operations, and straightforward combinators based on the primitives.

See Control.Monad.Tardis for the general explanation of what a Tardis is and how to use it.

- data TardisT bw fw m a
- runTardisT :: TardisT bw fw m a -> (bw, fw) -> m (a, (bw, fw))
- evalTardisT :: Monad m => TardisT bw fw m a -> (bw, fw) -> m a
- execTardisT :: Monad m => TardisT bw fw m a -> (bw, fw) -> m (bw, fw)
- type Tardis bw fw = TardisT bw fw Identity
- runTardis :: Tardis bw fw a -> (bw, fw) -> (a, (bw, fw))
- evalTardis :: Tardis bw fw a -> (bw, fw) -> a
- execTardis :: Tardis bw fw a -> (bw, fw) -> (bw, fw)
- tardis :: Monad m => ((bw, fw) -> (a, (bw, fw))) -> TardisT bw fw m a
- getPast :: Monad m => TardisT bw fw m fw
- getFuture :: Monad m => TardisT bw fw m bw
- sendPast :: Monad m => bw -> TardisT bw fw m ()
- sendFuture :: Monad m => fw -> TardisT bw fw m ()
- modifyForwards :: MonadFix m => (fw -> fw) -> TardisT bw fw m ()
- modifyBackwards :: MonadFix m => (bw -> bw) -> TardisT bw fw m ()
- getsPast :: MonadFix m => (fw -> a) -> TardisT bw fw m a
- getsFuture :: MonadFix m => (bw -> a) -> TardisT bw fw m a
- noState :: (a, b)

# The Tardis monad transformer

A TardisT is parameterized by two state streams: a 'backwards-traveling' state and a 'forwards-traveling' state. This library consistently puts the backwards-traveling state first whenever the two are seen together.

MonadFix m => MonadTardis bw fw (TardisT bw fw m) | |

MonadFix m => MonadState fw (TardisT bw fw m) | |

MonadTrans (TardisT bw fw) | |

MonadFix m => Monad (TardisT bw fw m) | |

MonadFix m => Functor (TardisT bw fw m) | |

MonadFix m => MonadFix (TardisT bw fw m) | |

MonadFix m => Applicative (TardisT bw fw m) |

runTardisT :: TardisT bw fw m a -> (bw, fw) -> m (a, (bw, fw))Source

A TardisT is merely an effectful state transformation

evalTardisT :: Monad m => TardisT bw fw m a -> (bw, fw) -> m aSource

Run a Tardis, and discard the final state, observing only the resultant value.

execTardisT :: Monad m => TardisT bw fw m a -> (bw, fw) -> m (bw, fw)Source

Run a Tardis, and discard the resultant value,
observing only the final state (of both streams).
Note that the `final`

state of the backwards-traveling state
is the state it reaches by traveling from the `bottom`

of your code to the `top`

.

# The Tardis monad

type Tardis bw fw = TardisT bw fw IdentitySource

Using a Tardis with no monad underneath will prove to be most common use case. Practical uses of a TardisT require that the underlying monad be an instance of MonadFix, but note that the IO instance of MonadFix is almost certainly unsuitable for use with Tardis code.

runTardis :: Tardis bw fw a -> (bw, fw) -> (a, (bw, fw))Source

A Tardis is merely a pure state transformation.

evalTardis :: Tardis bw fw a -> (bw, fw) -> aSource

Run a Tardis, and discard the final state, observing only the resultant value.

execTardis :: Tardis bw fw a -> (bw, fw) -> (bw, fw)Source

Run a Tardis, and discard the resultant value, observing only the final state (of both streams).

# Primitive Tardis operations

tardis :: Monad m => ((bw, fw) -> (a, (bw, fw))) -> TardisT bw fw m aSource

From a stateful computation, construct a Tardis. This is the pure parallel to the constructor TardisT, and is polymorphic in the transformed monad.

getPast :: Monad m => TardisT bw fw m fwSource

Retrieve the current value of the 'forwards-traveling' state,
which therefore came forwards from the past.
You can think of forwards-traveling state as traveling
`downwards`

through your code.

getFuture :: Monad m => TardisT bw fw m bwSource

Retrieve the current value of the 'backwards-traveling' state,
which therefore came backwards from the future.
You can think of backwards-traveling state as traveling
`upwards`

through your code.

sendFuture :: Monad m => fw -> TardisT bw fw m ()Source

Set the current value of the 'forwards-traveling' state,
which will therefore be sent forwards to the future.
This value can be retrieved by calls to getPast
located `below`

the current location,
unless it is overwritten by an intervening sendFuture.

# Composite Tardis operations

modifyForwards :: MonadFix m => (fw -> fw) -> TardisT bw fw m ()Source

Modify the forwards-traveling state as it passes through from past to future.

modifyBackwards :: MonadFix m => (bw -> bw) -> TardisT bw fw m ()Source

Modify the backwards-traveling state as it passes through from future to past.

getsPast :: MonadFix m => (fw -> a) -> TardisT bw fw m aSource

Retrieve a specific view of the forwards-traveling state.

getsFuture :: MonadFix m => (bw -> a) -> TardisT bw fw m aSource

Retrieve a specific view of the backwards-traveling state.