 public func unfold<A, B>(f : A -> (B, A)) -> A -> Stream<B> {
 	return { z in  
 		let (x, d) = f(z)
-		return Stream(st: (x, unfold(f)(d)))
+		return Stream((x, unfold(f)(d)))
 	}
 }
 
 /// Returns a Stream of alternating elements from each Stream.
 public func interleave<T>(s1 : Stream<T>) -> Stream<T> -> Stream<T> {
-	return { s2 in Stream(st: (s1.st().head, interleave(s2)(s1))) }
+	return { s2 in Stream((s1.step().head, interleave(s2)(s1))) }
 }
 
 /// Creates a Stream alternating an element in between the values of another Stream.
 public func intersperse<T>(x : T) -> Stream<T> -> Stream<T> {
-	return { s in Stream(st: (s.st().head, Stream(st: (x, intersperse(x)(s.st().tail))))) }
+	return { s in Stream((s.step().head, Stream((x, intersperse(x)(s.step().tail))))) }
 }
 
 /// Returns a Stream of successive reduced values.
 public func scanl<A, B>(f : A -> B -> A) -> A -> Stream<B> -> Stream<A> {
-	return { z in { s in Stream(st: (z, scanl(f)(f(z)(s.st().head))(s.st().tail))) } }
+	return { z in { s in Stream((z, scanl(f)(f(z)(s.step().head))(s.step().tail))) } }
 }
 
 /// Returns a Stream of successive reduced values.
 public func scanl1<A>(f : A -> A -> A) -> Stream<A> -> Stream<A> {
-	return { s in scanl(f)(s.st().head)(s.st().tail) }
+	return { s in scanl(f)(s.step().head)(s.step().tail) }
 }
 
 /// Transposes the "Rows and Columns" of an infinite Stream.
 public func transpose<T>(ss : Stream<Stream<T>>) -> Stream<Stream<T>> {
-	let xs = ss.st().head
-	let yss = ss.st().tail
-	return Stream(st: (Stream(st: (xs.st().head, map(head)(yss))), transpose(Stream(st: (xs.st().tail, map(tail)(yss)))))) 
+	let xs = ss.step().head
+	let yss = ss.step().tail
+	return Stream((Stream((xs.step().head, map(head)(yss))), transpose(Stream((xs.step().tail, map(tail)(yss)))))) 
 }
 
 /// Returns the first n elements of a Stream.


/// A lazy infinite sequence of values.
public struct Stream<T> {
	let st : @autoclosure() -> (head : T, tail : Stream<T>)
	
	public subscript(n : UInt) -> T {
		return index(self)(n)

/// Returns the longest suffix remaining after a predicate holds.
public func dropWhile<T>(p : T -> Bool) -> Stream<T> -> Stream<T> {
	return { s in 
		if p(s.step().head) {
			return dropWhile(p)(s.step().tail)
		}
		return s
	}
