A task that is currently or was part of a schedule.

t is the type of input parameter for each task, i.e. the task contents.

The current status of a task as returned by taskStatus.

The state of all scheduled pending tasks.

t is the type of task-params.

Check the schedule that its internal invariants all hold.

You must run this on every instance obtained not via the API functions here. For example, you must run this on instances obtained via deserialisation, which in general cannot check the complex invariants maintained by the API functions. Also, for all Tasks you obtain via a similarly non-standard method, including by deserialisation of a parent data structure, you must run checkTask schedule task.

Nothing means the check passed; Just errmsg gives a failure reason.

Note: this does not guard against all malicious behaviour, but it does guard against violation (either malicious or accidental) of the runtime invariants assumed by this data structure.

Check that an existing task is consistent with the current state of the structure, i.e. it is not a task that could be generated in the future.

Get the current tick, whose tasks have not all run yet.

From the perspective of the pure computation that is running this schedule, you should treat this as the current "logical time", even if an impure clock is telling you that the "environment time" is in the future.

Get the previous tick, whose tasks have all already run.

Get the number of ticks until the next scheduled task.

This may be used by an impure runtime environment to set an actual timeout; see Control.Clock for a starting point.

Schedule a task to run after a given number of ticks.

This is relative to tickNow; a 0 delta schedules the task to be run at the end of the current tick, i.e. as soon as possible but not immediately.

If your task params needs to refer to the task itself, you may achieve this by using the standard Haskell "tying the knot" technique, e.g.:

>>> data TPar = TPar !(Task TPar) deriving (Show, Eq)
>>> s = newSchedule
>>> let (t, s') = after 1 (TPar t) s -- @t@ on LHS & RHS, tying the knot
>>> t
Task (Delete 1 (RHandle {getHandle = 0}))
>>> taskStatus t s
TaskNotPending
>>> taskStatus t s'
TaskPending 1 (TPar (Task (Delete 1 (RHandle {getHandle = 0}))))
>>> taskStatus t s' == TaskPending 1 (TPar t)
True

Cancel a task. Result is Nothing if task was not already pending.

Cancel a task, discarding the result.

Reschedule a pending task to instead run after a given number of ticks.

If the task was not already pending, do nothing. If you need to reschedule a task unconditionally even if it was already cancelled or run, use both cancel_ and after in combination.

Run an action, accumulating its monoid result until it returns Nothing.

TODO: export to upstream extra

Convert a modification function into a state transition function.

Convert a getter function into a state transition function.

Convert a state transition function into a state transition arrow.

Convert a modification arrow into a state transition arrow.

Convert a getter function into a state transition arrow.