Thenable

The type of the wrapped value

pipe is immediately executed when this Thenable is resolved

The resolved result or nil if pending.

The provided closure executes when this promise is fulfilled.

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

The provided closure is executed when this promise is fulfilled.

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

The provided closure is executed when this promise is fulfilled.

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

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

The provided closure is executed when this promise is fulfilled.

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 promise is fulfilled.

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

The provided closure is executed with promise result.

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

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

Converts a Promise or Guarantee into a promise that can be cancelled.

The provided closure executes when this promise resolves.

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

firstly {
   URLSession.shared.dataTask(.promise, with: url1)
}.then { response in
   transform(data: response.data)
}.done { transformation in
   //…
}

The provided closure is executed when this promise is resolved.

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

The provided closure is executed when this promise is resolved.

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

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

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

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

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

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

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

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

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

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

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

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

Promise<[T]> => T -> Bool => Promise<[T]>

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

Undocumented

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

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

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

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

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

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

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

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

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

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

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

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

Undocumented