 public struct Stream<Element> {
 	private let step : () -> (head : Element, tail : Stream<Element>)
 	
-	private init(_ step : () -> (head : T, tail : Stream<T>)) {
+	private init(_ step : () -> (head : Element, tail : Stream<Element>)) {
 		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> {
+	public static func unfold<A>(initial : A, _ f : A -> (Element, A)) -> Stream<Element> {
 		let (x, d) = f(initial)
 		return Stream { (x, Stream.unfold(d, f)) }
 	}
 	
 	/// Repeats a value into a constant stream of that same value.
-	public static func `repeat`(x : T) -> Stream<T> {
+	public static func `repeat`(x : Element) -> Stream<Element> {
 		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> {
+	public static func iterate(initial : Element, _ f : Element -> Element)-> Stream<Element> {
 		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> {
+	public static func cycle(xs : [Element]) -> Stream<Element> {
 		switch xs.match {
 		case .Nil:
 			return error("Cannot cycle an empty list.")

	/// 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> {
		if p(self.step().head) {
			return Stream { (self.step().head, self.step().tail.filter(p)) }
		}

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