     }
 }
 
-public func forcomp<T,U,V>(f:Try<T>, g:Try<U>, h:Try<V>, apply:(T,U,V) -> Void) {
+public func forcomp<T,U,V>(f: Try<T>, g: Try<U>, h: Try<V>, apply: (T,U,V) -> Void) {
     f.foreach {fvalue in
         g.foreach {gvalue in
             h.foreach {hvalue in

    }
}

public func forcomp<T,U>(f:Try<T>, g:Try<U>, apply:(T,U) -> Void) {
    f.foreach {fvalue in
        g.foreach {gvalue in
            apply(fvalue, gvalue)

        return future
    }
    
    public func andThen(complete: Try<T> -> Void) -> FutureStream<T> {
        return self.andThen(self.defaultExecutionContext, complete: complete)
    }
    
    public func andThen(executionContext: ExecutionContext, complete: Try<T> -> Void) -> FutureStream<T> {
        let future = FutureStream<T>(capacity: self.capacity)
        future.onComplete(executionContext, complete: complete)
        self.onComplete(executionContext) { result in
            future.complete(result)
        }
        return future
    }
    
    public func recover(recovery :NSError -> Try<T>) -> FutureStream<T> {
        return self.recover(self.defaultExecutionContext, recovery: recovery)
    }
    
    public func recover(executionContext: ExecutionContext, recovery :NSError -> Try<T>) -> FutureStream<T> {
        let future = FutureStream<T>(capacity:self.capacity)
        self.onComplete(executionContext) { result in
            future.complete(result.recoverWith(recovery))
        }
        return future
    }
    
    public func recoverWith(recovery: NSError -> FutureStream<T>) -> FutureStream<T> {
        return self.recoverWith(self.defaultExecutionContext, recovery: recovery)
    }
    
    public func recoverWith(executionContext: ExecutionContext, recovery: NSError -> FutureStream<T>) -> FutureStream<T> {
        let future = FutureStream<T>(capacity: self.capacity)
        self.onComplete(executionContext) { result in
            switch result {
            case .Success(let value):
                future.success(value)
            case .Failure(let error):
                future.completeWith(executionContext, stream: recovery(error))
            }
        }
        return future
    }
    
    public func withFilter(filter: T -> Bool) -> FutureStream<T> {
        return self.withFilter(self.defaultExecutionContext, filter: filter)
    }
    
    public func withFilter(executionContext: ExecutionContext, filter: T -> Bool) -> FutureStream<T> {
        let future = FutureStream<T>(capacity: self.capacity)
        self.onComplete(executionContext) { result in
            future.complete(result.filter(filter))
        }
        return future
    }
    
    public func foreach(apply: T -> Void) {
        self.foreach(self.defaultExecutionContext, apply: apply)
    }
    
    public func foreach(executionContext: ExecutionContext, apply: T -> Void) {
        self.onComplete(executionContext) { result in
            result.foreach(apply)
        }
    }

    // MARK: Future Combinators
    public func flatmap<M>(mapping: T -> Future<M>) -> FutureStream<M> {
        return self.flatmap(self.defaultExecutionContext, mapping: mapping)
    }
    
    public func flatmap<M>(executionContext: ExecutionContext, mapping: T -> Future<M>) -> FutureStream<M> {
        let future = FutureStream<M>(capacity: self.capacity)
        self.onComplete(executionContext) { result in
            switch result {
            case .Success(let value):
                future.completeWith(executionContext, future:mapping(value))
