| Safe Haskell | Safe |
|---|---|
| Language | Haskell98 |
Quantum.Synthesis.StepComp
Description
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 a Source #
Fast-forward a computation by n steps. This is essentially
equivalent to doing n untick operations.
get_result :: StepComp a -> Maybe a Source #
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 a Source #
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.
Other operations
parallel_first :: StepComp a -> StepComp a -> StepComp a Source #
Run two step computations in parallel. The first one to complete becomes the result of the computation.