Control.Monad.Schedule.Trans

This module supplies a general purpose monad transformer that adds a syntactical "delay", or "waiting" side effect.

Waiting action

data Wait diff a

A functor implementing a syntactical "waiting" action.

Constructors

Wait

Fields

• getDiff :: diff

  The duration to wait.

• awaited :: a

  The encapsulated value.

Instances

Eq diff => Eq1 (Wait diff)

Defined in Control.Monad.Schedule.Trans

Methods

liftEq :: (a -> b -> Bool) -> Wait diff a -> Wait diff b -> Bool

Functor (Wait diff)

Defined in Control.Monad.Schedule.Trans

Methods

fmap :: (a -> b) -> Wait diff a -> Wait diff b

(<$) :: a -> Wait diff b -> Wait diff a

Ord diff => MonadSchedule (Wait diff)

Defined in Control.Monad.Schedule.Trans

Methods

schedule :: NonEmpty (Wait diff a) -> Wait diff (NonEmpty a, [Wait diff a])

(Show diff, Show a) => Show (Wait diff a)

Defined in Control.Monad.Schedule.Trans

Methods

showsPrec :: Int -> Wait diff a -> ShowS

show :: Wait diff a -> String

showList :: [Wait diff a] -> ShowS

(Eq diff, Eq a) => Eq (Wait diff a)

Defined in Control.Monad.Schedule.Trans

Methods

(==) :: Wait diff a -> Wait diff a -> Bool

(/=) :: Wait diff a -> Wait diff a -> Bool

(Ord diff, TimeDifference diff, Monad m, MonadSchedule m) => MonadSchedule (ScheduleT diff m)

Run each action one step until it is discovered which action(s) are pure, or yield next. If there is a pure action, it is returned, otherwise all actions are shifted to the time when the earliest action yields.

Defined in Control.Monad.Schedule.Trans

Methods

schedule :: NonEmpty (ScheduleT diff m a) -> ScheduleT diff m (NonEmpty a, [ScheduleT diff m a])

compareWait :: Ord diff => Wait diff a -> Wait diff a -> Ordering

Compare by the time difference, regardless of the value.

Note that this would not give a lawful Ord instance since we do not compare the a.

ScheduleT

type ScheduleT diff = FreeT (Wait diff)

Values in ScheduleT diff m are delayed computations with side effects in m. Delays can occur between any two side effects, with lengths specified by a diff value. These delays don't have any semantics, it can be given to them with runScheduleT.

type Schedule diff = ScheduleT diff Identity

wait :: Monad m => diff -> ScheduleT diff m ()

The side effect that waits for a specified amount.

runScheduleT :: Monad m => (diff -> m ()) -> ScheduleT diff m a -> m a

Supply a semantic meaning to Wait. For every occurrence of Wait diff in the ScheduleT diff m a value, a waiting action is executed, depending on diff.

runScheduleIO :: (MonadIO m, Integral n) => ScheduleT n m a -> m a

Run a ScheduleT value in a MonadIO, interpreting the times as milliseconds.

execScheduleT :: Monad m => ScheduleT diff m a -> m (a, [diff])

Formally execute all waiting actions, returning the final value and all moments when the schedule would have waited.

isZero :: (Eq diff, TimeDifference diff) => diff -> Bool