       let s = DispatchSemaphore(value: 0)
       self.notify(boostQoS: false, handler: { _ in s.signal() })
       s.wait()
-      _ = CAtomicsLoad(deferredState, .acquire)
+      state = CAtomicsLoad(deferredState, .acquire)
     }
 
     // this Deferred is resolved
-    return resolved!
+    let resolved = state.result.assumingMemoryBound(to: Result<Value, Error>.self)
+    return resolved.pointee
   }
 
   /// Get this `Deferred`'s value, blocking if necessary until it becomes resolved.

  var isResolved: Bool { return (self & .stateMask) == .resolved }
  var state: Int { return self & .stateMask }
  var waiters: UnsafeMutableRawPointer? { return UnsafeMutableRawPointer(bitPattern: self & ~.stateMask) }
}

/// An asynchronous computation.

  public init(queue: DispatchQueue, task: @escaping () throws -> Value)
  {
    self.queue = queue
    CAtomicsInitialize(deferredState, .executing)

    queue.async {
