     let queue = DispatchQueue(label: "deferred-recover", qos: qos)
     return recover(queue: queue, transform: transform)
   }
+
+  /// Enqueue a transform to be computed asynchronously if and when `self` becomes resolved with an error.
+  ///
+  /// - 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 the new `Deferred`
+
+  public func flatMapError<OtherFailure>(queue: DispatchQueue? = nil,
+                                         transform: @escaping (_ error: Failure) -> Deferred<Success, OtherFailure>) -> Deferred<Success, OtherFailure>
+  {
+    return TBD(queue: queue ?? self.queue) {
+      resolver in
+      self.notify(queue: queue) {
+        result in
+        guard resolver.needsResolution else { return }
+        resolver.beginExecution()
+        switch result
+        {
+        case let .success(value):
+          resolver.resolve(value: value)
+
+        case let .failure(error):
+          let transformed = transform(error)
+          if let transformed = transformed.peek()
+          {
+            resolver.resolve(transformed)
+          }
+          else
+          {
+            transformed.notify(queue: queue) { resolver.resolve($0) }
+            resolver.retainSource(transformed)
+          }
+        }
+      }
+      resolver.retainSource(self)
+    }
+  }
+
+  /// Enqueue a transform to be computed asynchronously if and when `self` becomes resolved with an error.
+  ///
+  /// - parameter qos: the QoS at which to execute the transform and the new `Deferred`'s notifications
+  /// - 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 the new `Deferred`
+
+  public func flatMapError<OtherFailure>(qos: DispatchQoS,
+                                         transform: @escaping(_ error: Failure) -> Deferred<Success, OtherFailure>) -> Deferred<Success, OtherFailure>
+  {
+    let queue = DispatchQueue(label: "deferred-flatmaperror", qos: qos)
+    return flatMapError(queue: queue, transform: transform)
+  }
 }
 
 extension Deferred
 {
-  /// Flatten a `Deferred<Deferred<Success>>` to a `Deferred<Success>`
+  /// Flatten a `Deferred<Deferred<Success>, Failure>` 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>(queue: DispatchQueue? = nil) -> Deferred<Other>
-    where Success == Deferred<Other>
+  public func flatten<Other>(queue: DispatchQueue? = nil) -> Deferred<Other, Failure>
+    where Success == Deferred<Other, Failure>
   {
     if let result = self.peek()
     {
-      let deferred: Deferred<Other>
-      do {
-        deferred = try result.get()
-      }
-      catch {
-        return Deferred<Other>(queue: queue ?? self.queue, error: error)
+      let deferred: Deferred<Other, Failure>
+      switch result
+      {
+      case .success(let value):
+        deferred = value
+      case .failure(let error):
+        return Deferred<Other, Failure>(queue: queue ?? self.queue, error: error)
       }
 
       if let result = deferred.peek()
       {
-        return Deferred<Other>(queue: queue ?? self.queue, result: result)
+        return Deferred<Other, Failure>(queue: queue ?? self.queue, result: result)
       }
 
       return TBD(queue: queue ?? self.queue) {

  /// - 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>

  /// - parameter qos: the QoS at which to execute the transform and the new `Deferred`'s notifications
  /// - 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 the new `Deferred`

  public func recover(qos: DispatchQoS,
                      transform: @escaping (_ error: Error) throws -> Deferred<Success>) -> Deferred<Success>
