Future is a trampolined computation producing an A that may include asynchronous steps. Like Trampoline, arbitrary monadic expressions involving map and flatMap are guaranteed to use constant stack space. But in addition, one may construct a Future from an asynchronous computation, represented as a function, listen: (A => Unit) => Unit, which registers a callback that will be invoked when the result becomes available. This makes Future useful as a concurrency primitive and as a control structure for wrapping callback-based APIs with a more straightforward, monadic API.

Unlike the Future implementation in scala 2.10, map and flatMap do NOT spawn new tasks and do not require an implicit ExecutionContext. Instead, map and flatMap merely add to the current (trampolined) continuation that will be run by the 'current' thread, unless explicitly forked via Future.fork or Future.apply. This means that Future achieves much better thread reuse than the 2.10 implementation and avoids needless thread pool submit cycles.

Future also differs from the scala 2.10 Future type in that it does not necessarily represent a _running_ computation. Instead, we reintroduce nondeterminism _explicitly_ using the functions of the scalaz.Nondeterminism interface. This simplifies our implementation and makes code easier to reason about, since the order of effects and the points of nondeterminism are made fully explicit and do not depend on Scala's evaluation order.

IMPORTANT NOTE: Future does not include any error handling and should generally only be used as a building block by library writers who want to build on Future's capabilities but wish to design their own error handling strategy. See scalaz.concurrent.Task for a type that extends Future with proper error handling -- it is merely a wrapper for Future[Throwable \/ A] with a number of additional convenience functions.