 
 	/// 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
+		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
+		return uncons.map { combine($0, $1.map { $0.foldRight(seed, combine) }) } ?? seed
 	}
 
 

	/// Unpacks the receiver into an optional tuple of its first element and the memoized remainder.
	///
	/// Returns `nil` if the receiver is the empty stream.
	public func uncons() -> (T, Memo<Stream>)? {
		switch self {
		case let Cons(x, rest):
			return (x.value, rest)


	/// A `Stream` of a `T` and the lazily memoized rest of the `Stream`.
	///
	/// Avoid using this directly; instead, use `Stream.cons()` or `Stream.pure()` to construct streams, and `stream.first`, `stream.rest`, and `stream.uncons` to deconstruct them: they don’t require you to `Box` or unbox, `Stream.cons()` comes in `@autoclosure` and `Memo` varieties, and `Stream.pure()`, `Stream.cons()`, and `stream.uncons` are all usable as first-class functions.
	case Cons(Box<T>, Memo<Stream>)

	/// The empty `Stream`.
