Promise

Creates an instant pending Promise

Creates an instant fulfilled Promise

Creates an instant rejected Promise

Creates a Promise with block-based api

Creates a Promise with enum-based DSL

Progress

If there is an asynchronous action that can succeed more than once, or delivers a series of values over time instead of just one, but you don’t want to finish the promise you can use this function.

let foobar = Promise<Int> { future in
    future(.progress(0))
    future(.progress(1))
    future(.progress(2))
    future(.fulfill(3))
    }.progress({ value in
        // This block is called multiple times
        print(value)
    }).then({ value in
        // This block is called once
        print(value)
    })

Map for chaineable promises

FlatMap for chaineable promises

Then

You can simple chaining multiple asynchronous tasks.

let foobar = Promise { future in
    future(.fulfill("foobar"))
}

promise.then { value in
    print(value)
}

Cancel

This function will trigger a callback that the promise can use to cancel its work. Naturally, requesting cancellation of a promise that has already been resolved does nothing, even if the callbacks have not yet been invoked.

let foobar = Promise<Int> { future in
    future(.progress(0))
    future(.cancel)
    future(.fulfill(3))
    }.progress {
        print($0)
    }.cancel {
        // Handle cancellable work
    }.then { value in
        // This block is never called
        print(value)
}

Returns if promise state is pending

Returns if promise state is fulfilled

Returns if promise state is rejected

Returns if promise state is cancelled

Returns current value of promise

Returns current error of promise

Update promise state synchronous to progressed

Update promise state synchronous to fulfilled

Update promise state synchronous to rejected

Update promise state synchronous to cancelled

Recover

This function lets us catch an error and easily recover from it without breaking the rest of the promise chain.

let foobar = Promise<Int> { _ in
   throw SimpleError()
}.recover { error in
   return Promise(value: 0)
}.then {
   print($0)
}.catch {
   // Handle error
}

Zip

This function allows you to join different promises 2 and return a tuple with the result of them. Promises are resolved in parallel.

 let promise1 = Promise(value: 0)
 let promise2 = Promise(value: "foobar")
 let zipped = Promise<Void>.zip(promise1, promise2)
     .then { value1, value2 in
         print(value1) // This function prints `0`
         print(value2) // This function prints `"foobar"`
}

Zip

This function allows you to join different promises 3 and return a tuple with the result of them. Promises are resolved in parallel.

let promise1 = Promise(value: 0)
let promise2 = Promise(value: "foo")
let promise3 = Promise(value: "bar")
let zipped = Promise<Void>.zip(promise1, promise2, promise3)
   .then { value1, value2, value3 in
       print(value1) // This function prints `0`
       print(value2) // This function prints `"foo"`
       print(value3) // This function prints `"bar"`
}

Zip

This function allows you to join different promises 4 and return a tuple with the result of them. Promises are resolved in parallel.

 let promise1 = Promise(value: 0)
 let promise2 = Promise(value: "foo")
 let promise3 = Promise(value: "bar")
 let promise4 = Promise(value: true)
 let zipped = Promise<Void>.zip(promise1, promise2, promise3, promise4)
        .then { value1, value2, value3 in
            print(value1) // This function prints `0`
            print(value2) // This function prints `"foo"`
            print(value3) // This function prints `"bar"`
            print(value4) // This function prints `true`
 }

Timeout

Timeout allows us to wait for a promise for a time interval or reject it, if it doesn’t resolve within the given time. The interval is expresed in seconds.

let promise = Promise<Int> { future in
    future(.fulfill(5))
    }.timeout(0.5)

Timeout

Static implementation for timeout. The interval is expresed in seconds.

Promise<Void>.timeout(0.2).then {
   // do something
}

Delay

Defer the execution of a Promise by a given time interval.

let promise = Promise<Void>.delay(0.2).then {
   // do something
}

Race

This function race many asynchronous promises and return the value of the first to complete.

let promise1 = Promise(value: 1)
let promise2 = Promise(value: 2)
let promise3 = Promise(value: 3)
let promise4 = Promise(value: 4)

let promise = Promise<Int>
   .race([promise1, promise2, promise3, promise4])
   .then { fastValue in
       print(fastValue)
}

Always

This function allows you to specify a block which will be always executed both for fulfill and reject of the Promise.

let foobar = Promise<Int> { _ in
    throw SimpleError()
}.then {
   print($0)
}.catch {
   // Handle error
}.always {
   // This block is always called
}

Validate

Validate is a function that takes a predicate, and rejects the promise chain if that predicate fails.

let promise = Promise(value: 2)
    .validate { $0 == 3 }
    .catch { error in
        // This promise always fails
}

Retry

Retry operator allows you to execute source chained promise if it ends with a rejection. If reached the attempts the promise still rejected chained promise is also rejected along with the same source error.

 let promise = Promise<Int>
     .retry(attempt: 3) { () -> Promise<Int> in
         guard threshold != 1 else { return Promise(value: 8) }
         threshold -= 1
         return Promise(error: SimpleError())
 }

Catch

This function allows you to handle Promise’s errors. The operator itself implicitly returns another promise, that is rejected with the same error.

let foobar = Promise<Void> { future in
   future(.reject(SimpleError()))
}.then({ value in
   print(value)
}).catch({ error in
   // Handle simple error here
})

All

This function create a Promise that resolved when the list of passed Promises resolves (promises are resolved in parallel). Promise also reject as soon as a promise reject for any reason.

 let promise1 = Promise(value: 1)
 let promise2 = Promise(value: 2)
 let promise3 = Promise(value: 3)
 let promise4 = Promise(value: 4)

 let promise = Promise<Int>
     .all([promise1, promise2, promise3, promise4])
     .then { values in
         for number in values {
             print(number)
         }
 }