Safe Haskell | None |
---|

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

runParIO :: Par a -> IO aSource

A version that avoids an internal `unsafePerformIO`

for calling
contexts that are already in the `IO`

monad.

read the value in a `IVar`

. The `get`

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 ()Source

put a value into a `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_`

.