A future is a value with an associated time of arrival. Typically,
neither the time nor the value can be known until the arrival time.

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 arrives (infinite time and
undefined value), and a mappend b is the earlier of a and b,
preferring a when simultaneous.

Functor: apply a function to a future argument. The (future)
result arrives simultaneously with the argument.

Applicative: pure gives value arriving negative infinity.
'(<*>)' applies a future function to a future argument, yielding a
future result that arrives once both function and argument have
arrived (coinciding with the later of the two times).

Monad: return is the same as pure (as usual). (>>=) 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 and is particularly useful with time
types that have rich partial information structure, such as /improving
values/.

Time used in futures. The parameter t can be any Ord type. The
added bounds represent -Infinity and +Infinity. Pure values have time
minBound (-Infinity), while never-occurring futures have time maxBound
(+Infinity).