 		return self.step().tail.tail.drop(n - 1)
 	}
 
-	/// Removes elements from the Stream that do not satisfy a given predicate.
+	/// Removes elements from the `Stream` that do not satisfy a given predicate.
 	///
 	/// If there are no elements that satisfy this predicate this function will diverge.
 	public func filter(p : T -> Bool) -> Stream<T> {

		}
	}
	
	/// Returns the first element of a Stream.
	public var head : T {
		return self.step().head
	}
	
	/// Returns the remaining elements of a Stream.
	public var tail : Stream<T> {
		return self.step().tail
	}
	
	/// Returns a Stream of all initial segments of a Stream.
	public var inits : Stream<[T]> {
		return Stream<[T]> { ([], self.step().tail.inits.fmap({ $0.cons(self.step().head) })) }
	}
	
	/// Returns a Stream of all final segments of a Stream.
	public var tails : Stream<Stream<T>> {
		return Stream<Stream<T>> { (self, self.step().tail.tails) }
	}
	
	/// Returns a pair of the first n elements and the remaining eleemnts in a Stream.
	public func splitAt(n : UInt) -> ([T], Stream<T>) {
		if n == 0 {
			return ([], self)

		return Stream { (x, `repeat`(x)) }
	}
	
	/// Returns a `Stream` of an infinite number of iteratations of applications of a function to a value.
	public static func iterate(initial : T, _ f : T -> T)-> Stream<T> {
		return Stream { (initial, Stream.iterate(f(initial), f)) }
	}
	
	/// Cycles a non-empty list into an infinite `Stream` of repeating values.
	///
	/// This function is partial with respect to the empty list.
	public static func cycle(xs : [T]) -> Stream<T> {
