PromiseKit

func flatMap<U>(
  on dispatchQueue: DispatchQueue? = .main,
  with transform: @escaping (Value) throws -> Promise<U>
) -> Promise<U> {
  Promise<U> { seal in
    self.finally {
      switch $0 {
      case .success(let value):
        dispatchQueue.async {
          do {
            try transform(value).finally {
              switch $0 {
              case .success(let value):
                seal.resolve(with: value, on: dispatchQueue)
              case .failure(let error):
                seal.reject(with: error, on: dispatchQueue)
              }
            }
          } catch { seal.reject(with: error, on: dispatchQueue) }
        }
      case .failure(let error):
        seal.reject(with: error, on: dispatchQueue)
      }
    }
  }
}

// map is derived: map f = flatMap (pure . f)
func map<U>(on dq: DispatchQueue? = .main,
            with transform: @escaping (Value) throws -> U) -> Promise<U> {
  flatMap(on: dq) { do { return .value(try transform($0)) }
                     catch { return .error(error) } }
}

public func concurrentlyDispatch<T>(
  spawnTask next: @escaping (Int) -> Promise<T>?,
  concurrent: Int, retryCount: Int = 2,
  on dispatchQueue: DispatchQueue? = .main
) -> Promise<()> {
  .init { seal in
    let barrier = DispatchQueue(label: "barrier", attributes: .concurrent)
    var segmentIndex = concurrent
    var active = [(promise: Promise<T>, retryCount: Int, segmentIndex: Int)]()

    func observer(_ result: Result<T, Error>, arrayIndex: Int) {
      barrier.async(flags: .barrier) {
        switch result {
        case .success:
          guard let promise = next(segmentIndex) else {
            if active.allSatisfy({ $0.promise.isFulfilled }) {
              seal.resolve(on: dispatchQueue) }; return }
          promise.finally { observer($0, arrayIndex: arrayIndex) }
          active[arrayIndex] = (promise, 0, segmentIndex)
          segmentIndex += 1
        case .failure where active[arrayIndex].retryCount < retryCount:
          let idx = active[arrayIndex].segmentIndex
          let promise = next(idx)!
          promise.finally { observer($0, arrayIndex: arrayIndex) }
          active[arrayIndex] = (promise, active[arrayIndex].retryCount + 1, idx)
        case .failure(let error):
          active.forEach { $0.promise.reject(with: error) }
          seal.reject(with: error, on: dispatchQueue)
        }
      }
    }
    // spawn initial pool
    for i in 0..<concurrent {
      guard let p = next(i) else { break }
      active.append((p, 0, i))
    }
    active.enumerated().forEach { (i, t) in t.promise.finally { observer($0, arrayIndex: i) } }
  }
}

// Applicative > Alternative > Monad (matches Haskell's typeclass tower)
precedencegroup SequencePrecedence { higherThan: ChoicePrecedence }
precedencegroup ChoicePrecedence   { higherThan: FlatMapPrecedence }
precedencegroup FlatMapPrecedence  { higherThan: AssignmentPrecedence }

// >>- monadic bind (flatMap infix)
func >>-<T, U>(p: Promise<T>, f: @escaping (T) throws -> Promise<U>) -> Promise<U> {
  p.flatMap(on: .main, with: f)
}
// <|> alternative (try left, on failure try right)
func <|><T>(left: Promise<T>, right: @autoclosure @escaping () -> Promise<T>) -> Promise<T> {
  left.flatMapError(on: .main) { _ in right() }
}
// <*> applicative apply
func <*><T, U>(left: Promise<(U) -> T>, right: Promise<U>) -> Promise<T> {
  right >>- { r in left.map(on: .main) { $0(r) } }
}

// Usage: curry(makeUser) <^> fetchName() <*> fetchEmail() <*> fetchAge()