 	return Stream { (Stream { (xs.step().head, yss.fmap{ $0.head }) }, transpose(Stream { (xs.step().tail, yss.fmap{ $0.tail }) } )) }
 }
 
-/// Zips two Streams into a Stream of pairs.
+/// Zips two `Stream`s into a `Stream` of pairs.
 public func zip<A, B>(s1 : Stream<A>) -> Stream<B> -> Stream<(A, B)> {
 	return { s2 in Stream { ((s1.step().head, s2.step().head), zip(s1.step().tail)(s2.step().tail)) } }
 }
 
-/// Zips two Streams into a third Stream using a combining function.
+/// Zips two `Stream`s into a third Stream using a combining function.
 public func zipWith<A, B, C>(f : A -> B -> C) -> Stream<A> -> Stream<B> -> Stream<C> {
 	return { s1 in { s2 in Stream { (f(s1.step().head)(s2.step().head), zipWith(f)(s1.step().tail)(s2.step().tail)) } } }
 }
 
-/// Unzips a Stream of pairs into a pair of Streams.
+/// Unzips a `Stream` of pairs into a pair of Streams.
 public func unzip<A, B>(sp : Stream<(A, B)>) -> (Stream<A>, Stream<B>) {
 	return (sp.fmap(fst), sp.fmap(snd))
 }

		return self
	}
	
	/// Returns the first n elements of a Stream.
	public func take(n : UInt) -> [T] {
		if n == 0 {
			return []

		self.step = step
	}
	
	/// Uses function to construct a `Stream`.
	///
	/// Unlike unfold for lists, unfolds to construct a `Stream` have no base case.
	public static func unfold<A>(initial : A, _ f : A -> (T, A)) -> Stream<T> {
		let (x, d) = f(initial)
		return Stream { (x, Stream.unfold(d, f)) }
