CancellableThenable

Type of the delegate thenable

Delegate thenable for this CancellableThenable

The CancelContext associated with this CancellableThenable

Tracks the cancel items for this CancellableThenable. These items are removed from the associated CancelContext when the thenable resolves.

Append the task and reject function for a cancellable task to the cancel context

Append the cancel context associated with from to our cancel context. Typically from is a branch of our chain.

Cancel all members of the promise chain and their associated asynchronous operations.

True if all members of the promise chain have been successfully cancelled, false otherwise.

True if cancel has been called on the CancelContext associated with this promise, false otherwise. cancelAttempted will be true if cancel is called on any promise in the chain.

The cancellation error generated when the promise is cancelled, or nil if not cancelled.

The provided closure executes when this cancellable promise resolves.

This allows chaining promises. The cancellable promise returned by the provided closure is resolved before the cancellable promise returned by this closure resolves.

The provided closure executes when this cancellable promise resolves.

This allows chaining promises. The promise returned by the provided closure is resolved before the cancellable promise returned by this closure resolves.

The provided closure is executed when this cancellable promise is resolved.

This is like then but it requires the closure to return a non-promise and non-cancellable-promise.

The provided closure is executed when this cancellable promise is resolved.

In your closure return an Optional, if you return nil the resulting cancellable promise is rejected with PMKError.compactMap, otherwise the cancellable promise is fulfilled with the unwrapped value.

 let context = firstly {
     URLSession.shared.dataTask(.promise, with: url)
 }.cancellize().compactMap {
     try JSONSerialization.jsonObject(with: $0.data) as? [String: String]
 }.done { dictionary in
     //…
 }.catch {
     // either `PMKError.compactMap` or a `JSONError`
 }.cancelContext

 //…

 context.cancel()

The provided closure is executed when this cancellable promise is resolved.

