Safe Haskell  Safe 

Language  Haskell98 
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.
 newtype TardisT bw fw m a = TardisT {
 runTardisT :: (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
 mapTardisT :: (m (a, (bw, fw)) > n (b, (bw, fw))) > TardisT bw fw m a > TardisT bw fw n b
 noState :: (a, b)
The Tardis monad transformer
newtype TardisT bw fw m a Source
A TardisT is parameterized by two state streams: a 'backwardstraveling' state and a 'forwardstraveling' state. This library consistently puts the backwardstraveling state first whenever the two are seen together.
TardisT  

MonadFix m => MonadTardis bw fw (TardisT bw fw m) Source  
MFunctor (TardisT bw fw) Source  
MonadTrans (TardisT bw fw) Source  
MonadFix m => Monad (TardisT bw fw m) Source  
MonadFix m => Functor (TardisT bw fw m) Source  
MonadFix m => MonadFix (TardisT bw fw m) Source  
MonadFix m => Applicative (TardisT bw fw m) Source 
evalTardisT :: Monad m => TardisT bw fw m a > (bw, fw) > m a Source
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 backwardstraveling 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 Identity Source
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) > a Source
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 a Source
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 fw Source
Retrieve the current value of the 'forwardstraveling' state,
which therefore came forwards from the past.
You can think of forwardstraveling state as traveling
downwards
through your code.
getFuture :: Monad m => TardisT bw fw m bw Source
Retrieve the current value of the 'backwardstraveling' state,
which therefore came backwards from the future.
You can think of backwardstraveling state as traveling
upwards
through your code.
sendPast :: Monad m => bw > TardisT bw fw m () Source
Set the current value of the 'backwardstraveling' state,
which will therefore be sent backwards to the past.
This value can be retrieved by calls to "getFuture"
located above
the current location,
unless it is overwritten by an intervening "sendPast".
sendFuture :: Monad m => fw > TardisT bw fw m () Source
Set the current value of the 'forwardstraveling' 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 forwardstraveling state as it passes through from past to future.
modifyBackwards :: MonadFix m => (bw > bw) > TardisT bw fw m () Source
Modify the backwardstraveling state as it passes through from future to past.
getsPast :: MonadFix m => (fw > a) > TardisT bw fw m a Source
Retrieve a specific view of the forwardstraveling state.
getsFuture :: MonadFix m => (bw > a) > TardisT bw fw m a Source
Retrieve a specific view of the backwardstraveling state.
Other
mapTardisT :: (m (a, (bw, fw)) > n (b, (bw, fw))) > TardisT bw fw m a > TardisT bw fw n b Source
A function that operates on the internal representation of a Tardis can also be used on a Tardis.