             resolver.resolve(error: error)
           }
         }
-        else
-        {
-          resolver.resolve(result)
-        }
       }
       resolver.retainSource(self)
     }

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

        result in
        guard resolver.needsResolution else { return }
        resolver.beginExecution()
        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()
