 }
 
 /// There's got to be a better way to do this...
-private func liftCodense<A, B>(a : Free<A>, k : A -> Free<B>) -> Codensity<B> {
+private func liftCodense<A, B>(a : FreeId<A>, k : A -> FreeId<B>) -> Codensity<B> {
 	return Codensity<B>(sub: unsafeCoerce(a), unsafeCoerce(k))
 }
 
-private class Codensity<T> : Free<T> {
-	let sub : Free<T>
-	let k : T -> Free<T>
-	
-	private override func fold<R>(norm : Free<T> -> R, codense : Codensity<T> -> R) -> R {
+private class Codensity<T> : FreeId<T> {
+	let sub : FreeId<T>
+	let k : T -> FreeId<T>
+	
+	private override func fold<R>(norm : FreeId<T> -> R, codense : Codensity<T> -> R) -> R {
 		return codense(self)
 	}
 	
-	init(sub : Free<T>, k : T -> Free<T>) {
+	init(sub : FreeId<T>, k : T -> FreeId<T>) {
 		self.sub = sub
 		self.k = k
 	}
 	
-	private override func flatMap<B>(f: T -> Free<B>) -> Free<B> {
+	private override func flatMap<B>(f: T -> FreeId<B>) -> FreeId<B> {
 		return liftCodense(sub, { o in suspend(Trampoline(self.k(o).flatMap(f))).t })
 	}
 		

///
/// Codense implementation with catamorphisms inspired by FunctionalJava
/// https://github.com/functionaljava/functionaljava
private class Free<T> {
	func resume() -> Either<Box<() -> Trampoline<T>>, T> {
		return undefined()
	}

/// Monads" by Rúnar Óli Bjarnason ~( http://blog.higher-order.com/assets/trampolines.pdf ) with the
/// added benefit of Trampoline itself becoming a Monad.
public struct Trampoline<T> {
	private let t : FreeId<T>
	
	private init(_ t : FreeId<T>) {
		self.t = t
	}
	
