Lightweight promises for iOS, macOS, tvOS, watchOS, and Linux

async, futures, ios, macos, promises, server-side-swift, swift, tvos, watchos




Futures is a cross-platform framework for simplifying asynchronous programming, written in Swift. It's lightweight, fast, and easy to understand.

Supported Platforms

Futures supports all platforms where Swift 3 and later is supported.

  • Ubuntu 14.04
  • macOS 10.9
  • tvOS 9.0
  • iOS 8.0
  • watchOS 2.0


Fundamentally, Futures is a very simple framework, that consists of two types:

  • Promise, a single assignment container producing a Future
  • Future, a read-only container resolving into either a value, or an error

Unlike many promise frameworks, a promise is not distinguished from a future, which does not ensure immutability of a promise that gets passed around. This framework distinguishes a Promise from a future in that a Future is the observable value while a Promise is the function that sets the value.

Futures are observed, by default, on a single concurrent dispatch queue. This queue can be modified by assigning a different queue to DispatchQueue.futures. You can also specify a queue of your choice to each callback added to a future .

A future is regarded as:

  • resolved, if its value is set
  • fulfilled, if the value is set, and successful
  • rejected, if the value is set, and a failure (error)


When a function returns a Future<T>, you can either decide to observe it directly, or continue with more asynchronous tasks. For observing, you use:

  • whenResolved, if you're interested in both a value and a rejection error
  • whenFulfilled, if you only care about the values
  • whenRejected, if you only care about the error

If you have more asynchronous work to do based on the result of the first future, you can use

  • then(), to execute another future based on the result of the current one
  • thenIfRejected(), to recover from a potential error resulting from the current future
  • map(), to transform the fulfilled value of the current future
  • mapIfRejected(), to transform an error resulting from the rejection of the current future, as the means of recovering from that error
  • defer(), to execute a Void returning future regardless of whether the current future is rejected or resolved
  • and(), to combine the result of two futures into a single tuple
  • Future<T>.reduce(), to combine the result of multiple futures into a single future

Note that you can specify an observation dispatch queue for all these functions. For instance, you can use then(on: .main), or .map(on: .global()). By default, the queue is DispatchQueue.futures.

As a simple example, this is how some code may look:

let future = loadNetworkResource(
    from: URL("http://someHost/resource")!
).map { data in
    try jsonDecoder.decode(SomeType.self, from: data)
}.defer {

future.whenFulfilled(on: .main) { someType in
    // Success

future.whenRejected(on: .main) { error in
    // Error

To create your functions returning a Future<T>, you create a new pending promise, and resolve it when appropriate.

func performAsynchronousWork() -> Future<String> {
    let promise = Promise<String>()

    DispatchQueue.global().async {

        // If error

    return promise.future

You can also use shorthands.

promise {
     try jsonDecoder.decode(SomeType.self, from: data)
} // Future<SomeType>

Or shorthands which you can return from asynchronously.

promise(String.self) { completion in
    /// ... on success ...
    completion(.fulfill("Some string"))
    /// ... if error ...
} // Future<String>


The complete documentation can be found here.

Getting started

Futures can be added to your project either using Carthage or Swift package manager.

If you want to depend on Futures in your project, it's as simple as adding a dependencies clause to your Package.swift:

dependencies: [
    .package(url: "https://github.com/formbound/Futures.git", from: "1.1.0")

Or, add a dependency in your Cartfile:

github "formbound/Futures"

More details on using Carthage can be found here.

Lastly, import the module in your Swift files

import Futures