 
 /// An asynchronous computation.
 ///
-/// A `Deferred` starts out undetermined, in the `.waiting` state.
-/// It may then enter the `.executing` state, and may eventually become determined,
+/// A `Deferred` starts out unresolved, in the `.waiting` state.
+/// It may then enter the `.executing` state, and may eventually become resolved,
 /// either having `.succeeded` or `.errored`.
 ///
-/// A `Deferred` that becomes determined, will henceforth always be determined: it can no longer mutate.
+/// A `Deferred` that becomes resolved, will henceforth always be resolved: it can no longer mutate.
 ///
 /// The `get()` function will return the value of the computation's `Outcome` (or throw an `Error`),
 /// blocking until it becomes available. If the outcome of the computation is known when `get()` is called,
 /// it will return immediately.
 /// The properties `value` and `error` are convenient non-throwing (but blocking) wrappers  for the `get()` method.
 ///
-/// Closures supplied to the `enqueue` function will be called after the `Deferred` has become determined.
+/// Closures supplied to the `enqueue` function will be called after the `Deferred` has become resolved.
 /// The functions `map`, `flatMap`, `notify` and others are wrappers that add functionality to the `enqueue` function.
 
 open class Deferred<Value>


  /// Set our `Deferred` to an error and dispatch all notifications for execution.
  ///
  /// Note that a `Deferred` can only be determined once.
  /// On subsequent calls, `determine` will fail and return `false`.
  /// This operation is lock-free and thread-safe.
  ///
  /// - parameter error: the intended error for this `Deferred`


    // precondition(waiters.load() == .resolved, "waiters.pointer has incorrect value \(String(describing: waiters.load()))")

    // This `Deferred` has been resolved
    return true
  }

  /// Set the value of this `Deferred` and dispatch all notifications for execution.
  ///
  /// Note that a `Deferred` can only be resolved once.
  /// On subsequent calls, `resolve` will fail and return `false`.
  /// This operation is lock-free and thread-safe.
  ///
  /// - parameter value: the intended value for this `Deferred`
  /// - returns: whether the call succesfully changed the state of this `Deferred`.

  @discardableResult
  fileprivate func resolve(value: Value) -> Bool
  {
    return resolve(Outcome(value: value))
  }

  /// Set this `Deferred` to an error and dispatch all notifications for execution.
  ///
  /// Note that a `Deferred` can only be resolved once.
  /// On subsequent calls, `resolve` will fail and return `false`.
  /// This operation is lock-free and thread-safe.
  ///
  /// - parameter error: the intended error for this `Deferred`
  /// - returns: whether the call succesfully changed the state of this `Deferred`.

