     internal func complete(result: Try<T>) {
         let future = Future<T>()
         future.complete(result)
-        self.futureQueue.sync {
-            self.addFuture(future)
-            for complete in self.saveCompletes {
-                complete(future)
-            }
+        self.addFuture(future)
+        for complete in self.saveCompletes {
+            complete(future)
         }
     }
 


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

    // MARK: Complete
    internal func complete(result: Try<T>) {
        self.futureQueue.sync {
            if self.result != nil {
                SimpleFuturesException.futureCompleted.raise()
            }
            self.result = result
            for complete in self.saveCompletes {
                complete(result)
            }
            self.saveCompletes.removeAll()
        }
    }

    internal func completeWith(future: Future<T>) {

    private typealias InFuture = Future<T> -> Void

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