Future<T> class

An object representing a delayed computation.

A Future is used to represent a potential value, or error, that will be available at some time in the future. Receivers of a Future can register callbacks that handle the value or error once it is available. For example:

Future<int> future = getFuture();
future.then((value) => handleValue(value))
      .catchError((error) => handleError(error));

A Future can be completed in two ways: with a value ("the future succeeds") or with an error ("the future fails"). Users can install callbacks for each case.

In some cases we say that a future is completed with another future. This is a short way of stating that the future is completed in the same way, with the same value or error, as the other future once that completes. Whenever a function in the core library may complete a future (for example Completer.complete or new Future.value), then it also accepts another future and does this work for the developer.

The result of registering a pair of callbacks is a new Future (the "successor") which in turn is completed with the result of invoking the corresponding callback. The successor is completed with an error if the invoked callback throws. For example:

Future<int> successor = future.then((int value) {
    // Invoked when the future is completed with a value.
    return 42;  // The successor is completed with the value 42.
  onError: (e) {
    // Invoked when the future is completed with an error.
    if (canHandle(e)) {
      return 499;  // The successor is completed with the value 499.
    } else {
      throw e;  // The successor is completed with the error e.

If a future does not have a successor when it completes with an error, it forwards the error message to the global error-handler. This behavior makes sure that no error is silently dropped. However, it also means that error handlers should be installed early, so that they are present as soon as a future is completed with an error. The following example demonstrates this potential bug:

var future = getFuture();
new Timer(new Duration(milliseconds: 5), () {
  // The error-handler is not attached until 5 ms after the future has
  // been received. If the future fails before that, the error is
  // forwarded to the global error-handler, even though there is code
  // (just below) to eventually handle the error.
  future.then((value) { useValue(value); },
              onError: (e) { handleError(e); });

When registering callbacks, it's often more readable to register the two callbacks separately, by first using then with one argument (the value handler) and using a second catchError for handling errors. Each of these will forward the result that they don't handle to their successors, and together they handle both value and error result. It also has the additional benefit of the catchError handling errors in the then value callback too. Using sequential handlers instead of parallel ones often leads to code that is easier to reason about. It also makes asynchronous code very similar to synchronous code:

// Synchronous code.
try {
  int value = foo();
  return bar(value);
} catch (e) {
  return 499;

Equivalent asynchronous code, based on futures:

Future<int> future = new Future(foo);  // Result of foo() as a future.
future.then((int value) => bar(value))
      .catchError((e) => 499);

Similar to the synchronous code, the error handler (registered with catchError) is handling any errors thrown by either foo or bar. If the error-handler had been registered as the onError parameter of the then call, it would not catch errors from the bar call.

Futures can have more than one callback-pair registered. Each successor is treated independently and is handled as if it was the only successor.

A future may also fail to ever complete. In that case, no callbacks are called.


Future(FutureOr<T> computation())
Creates a future containing the result of calling computation asynchronously with Timer.run. [...]
Future.delayed(Duration duration, [ FutureOr<T> computation() ])
Creates a future that runs its computation after a delay. [...]
Future.error(Object error, [ StackTrace stackTrace ])
Creates a future that completes with an error. [...]
Future.microtask(FutureOr<T> computation())
Creates a future containing the result of calling computation asynchronously with scheduleMicrotask. [...]
Future.sync(FutureOr<T> computation())
Returns a future containing the result of immediately calling computation. [...]
Future.value([FutureOr<T> value ])
Creates a future completed with value. [...]


hashCode int
The hash code for this object. [...]
read-only, inherited
runtimeType Type
A representation of the runtime type of the object.
read-only, inherited


asStream() Stream<T>
Creates a Stream containing the result of this future. [...]
catchError(Function onError, { bool test(Object error) }) Future<T>
Handles errors emitted by this Future. [...]
then<R>(FutureOr<R> onValue(T value), { Function onError }) Future<R>
Register callbacks to be called when this future completes. [...]
timeout(Duration timeLimit, { FutureOr<T> onTimeout() }) Future<T>
Time-out the future computation after timeLimit has passed. [...]
whenComplete(FutureOr action()) Future<T>
Registers a function to be called when this future completes. [...]
noSuchMethod(Invocation invocation) → dynamic
Invoked when a non-existent method or property is accessed. [...]
toString() String
Returns a string representation of this object.


operator ==(dynamic other) bool
The equality operator. [...]

Static Methods

any<T>(Iterable<Future<T>> futures) Future<T>
Returns the result of the first future in futures to complete. [...]
doWhile(FutureOr<bool> action()) Future
Performs an operation repeatedly until it returns false. [...]
forEach<T>(Iterable<T> elements, FutureOr action(T element)) Future
Performs an action for each element of the iterable, in turn. [...]
wait<T>(Iterable<Future<T>> futures, { bool eagerError: false, void cleanUp(T successValue) }) Future<List<T>>
Waits for multiple futures to complete and collects their results. [...]