Safe Haskell | Safe-Inferred |
---|

This module provides *step computations*. These are computations
that can be run, stopped, resumed, parallelized, and/or bounded in
runtime.

- data StepComp a
- tick :: StepComp ()
- untick :: StepComp a -> StepComp a
- forward :: Int -> StepComp a -> StepComp a
- is_done :: StepComp a -> Bool
- get_result :: StepComp a -> Maybe a
- subtask :: Int -> StepComp a -> StepComp (StepComp a)
- speedup :: Int -> StepComp a -> StepComp a
- parallel :: StepComp a -> StepComp b -> StepComp (Either (a, StepComp b) (StepComp a, b))
- with_counter :: StepComp a -> StepComp (a, Int)
- run :: StepComp a -> a
- run_with_steps :: StepComp a -> (a, Int)
- run_bounded :: Int -> StepComp a -> Maybe a
- diverge :: StepComp a
- parallel_first :: StepComp a -> StepComp a -> StepComp a
- parallel_maybe :: StepComp (Maybe a) -> StepComp (Maybe b) -> StepComp (Maybe (a, b))
- parallel_list_maybe :: [StepComp (Maybe a)] -> StepComp (Maybe [a])

# A monad for step computations

A step computation can be run for a specified number of steps, stopped, continued, and interleaved. Such a computation produces "ticks" at user-defined intervals, which must be consumed by the environment for the computation to continue.

# Basic operations

forward :: Int -> StepComp a -> StepComp aSource

Fast-forward a computation by *n* steps. This is essentially
equivalent to doing *n* `untick`

operations.

get_result :: StepComp a -> Maybe aSource

Retrieve the result of a completed step computation (or `Nothing`

if it is incomplete).

subtask :: Int -> StepComp a -> StepComp (StepComp a)Source

Run a subsidiary computation for up to *n* steps, translated into
an equal number of steps of the parent computation.

speedup :: Int -> StepComp a -> StepComp aSource

Run a subtask, speeding it up by a factor of *n* ≥ 1. Every 1 tick of
the calling task corresponds to up to *n* ticks of the subtask.

parallel :: StepComp a -> StepComp b -> StepComp (Either (a, StepComp b) (StepComp a, b))Source

Run two step computations in parallel, until one branch terminates. Tick allocation is associative: each tick of the parent function translates into one tick for each subcomputation. Therefore, when running, e.g., three subcomputations in parallel, they will each receive an approximately equal number of ticks.

with_counter :: StepComp a -> StepComp (a, Int)Source

Wrap a step computation to return the number of steps, in addition to the result.

## Run functions

run_with_steps :: StepComp a -> (a, Int)Source

Run a step computation until it finishes, and also return the number of steps it took.

run_bounded :: Int -> StepComp a -> Maybe aSource

Run a step computation for at most *n* steps.

# Other operations

parallel_first :: StepComp a -> StepComp a -> StepComp aSource

Run two step computations in parallel. The first one to complete becomes the result of the computation.