Control.Monad.Trans.Recorder

Results of the RecorderT computations are recorded in a running journal using the record combinator. A computation can be paused at any point using the pause primitive returning a Recording that can be used to restart the computation from the same point later. When the recording is replayed, the record combinator returns the previously recorded result of the computation from the journal instead of actually running the computation again.

import Control.Monad.IO.Class (liftIO)
import Control.Monad.Trans.Recorder (runRecorderT, record, pause, Paused(..), blank)
import Control.Exception (catch)

main = do
    recording <- (runRecorderT blank computation >> return blank) `catch` \(Paused r) -> return r
    putStrLn "Computation paused, resuming again with recorded logs"
    runRecorderT recording computation
    return ()

    where

    computation = do
         x1 <- record $ liftIO $ return 1
         record $ liftIO $ print ("A", x1)
         x2 <- record $ liftIO $ return 2
         record pause
         record $ liftIO $ print ("B", x1, x2)

Note that only those computations are replayed that are explicitly recorded. Unrecorded impure computations can result in the program misbehaving if it takes a different path upon replay. Instead of recording selectively you can enforce recording of each and every operation using the AutoRecorder module.

Documentation

data RecorderT m a

The monad record and play transformer. Maintains a running log of the results of monadic actions.

Instances

MonadTrans RecorderT

Methods

lift :: Monad m => m a -> RecorderT m a

MonadTransControl RecorderT

Associated Types

type StT (RecorderT :: (* -> *) -> * -> *) a :: *

Methods

liftWith :: Monad m => (Run RecorderT -> m a) -> RecorderT m a

restoreT :: Monad m => m (StT RecorderT a) -> RecorderT m a

MonadBase b m => MonadBase b (RecorderT m)

Methods

liftBase :: b α -> RecorderT m α

MonadBaseControl b m => MonadBaseControl b (RecorderT m)

Associated Types

type StM (RecorderT m :: * -> *) a :: *

Methods

liftBaseWith :: (RunInBase (RecorderT m) b -> b a) -> RecorderT m a

restoreM :: StM (RecorderT m) a -> RecorderT m a

Monad m => Monad (RecorderT m)

Methods

(>>=) :: RecorderT m a -> (a -> RecorderT m b) -> RecorderT m b

(>>) :: RecorderT m a -> RecorderT m b -> RecorderT m b

return :: a -> RecorderT m a

fail :: String -> RecorderT m a

Functor m => Functor (RecorderT m)

Methods

fmap :: (a -> b) -> RecorderT m a -> RecorderT m b

(<$) :: a -> RecorderT m b -> RecorderT m a

Monad m => Applicative (RecorderT m)

Methods

pure :: a -> RecorderT m a

(<*>) :: RecorderT m (a -> b) -> RecorderT m a -> RecorderT m b

(*>) :: RecorderT m a -> RecorderT m b -> RecorderT m b

(<*) :: RecorderT m a -> RecorderT m b -> RecorderT m a

MonadIO m => MonadIO (RecorderT m)

Methods

liftIO :: IO a -> RecorderT m a

MonadThrow m => MonadThrow (RecorderT m)

Methods

throwM :: Exception e => e -> RecorderT m a

MonadCatch m => MonadCatch (RecorderT m)

Methods

catch :: Exception e => RecorderT m a -> (e -> RecorderT m a) -> RecorderT m a

MonadMask m => MonadMask (RecorderT m)

Methods

mask :: ((forall a. RecorderT m a -> RecorderT m a) -> RecorderT m b) -> RecorderT m b

uninterruptibleMask :: ((forall a. RecorderT m a -> RecorderT m a) -> RecorderT m b) -> RecorderT m b

Monad m => MonadRecorder (RecorderT m)

Methods

getJournal :: RecorderT m Journal

putJournal :: Journal -> RecorderT m ()

play :: Recording -> RecorderT m ()

type StT RecorderT a

type StT RecorderT a = StT (StateT Journal) a

type StM (RecorderT m) a

type StM (RecorderT m) a = ComposeSt RecorderT m a

data Journal

The internal log state kept when recording or replaying.

Instances

Read Journal

Methods

readsPrec :: Int -> ReadS Journal

readList :: ReadS [Journal]

readPrec :: ReadPrec Journal

readListPrec :: ReadPrec [Journal]

Show Journal

Methods

showsPrec :: Int -> Journal -> ShowS

show :: Journal -> String

showList :: [Journal] -> ShowS

class Monad m => MonadRecorder m where

A monad with the ability to record and play the results of monadic actions.

Minimal complete definition

getJournal, putJournal, play

Methods

getJournal :: m Journal

Retrieve the record and replay journal. Used by the implementation of record and play.

putJournal :: Journal -> m ()

Replace the record and replay journal. Used by the implementation of record and play.

play :: Recording -> m ()

Play a previously recorded journal. This function can be used to set a replay journal at any point.

Instances

Monad m => MonadRecorder (RecorderT m)

Methods

getJournal :: RecorderT m Journal

putJournal :: Journal -> RecorderT m ()

play :: Recording -> RecorderT m ()

runRecorderT :: Monad m => Recording -> RecorderT m a -> m a

Run a fresh RecorderT computation using blank recording or resume a paused computation using captured recording. The captured state of the action is restored and the action resumes right after the pause call that paused the action.

class Recordable a where

A type that can be recorded.

Minimal complete definition

toJournal, fromJournal

Methods

toJournal :: a -> String

fromJournal :: String -> a

Instances

(Show a, Read a) => Recordable a

Methods

toJournal :: a -> String

fromJournal :: String -> a

data Recording

The log entries returned when an action is suspended.

Instances

Eq Recording

Methods

(==) :: Recording -> Recording -> Bool

(/=) :: Recording -> Recording -> Bool

Show Recording

Methods

showsPrec :: Int -> Recording -> ShowS

show :: Recording -> String

showList :: [Recording] -> ShowS

blank :: Recording

An empty Recording.

record :: (Recordable a, Read a, Show a, MonadRecorder m) => m a -> m a

Add the result of an action to the recording journal. During replay, if the result of an action is available in the replay journal then get it from the journal instead of running the action.

data Paused

Exception thrown when pause is called.

Constructors

Paused Recording

Instances

Show Paused

Methods

showsPrec :: Int -> Paused -> ShowS

show :: Paused -> String

showList :: [Paused] -> ShowS

Exception Paused

Methods

toException :: Paused -> SomeException

fromException :: SomeException -> Maybe Paused

displayException :: Paused -> String

pause :: (MonadRecorder m, MonadThrow m) => m ()

Pause a computation before completion for resuming later. Throws Paused exception which carries the current recorded logs.