Stability  experimental 

Maintainer  conal@conal.net 
A sort of semantic prototype for functional futures, roughly as described at http://en.wikipedia.org/wiki/Futures_and_promises.
A future 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.
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: Ord
, Functor
,
Applicative
, Monad
, and Monoid
. Some comments on the Future
instances of these classes:

Ord
:a
is whichever ofmin
ba
andb
is knowable first.a
is whichever ofmax
ba
andb
is knowable last.  Monoid:
mempty
is a future that never becomes knowable.mappend
is the same asmin
. 
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 aspure
(as always).(>>=)
cascades futures.join
resolves a future future value into a future value.
Futures are parametric over time as well as value types. The time parameter can be any ordered type.
Please keep in mind that this module specifies the interface and semantics, rather than a useful implementation. See Data.Future for an implementation that nearly implements the semantics described here.
On second thought, I'm experimenting with using this module in an usable implementation of events. See Data.MEvent.
Time & futures
type Time t = Max (AddBounds t)Source
Time of some event occurrence, which can be any Ord
type. In an
actual implementation, we would not usually have access to the time
value until (slightly after) that time. Extracting the actual time
would block until the time is known. The added bounds represent
Infinity and +Infinity. Pure values have time minBound (Infinity),
while eternally unknowable values (nonoccurring events) have time
maxBound (+Infinity).
A future value of type a
with time type t
. Semantically, just a
time/value pair, but those values would not be available until
force
d, which could block.
sequenceF :: Functor f => Future t (f a) > f (Future t a)Source
Make a future container into a container of futures.
To go elsewhere
Ordered monoid under max
.
Ordered monoid under min
.