Data.Promise

Lazy demand-driven promises.

Documentation

data Lazy s a

A lazy, demand-driven calculation that can create and fulfill promises.

Instances

Monad (Lazy s)

Functor (Lazy s)

MonadFix (Lazy s)

Applicative (Lazy s)

PrimMonad (Lazy s)

type PrimState (Lazy s) = s

runLazy :: (forall s. Promise s a -> Lazy s b) -> a -> a

Run a lazy computation. The final answer is given in the form of a promise to be fulfilled. If the promises is unfulfilled then an user supplied default value will be returned.

runLazy_ :: (forall s. Promise s a -> Lazy s b) -> a

Run a lazy computation. The final answer is given in the form of a promise to be fulfilled. If the promises is unfulfilled then an BrokenPromise will be thrown.

runLazy_ k ≡ runLazy k (throw BrokenPromise)

runLazyIO :: (forall s. Promise s a -> Lazy s b) -> a -> IO a

runLazyIO_ :: (forall s. Promise s a -> Lazy s b) -> IO a

data Promise s a where

A lazy I-Var.

Constructors

Promise :: MVar a -> a -> Promise s a

promise :: a -> Lazy s (Promise s a)

Promise that by the end of the computation we'll provide a "real" answer, or we'll fall back and give you this answer

promise_ :: Lazy s (Promise s a)

Create an empty promise. If you observe the demanded answer of this promise then either by the end of the current lazy computation we'll provide a "real" answer, or you'll get an error.

promise_ ≡ promise (throw BrokenPromise)

(!=) :: Promise s a -> a -> Lazy s () infixl 0

Fulfill a promise. Each promise should only be fulfilled once.

>>> runLazy_ $ \p -> p != "good"
"good"

>>> runLazy_ $ \p -> do q <- promise_; p != "yay! " ++ demand q; q != "it works."
"yay! it works."

>>> runLazy_ $ \p -> return ()
*** Exception: BrokenPromise

>>> runLazy (\p -> return ()) "default"
"default"

demand :: Promise s a -> a

Demand the result of a promise.

data BrokenPromise

Thrown when the answer for an unfulfillable promise is demanded.

Constructors

BrokenPromise

Instances

Show BrokenPromise

Exception BrokenPromise