 	public func typecheck() -> [Error] {
 		let environment = self.environment
 		let context = self.context
-		return lazy(definitions)
+		return lazy(declarations)
 			.map { $0.typecheck(environment, context) }
 			.reduce([]) { $0 + ($1.left.map { [ $0 ] } ?? []) }
 	}

	}

	public let dependencies: [Module]
	public let definitions: [Binding<Recur>]

	public var environment: Environment {
		let dependencies = lazy(self.dependencies).map { $0.environment }
		let definitions = lazy(self.definitions).map { [$0.symbol: $0.value] }
		return dependencies
			.concat(definitions)
			.reduce(Environment(), combine: +)


	public init<D: SequenceType, S: SequenceType where D.Generator.Element == Module, S.Generator.Element == Binding<Recur>>(_ dependencies: D, _ definitions: S) {
		self.dependencies = Array(dependencies)
		self.declarations = Array(definitions)
	}

	public init<S: SequenceType where S.Generator.Element == Binding<Recur>>(_ definitions: S) {
