 	}
 
 	public let dependencies: [Module]
-	public let definitions: [Binding<Recur>]
+	public let declarations: [Binding<Recur>]
 
 	public var environment: Environment {
 		let dependencies = lazy(self.dependencies).map { $0.environment }
-		let definitions = lazy(self.definitions).map { [$0.symbol: $0.value] }
+		let definitions = lazy(self.declarations).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.definitions = Array(definitions)
	}

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

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