 
 /// Produces the concatenation of `left` and `right`.
 public func ++ <T> (left: Stream<T>, right: Stream<T>) -> Stream<T> {
-	return left.uncons().map { first, rest in
+	return left.uncons.map { first, rest in
 		.cons(first, Memo { rest.value ++ right })
 	} ?? right
 }


	/// Returns a `Stream` produced by mapping the elements of the receiver with `f`.
	public func map<U>(f: T -> U) -> Stream<U> {
		return uncons().map { .cons(f($0), $1.value.map(f)) } ?? nil
	}




	/// Folds the receiver ending with a given `seed` using the right-associative function `combine`.
	public func foldRight<Result>(seed: Result, _ combine: (T, Result) -> Result) -> Result {
		return uncons.map { combine($0, $1.value.foldRight(seed, combine)) } ?? seed
	}

	/// Folds the receiver ending with a given `seed` using the right-associative function `combine`.
	///
	/// `combine` receives the accumulator as a lazily memoized value. Thus, `combine` may terminate the fold simply by not evaluating the memoized accumulator.
	public func foldRight<Result>(seed: Result, _ combine: (T, Memo<Result>) -> Result) -> Result {
		return uncons.map { combine($0, $1.map { $0.foldRight(seed, combine) }) } ?? seed
	}