Equivalent to map { x -> Void in, but since we force the Void return Swift is happier and gives you less hassle about your closure’s qualification.

The provided closure is executed when this cancellable promise is resolved.

This is like done but it returns the same value that the handler is fed. get immutably accesses the fulfilled value; the returned CancellablePromise maintains that value.

The provided closure is executed with cancellable promise result.

This is like get but provides the Result of the CancellablePromise so you can inspect the value of the chain at this point without causing any side effects.

promise.tap{ print($0) }.then{ /*…

The provided closure executes when this cancellable promise resolves.

This allows chaining promises. The cancellable promise returned by the provided closure is resolved before the cancellable promise returned by this closure resolves.

let context = firstly {
   URLSession.shared.dataTask(.promise, with: url1)
}.cancellize().then { response in
   transform(data: response.data) // returns a CancellablePromise
}.done { transformation in
   //…
}.cancelContext
//…
context.cancel()

The provided closure executes when this cancellable promise resolves.

This allows chaining promises. The promise returned by the provided closure is resolved before the cancellable promise returned by this closure resolves.

let context = firstly {
   URLSession.shared.dataTask(.promise, with: url1)
}.cancellize().then { response in
   transform(data: response.data) // returns a Promise
}.done { transformation in
   //…
}.cancelContext
//…
context.cancel()

The provided closure is executed when this cancellable promise is resolved.

This is like then but it requires the closure to return a non-promise and non-cancellable-promise.

let context = firstly {
   URLSession.shared.dataTask(.promise, with: url1)
}.cancellize().map { response in
   response.data.length
}.done { length in
   //…
}.cancelContext
//…
context.cancel()

The provided closure is executed when this cancellable promise is resolved.

In your closure return an Optional, if you return nil the resulting cancellable promise is rejected with PMKError.compactMap, otherwise the cancellable promise is fulfilled with the unwrapped value.

let context = firstly {
   URLSession.shared.dataTask(.promise, with: url)
}.cancellize().compactMap {
   try JSONSerialization.jsonObject(with: $0.data) as? [String: String]
}.done { dictionary in
   //…
}.catch {
   // either `PMKError.compactMap` or a `JSONError`
}.cancelContext
//…
context.cancel()

CancellablePromise<[U.T]> => U.T -> V => CancellablePromise<[V]>

firstly {
    cancellize(Promise.value([1,2,3]))
}.mapValues { integer in
    integer * 2
}.done {
    // $0 => [2,4,6]
}

CancellablePromise<[U.T]> => U.T -> [V] => CancellablePromise<[V]>

firstly {
    cancellize(Promise.value([1,2,3]))
}.flatMapValues { integer in
    [integer, integer]
}.done {
    // $0 => [1,1,2,2,3,3]
}

CancellablePromise<[U.T]> => U.T -> V? => CancellablePromise<[V]>

firstly {
    cancellize(Promise.value(["1","2","a","3"]))
}.compactMapValues {
    Int($0)
}.done {
    // $0 => [1,2,3]
}

CancellablePromise<[U.T]> => U.T -> CancellablePromise<V> => CancellablePromise<[V]>

firstly {
    cancellize(Promise.value([1,2,3]))
}.thenMap { integer in
    cancellize(Promise.value(integer * 2))
}.done {
    // $0 => [2,4,6]
}

CancellablePromise<[U.T]> => U.T -> Promise<V> => CancellablePromise<[V]>

firstly {
    Promise.value([1,2,3])
}.cancellize().thenMap { integer in
    .value(integer * 2)
}.done {
    // $0 => [2,4,6]
}

CancellablePromise<[T]> => T -> CancellablePromise<[U]> => CancellablePromise<[U]>

firstly {
    cancellize(Promise.value([1,2,3]))
}.thenFlatMap { integer in
    cancellize(Promise.value([integer, integer]))
}.done {
    // $0 => [1,1,2,2,3,3]
}

CancellablePromise<[T]> => T -> Promise<[U]> => CancellablePromise<[U]>

firstly {
    Promise.value([1,2,3])
}.cancellize().thenFlatMap { integer in
    .value([integer, integer])
}.done {
    // $0 => [1,1,2,2,3,3]
}

CancellablePromise<[T]> => T -> Bool => CancellablePromise<[U]>

firstly {
    cancellize(Promise.value([1,2,3]))
}.filterValues {
    $0 > 1
}.done {
    // $0 => [2,3]
}

Undocumented

CancellablePromise<[U.T]> => U.T -> V => CancellablePromise<[V]>

firstly {
    cancellize(Promise.value([1,2,3]))
}.mapValues { integer in
    integer * 2
}.done {
    // $0 => [2,4,6]
}

CancellablePromise<[U.T]> => U.T -> [V] => CancellablePromise<[V]>

firstly {
    cancellize(Promise.value([1,2,3]))
}.flatMapValues { integer in
    [integer, integer]
}.done {
    // $0 => [1,1,2,2,3,3]
}

CancellablePromise<[U.T]> => U.T -> V? => CancellablePromise<[V]>

firstly {
    cancellize(Promise.value(["1","2","a","3"]))
}.compactMapValues {
    Int($0)
}.done {
    // $0 => [1,2,3]
}

CancellablePromise<[U.T]> => U.T -> CancellablePromise<V> => CancellablePromise<[V]>

firstly {
    cancellize(Promise.value([1,2,3]))
}.thenMap { integer in
    cancellize(Promise.value(integer * 2))
}.done {
    // $0 => [2,4,6]
}

CancellablePromise<[U.T]> => U.T -> Promise<V> => CancellablePromise<[V]>

firstly {
    Promise.value([1,2,3])
}.cancellize().thenMap { integer in
    .value(integer * 2)
}.done {
    // $0 => [2,4,6]
}

CancellablePromise<[T]> => T -> CancellablePromise<[U]> => CancellablePromise<[U]>

firstly {
    cancellize(Promise.value([1,2,3]))
}.thenFlatMap { integer in
    cancellize(Promise.value([integer, integer]))
}.done {
    // $0 => [1,1,2,2,3,3]
}

CancellablePromise<[T]> => T -> Promise<[U]> => CancellablePromise<[U]>

firstly {
    Promise.value([1,2,3])
}.cancellize().thenFlatMap { integer in
    .value([integer, integer])
}.done {
    // $0 => [1,1,2,2,3,3]
}

CancellablePromise<[T]> => T -> Bool => CancellablePromise<[U]>

firstly {
    cancellize(Promise.value([1,2,3]))
}.filterValues {
    $0 > 1
}.done {
    // $0 => [2,3]
}

Undocumented