 }
 
 // Concrete future wrapper that will never get filled.
-private final class UnfilledFuture<Value>: FutureBase<Value> {
+private final class Never<Value>: FutureBox<Value> {
     override init() {}
 
     override func upon(queue: dispatch_queue_t, body: Value -> ()) {}

*/

// Abstract class that fake-conforms to `FutureType` for use by `Future`.
private class FutureBase<Value>: FutureType {
    func upon(queue: dispatch_queue_t, body: Value -> ()) {
        fatalError()
    }

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

    /// Create a future whose `upon(_:function:)` method forwards to `base`.
    public init<Future: FutureType where Future.Value == Value>(_ base: Future) {
        self.box = ForwardedTo(base: base)
    }

    /// Wrap and forward future as if it were always filled with `value`.
    public init(value: Value) {
        self.box = Always(value: value)
    }

    /// Create a future that will never get fulfilled.
    public init() {
        self.box = Never()
    }
    
    /// Create a future having the same underlying future as `other`.
