Stability | experimental |
---|---|

Maintainer | conal@conal.net |

A *future value* is a value that will become knowable only later. This
module gives a way to manipulate them functionally. For instance,
`a+b`

becomes knowable when the later of `a`

and `b`

becomes knowable.
See http://en.wikipedia.org/wiki/Futures_and_promises.

Primitive futures can be things like /the value of the next key you
press*, or *the value of LambdaPix stock at noon next Monday/.

Composition is via standard type classes: `Functor`

, `Applicative`

,
`Monad`

, and `Monoid`

. Some comments on the `Future`

instances of
these classes:

- Monoid:
`mempty`

is a future that never becomes knowable.`a`

is whichever of`mappend`

b`a`

and`b`

is knowable first. -
`Functor`

: apply a function to a future. The result is knowable when the given future is knowable. -
`Applicative`

:`pure`

gives value knowable since the beginning of time. '(<*>)' applies a future function to a future argument. Result available when*both*are available, i.e., it becomes knowable when the later of the two futures becomes knowable. -
`Monad`

:`return`

is the same as`pure`

(as always).`(>>=)`

cascades futures.`join`

resolves a future future into a future.

The current implementation is nondeterministic in `mappend`

for futures
that become knowable at the same time or nearly the same time. I
want to make a deterministic implementation.

See Data.SFuture for a simple denotational semantics of futures. The
current implementation *does not* quite implement this target semantics
for `mappend`

when futures are available simultaneously or nearly
simultaneously. I'm still noodling how to implement that semantics.