 }
 
 // Concrete future wrapper that will never get filled.
-private final class Never<Value>: FutureBox<Value> {
+private final class Never<Value>: Box<Value> {
     override init() {}
 
-    override func upon(_: DispatchQueue, execute _: @escaping(Value) -> Void) {}
+    override func upon(_: Future<Value>.PreferredExecutor, execute _: @escaping(Value) -> Void) {}
 
     override func upon(_: Executor, execute _: @escaping(Value) -> Void) {}
 

}

// Concrete future wrapper for an always-filled future.
private final class Always<Value>: FutureBox<Value> {
    let value: Value
    init(value: Value) {
        self.value = value
    }

    override func upon(_ queue: DispatchQueue, execute body: @escaping(Value) -> Void) {
        queue.async { [value] in
            body(value)
        }

///   ensuring that only your implementation can fill the deferred value
///   using the `PromiseProtocol` aspect.
public struct Future<Value>: FutureProtocol {
    private let box: Box<Value>

    /// Create a future whose `upon(_:execute:)` methods forward to `base`.
    public init<OtherFuture: FutureProtocol>(_ base: OtherFuture)
