 		}
 	}
 	
-	func fold<R>(norm : Free<T> -> R, codense : Codensity<T> -> R) -> R {
+	func fold<R>(norm : FreeId<T> -> R, codense : Codensity<T> -> R) -> R {
 		return undefined()
 	}
 	

	}
}

private class Suspend<T> : Free<T> {
	let suspension : Box<() -> Trampoline<T>>
	
	init(s : Box<() -> Trampoline<T>>) {
		self.suspension = s
	}
	
	private override func fold<R>(norm : Free<T> -> R, codense : Codensity<T> -> R) -> R {
		return norm(self)
	}
	

}

/// There's got to be a better way to do this...
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> : 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 : FreeId<T>, k : T -> FreeId<T>) {
		self.sub = sub
		self.k = k
	}
	
	private override func flatMap<B>(f: T -> FreeId<B>) -> FreeId<B> {
		return liftCodense(sub, { o in suspend(Trampoline(self.k(o).flatMap(f))).t })
	}
		
