         self.future = Future<T>()
     }
 
-    public init(queue:Queue) {
-        self.future = Future<T>(queue:queue)
-    }
-
     public func completeWith(future:Future<T>) {
         self.completeWith(self.future.defaultExecutionContext, future:future)
     }


    private var result:Try<T>?

    typealias OnComplete                                    = Try<T> -> Void
    private var saveCompletes                               = [OnComplete]()
    private let futureQueue : Queue
    
    public var completed : Bool {
        return self.result != nil
    }
    
    public init() {
        self.futureQueue = Queue.simpleFutures
    }
    
    public init(queue:Queue) {
        self.futureQueue = queue
    }

    // should be future mixin
    internal func complete(result:Try<T>) {
        self.futureQueue.async {
            if self.result != nil {
                SimpleFuturesException.futureCompleted.raise()
            }

    private typealias InFuture  = Future<T> -> Void

    private var saveCompletes   = [InFuture]()
    private let futureQueue     = Queue.simpleFutureStreams
    private var capacity : Int?
    
    internal let defaultExecutionContext: ExecutionContext  = QueueContext.main
    
