     public func succes(value:T) {
         let promise = Promise<T>()
         promise.success(value)
-        self.completeWith(promise.future)
+        self.write(promise.future)
     }
     
     public func failure(error:NSError) {
         let promise = Promise<T>()
         promise.failure(error)
-        self.completeWith(promise.future)
+        self.write(promise.future)
     }
     
-    public func completeWith(future:Future<T>) {
-        self.futureStream.completeWith(future)
+    public func write(future:Future<T>) {
+        self.futureStream.write(future)
     }
     
 

public class FutureStream<T> {
    
    private var futures         = [Future<T>]()
    private typealias InFuture  = Future<T> -> Void
    private var saveCompletes   = [InFuture]()
    

        }
    }
    
    public func map<M>(mapping:T -> Try<M>) -> Future<M> {
        return self.map(QueueContext.main, mapping)
    }
    
    public func map<M>(executionContext:ExecutionContext, mapping:T -> Try<M>) -> Future<M> {
        let promise = Promise<M>()
        self.onComplete(executionContext) {result in
            switch result {
            case .Success(let resultWrapper):
                promise.complete(mapping(resultWrapper.value))
            case .Failure(let error):
                promise.failure(error)
            }
        }
        return promise.future
    }
    
