 		//     then case E (λ t : Tag E . P (there t)) cs.1 t
 		//     else cs.0
 		let `case` = Binding("case",
-			lambda(enumeration) { E in
+			lambda(Enumeration) { E in
 				Recur.lambda(Recur.lambda(Tag[E], const(.Type))) { P in
 					Recur.lambda(Branches[E, P]) { cs in Recur.lambda(Tag[E]) { t in
 						.If(t.first,

extension Expression where Recur: FixpointType {
	public static var description: Module<Recur> {
		let Tag = Recur("Tag")
		let enumeration = Recur("Enumeration")
		let label = Recur("Label")
		let cons = Recur("::")
		let Branches = Recur("Branches")

		// Tag : λ _ : Enumeration . Type
		// Tag = λ E : Enumeration . λ _ : Boolean . Tag E
		let tag = Binding("Tag",
			lambda(enumeration, .BooleanType) { E, _ in Tag[E] },
			lambda(enumeration, const(.Type(0))))

		// here : λ first : Label . λ rest : Enumeration . Tag (first :: rest)
		// here = λ first : Label . (true, first) : Tag (first :: rest)
		let here = Binding("here",
			lambda(label, enumeration) { first, rest in .Annotation(.Product(.Boolean(false), .Unit), Tag[cons[first, rest]]) },
			lambda(label, enumeration) { first, rest in Tag[cons[first, rest]] })

		// there : λ first : Label . λ rest : Enumeration . Tag (first :: rest)
		// there = λ first : Label . (false, rest) : Tag (first :: rest)
		let there = Binding("there",
			lambda(label, enumeration) { first, rest in Recur.lambda(Tag[rest]) { next in .Annotation(.Product(.Boolean(true), next), Tag[cons[first, rest]]) } },
			lambda(label, enumeration) { first, rest in Tag[cons[first, rest]] })


		// Branches : λ E : Enumeration . λ _ : (λ _ : Tag E . Type) . Type

						.Unit)
				}
			},
			lambda(Enumeration) { E in
				.lambda(.lambda(Tag[E], const(.Type)), const(.Type))
			})

