Classes

Used to keep track of observers, in order to supply the ability to remove observers from a future, if the result of a future is no longer interesting.

The following methods return a FutureObserver:

• Future<T>.whenResolved()
• Future<T>.whenFulfilled()
• Future<T>.whenRejected()

See more

public final class FutureObserver<T> : AnyFutureObserver

Container for a result that will be provided later.

Functions that promise to do work asynchronously return a Future<T>. The receipient of a future can observe it to be notified, or to queue more asynchronous work, when the operation completes.

A Future<T> is regarded as:

• resolved, when a value is set
• fulfilled, when a value is set and successful
• rejected, when a value is not set, and an error occured

The provider of a Future<T> creates a placeholder object before the actual result is available, immeadiately returning the object, providing a dynamic way of structuring complex dependencies for asynchronous work. This is common behavior in Future/Promise implementation across many languages. Referencing these resources may be useful if you’re unfamilliar with the concept of Promises/Futures:

• Javascript
• Scala
• Python

The provider of a Future<T> may be implemented as follows:

func performAsynchronousWork() -> Future<String> {
    let promise = Promise<String>()
    DispatchQueue.global().async {
        ... on success ...
        promise.fulfill("A string")
        ... on failure ...
        promise.reject(error)
    }
    return promise.future
}

When receiving a Future<T>, you have a number of options. You can immediately observe the result of the future using whenResolved(), whenFulfilled(), or whenRjected(), or choose to do more asyncrhonous work before, or parallel to observing. Each Future<T> can have multiple observers, which are used to both simply return a result, or to queue up other futures.

To perform more asynchronous work, once a Future<T> is fulfilled, use then(). To transform the fulfilled value of a future into another value, use map().

Options for combining futures into a single future is provided using and(), fold(), and Future<T>.reduce()

A Future<T> differs from a Promise<T> in that a future is the container of a result; the promise being the function that sets that result. This design decision was made, in this library as well as in many others, to prevent receivers of Future<T> to resolve the future themselves.

See more

public final class Future<T> : AnyFuture