   /// - returns: this `Deferred`'s resolved value, or `nil`
 
   public var value: Value? {
-    return outcome.value
+    return result.value
   }
 
   /// Get this `Deferred`'s error state, blocking if necessary until it becomes resolved.


  public init(queue: DispatchQueue? = nil, source: Deferred<Value>)
  {
    if let outcome = source.peek()
    {
      super.init(queue: queue ?? source.queue, outcome: outcome)
    }
    else
    {
      super.init(queue: queue ?? source.queue, source: source, beginExecution: true)
      source.enqueue(queue: queue, boostQoS: false,
                     task: { [weak self] outcome in self?.resolve(outcome) })
    }
  }
}

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