Safe Haskell | None |
---|---|

Language | Haskell98 |

This is the scheduler described in the paper "A Monad for
Deterministic Parallelism". It is based on a lazy `Trace`

data
structure that separates the scheduler from the `Par`

monad
method implementations.

- data Par a
- runPar :: Par a -> a
- runParIO :: Par a -> IO a
- fork :: Par () -> Par ()
- data IVar a
- new :: Par (IVar a)
- newFull :: NFData a => a -> Par (IVar a)
- newFull_ :: a -> Par (IVar a)
- get :: IVar a -> Par a
- put :: NFData a => IVar a -> a -> Par ()
- put_ :: IVar a -> a -> Par ()
- spawn :: NFData a => Par a -> Par (IVar a)
- spawn_ :: Par a -> Par (IVar a)
- spawnP :: NFData a => a -> Par (IVar a)

# Documentation

Run a parallel, deterministic computation and return its result.

Note: you must NOT return an IVar in the output of the parallel
computation. This is unfortunately not enforced, as it is with
`runST`

or with newer libraries that export a Par monad, such as
`lvish`

.

A version that avoids an internal `unsafePerformIO`

for calling
contexts that are already in the `IO`

monad.

Returning any value containing IVar is still disallowed, as it can compromise type safety.

Read the value in an `IVar`

. The `get`

operation can only return when the
value has been written by a prior or parallel `put`

to the same
`IVar`

.

put :: NFData a => IVar a -> a -> Par () #

Put a value into an `IVar`

. Multiple `put`

s to the same `IVar`

are not allowed, and result in a runtime error.

`put`

fully evaluates its argument, which therefore must be an
instance of `NFData`

. The idea is that this forces the work to
happen when we expect it, rather than being passed to the consumer
of the `IVar`

and performed later, which often results in less
parallelism than expected.

Sometimes partial strictness is more appropriate: see `put_`

.