A way to produce Future objects and to complete them later with a value or error.

Most of the time, the simplest way to create a future is to just use one of the Future constructors to capture the result of a single asynchronous computation:

new Future(() { doSomething(); return result; });

or, if the future represents the result of a sequence of asynchronous computations, they can be chained using Future.then or similar functions on Future:

Future doStuff(){
  return someAsyncOperation().then((result) {
    return someOtherAsyncOperation(result);

If you do need to create a Future from scratch — for example, when you're converting a callback-based API into a Future-based one — you can use a Completer as follows:

class AsyncOperation {
  Completer _completer = new Completer();

  Future<T> doOperation() {
    return _completer.future; // Send future object back to client.

  // Something calls this when the value is ready.
  void _finishOperation(T result) {

  // If something goes wrong, call this.
  void _errorHappened(error) {


future Future<T>

The future that will contain the result provided to this completer.

isCompleted bool

Whether the future has been completed.



Creates a new completer.


Completes the future synchronously.


complete([value]) → void

Completes future with the supplied values.

completeError(Object error, [StackTrace stackTrace]) → void

Complete future with an error.