       self.notify(queue: queue) {
         result in
         guard resolver.needsResolution else { return }
-        let deferred: Deferred<Other>
-        do {
-          deferred = try result.get()
-        }
-        catch {
+        let deferred: Deferred<Other, Failure>
+        switch result
+        {
+        case .success(let value):
+          deferred = value
+        case .failure(let error):
           resolver.resolve(error: error)
           return
         }

  /// - parameter queue: the `DispatchQueue` to attach to the new `Deferred`; defaults to `self`'s queue.
  /// - parameter transform: the transform to be performed
  /// - returns: a `Deferred` reference representing the return value of the transform
  /// - parameter error: the Error to be transformed for a new `Deferred`

  public func recover(queue: DispatchQueue? = nil,
                      transform: @escaping (_ error: Error) throws -> Deferred<Success>) -> Deferred<Success>

      resolver.retainSource(self)
    }
  }

  /// Flatten a `Deferred<Deferred<Success>, Never>` to a `Deferred<Success, Failure>`
  ///
  /// In the right conditions, acts like a fast path for a flatMap with no transform.
  ///
  /// - parameter queue: the `DispatchQueue` onto which the new `Deferred` should dispatch notifications; use `self.queue` if `nil`
  /// - returns: a flattened `Deferred`

  public func flatten<Other, OtherFailure>(queue: DispatchQueue? = nil) -> Deferred<Other, OtherFailure>
    where Success == Deferred<Other, OtherFailure>, Failure == Never
  {
    if let result = self.peek()
    {
      let deferred: Deferred<Other, OtherFailure>
      switch result
      {
      case .success(let value):
        deferred = value
      }

      if let result = deferred.peek()
      {
        return Deferred<Other, OtherFailure>(queue: queue ?? self.queue, result: result)
      }

      return TBD(queue: queue ?? self.queue) {
        resolver in
        if deferred.state == .executing { resolver.beginExecution() }
        deferred.notify(queue: queue) { resolver.resolve($0) }
        resolver.retainSource(deferred)
      }
    }

    return TBD<Other, OtherFailure>(queue: queue ?? self.queue) {
      resolver in
      self.notify(queue: queue) {
        result in
        guard resolver.needsResolution else { return }
        let deferred: Deferred<Other, OtherFailure>
        switch result
        {
        case .success(let value):
          deferred = value
        }

        if let result = deferred.peek()
        {
          resolver.resolve(result)
          return
        }

        if deferred.state == .executing { resolver.beginExecution() }
        deferred.notify(queue: queue) { resolver.resolve($0) }
        resolver.retainSource(deferred)
      }
      resolver.retainSource(self)
    }
  }

}

extension Deferred
