 
   public convenience init(queue: DispatchQueue, error: Error)
   {
-    self.init(queue: queue, outcome: Result<Value, Error>(error: error))
+    self.init(queue: queue, result: Result<Value, Error>(error: error))
   }
 
   // MARK: state changes / resolve

  ///
  /// - parameter queue:     the `DispatchQueue` onto which the computation should be enqueued; use `source.queue` if `nil`
  /// - parameter source:    the `Deferred` whose error should be used as the input for the transform
  /// - parameter transform: the transform to be applied to `source.error` and whose outcome is represented by this `Deferred`
  /// - parameter error:     the Error to be transformed for a new `Deferred`

  init(queue: DispatchQueue?, source: Deferred<Value>, transform: @escaping (_ error: Error) throws -> Deferred<Value>)

    guard updatedState != .resolving else { return false }
    // this thread has exclusive access

    resolved = result
    source = nil

    // This atomic swap operation uses memory order .acqrel.
