         result in
         guard resolver.needsResolution else { return }
         resolver.beginExecution()
-        if let error = result.error
+        switch result
         {
+        case let .success(value):
+          resolver.resolve(value: value)
+
+        case let .failure(error):
           do {
             let transformed = try transform(error)
             if let transformed = transformed.peek()

  /// - parameter task: the computation to be performed

  public static func Retrying(_ attempts: Int, queue: DispatchQueue,
                              task: @escaping () throws -> Deferred) -> Deferred
  {
    let error = Invalidation.invalid("task was not allowed a single attempt in \(#function)")
    let deferred = Deferred<Success>(queue: queue, error: error)

    if attempts < 1 { return deferred }

    return Deferred.Retrying(attempts, deferred, task: task)
  }

  private static func Retrying(_ attempts: Int, _ deferred: Deferred, task: @escaping () throws -> Deferred) -> Deferred
  {
    return (0..<attempts).reduce(deferred) {
      (deferred, _) in

  /// - parameter error: the Error to be transformed for the new `Deferred`

  public func recover(qos: DispatchQoS,
                      transform: @escaping (_ error: Error) throws -> Deferred<Success, Error>) -> Deferred<Success, Error>
  {
    let queue = DispatchQueue(label: "deferred-recover", qos: qos)
    return recover(queue: queue, transform: transform)
