dhall 0.1.0 → 0.5.1

data/lib/dhall/resolve.rb

@@ -16,23 +16,32 @@ module Dhall
 	module Resolvers
 		ReadPathSources = lambda do |sources|
 			sources.map do |source|
-				Promise.resolve(nil).then { source.pathname.binread }
+				Util::LazyPromise.new { source.pathname.binread }
+			end
+		end
+
+		ReadEnvironmentSources = lambda do |sources|
+			sources.map do |source|
+				Util::LazyPromise.new do
+					ENV.fetch(source.var) do
+						raise ImportFailedException, "No #{source}"
+					end
+				end
 			end
 		end
 
 		PreflightCORS = lambda do |source, parent_origin|
+			timeout = source.deadline.timeout
 			uri = source.uri
 			if parent_origin != "localhost" && parent_origin != source.origin
 				req = Net::HTTP::Options.new(uri)
 				req["Origin"] = parent_origin
 				req["Access-Control-Request-Method"] = "GET"
 				req["Access-Control-Request-Headers"] =
-					source.headers.map { |h| h.fetch("header").to_s }.join(",")
-				r = Net::HTTP.start(
-					uri.hostname,
-					uri.port,
-					use_ssl: uri.scheme == "https"
-				) { |http| http.request(req) }
+					source.headers.to_a.map { |h|
+						(h.fetch("header") { h.fetch("mapKey") }).to_s
+					}.join(",")
+				r = Util.net_http_req_with_timeout(uri, req, timeout: timeout)
 
 				raise ImportFailedException, source if r.code != "200"
 				unless r["Access-Control-Allow-Origin"] == parent_origin ||
@@ -44,18 +53,21 @@ module Dhall
 
 		ReadHttpSources = lambda do |sources, parent_origin|
 			sources.map do |source|
-				Promise.resolve(nil).then do
+				Util::LazyPromise.new do
 					PreflightCORS.call(source, parent_origin)
+					timeout = source.deadline.timeout
 					uri = source.uri
-					req = Net::HTTP::Get.new(uri)
-					source.headers.each do |header|
-						req[header.fetch("header").to_s] = header.fetch("value").to_s
+					r = loop do
+						req = Net::HTTP::Get.new(uri)
+						source.headers.each do |header|
+							req[(header.fetch("header") { header.fetch("mapKey") }).to_s] =
+								(header.fetch("value") { header.fetch("mapValue") }).to_s
+						end
+						r = Util.net_http_req_with_timeout(uri, req, timeout: timeout)
+
+						break r unless ["301", "302", "303", "307", "308"].include?(r.code)
+						uri = URI(r["Location"])
 					end
-					r = Net::HTTP.start(
-						uri.hostname,
-						uri.port,
-						use_ssl: uri.scheme == "https"
-					) { |http| http.request(req) }
 
 					raise ImportFailedException, source if r.code != "200"
 					r.body
@@ -63,6 +75,18 @@ module Dhall
 			end
 		end
 
+		StandardReadHttpSources = lambda do |sources, parent_origin|
+			ReadHttpSources.call(sources, parent_origin).map do |source_promise|
+				source_promise.then do |s|
+					s = s.dup.force_encoding("UTF-8")
+					unless s.valid_encoding?
+						raise ImportFailedException, "#{s.inspect} is not valid UTF-8"
+					end
+					s
+				end
+			end
+		end
+
 		RejectSources = lambda do |sources|
 			sources.map do |source|
 				Promise.new.reject(ImportBannedException.new(source))
@@ -74,7 +98,7 @@ module Dhall
 				path_reader: ReadPathSources,
 				http_reader: ReadHttpSources,
 				https_reader: http_reader,
-				public_gateway: "cloudflare-ipfs.com"
+				public_gateway: URI("https://cloudflare-ipfs.com")
 			)
 				@path_reader = path_reader
 				@http_reader = http_reader
@@ -89,7 +113,7 @@ module Dhall
 			def call(sources)
 				@path_reader.call(sources).map.with_index do |promise, idx|
 					source = sources[idx]
-					if source.is_a?(Import::AbsolutePath) &&
+					if source.canonical.is_a?(Import::AbsolutePath) &&
 					   ["ipfs", "ipns"].include?(source.path.first)
 						gateway_fallback(source, promise)
 					else
@@ -107,7 +131,7 @@ module Dhall
 			def gateway_fallback(source, promise)
 				promise.catch {
 					@http_reader.call([
-						source.to_uri(Import::Http, "localhost:8000")
+						source.to_uri(Import::Http, URI("http://localhost:8000"))
 					], "localhost").first
 				}.catch do
 					@https_reader.call([
@@ -117,17 +141,67 @@ module Dhall
 			end
 		end
 
+		module NoCache
+			def self.fetch(*)
+				yield
+			end
+		end
+
+		class RamCache
+			def initialize
+				@cache = {}
+			end
+
+			def fetch(key, &block)
+				return @cache[key] if @cache.key?(key)
+
+				Promise.resolve(nil).then(&block).then do |result|
+					@cache[key] = result
+				end
+			end
+		end
+
+		class StandardFileCache
+			def initialize(
+				dir=Pathname.new(ENV.fetch(
+					"XDG_CACHE_HOME", ENV.fetch("HOME") + "/.cache/"
+				)) + "dhall/"
+			)
+				dir.mkpath
+				@dir = dir
+				@ram = RamCache.new
+			end
+
+			def fetch(key, &block)
+				if key.is_a?(String) && key.start_with?("sha256:")
+					file = @dir + key.sub(/^sha256:/, "1220")
+					return Dhall.from_binary(file.binread) if file.exist?
+
+					Promise.resolve(nil).then(&block).then do |result|
+						file.open("wb") { |fh| fh.write(result.to_cbor) }
+						result
+					end
+				else
+					@ram.fetch(key, &block)
+				end
+			end
+		end
+
 		class ResolutionSet
-			def initialize(reader)
+			def initialize(reader, max_depth:)
 				@reader = reader
+				@max_depth = max_depth
 				@parents = []
 				@set = Hash.new { |h, k| h[k] = [] }
 			end
 
 			def register(source)
 				p = Promise.new
-				if @parents.include?(source)
+				if @parents.include?(source.canonical)
 					p.reject(ImportLoopException.new(source))
+				elsif @parents.length + 1 > @max_depth
+					msg = "Max import depth of #{@max_depth} exceeded"
+					p.reject(ImportFailedException.new(msg))
 				else
 					@set[source] << p
 				end
@@ -141,6 +215,8 @@ module Dhall
 
 			def reader
 				lambda do |sources|
+					raise TimeoutException if sources.any? { |s| s.deadline.exceeded? }
+
 					if @reader.arity == 2
 						@reader.call(sources, @parents.last&.origin || "localhost")
 					else
@@ -159,28 +235,66 @@ module Dhall
 			end
 		end
 
+		class SourceWithDeadline < SimpleDelegator
+			attr_reader :deadline
+
+			def initialize(source, deadline)
+				@source = source
+				@deadline = deadline
+
+				super(source)
+			end
+
+			def to_uri(*args)
+				self.class.new(super, deadline)
+			end
+		end
+
 		class Standard
+			attr_reader :deadline
+
 			def initialize(
 				path_reader: ReadPathSources,
-				http_reader: ReadHttpSources,
-				https_reader: http_reader
+				http_reader: StandardReadHttpSources,
+				https_reader: http_reader,
+				environment_reader: ReadEnvironmentSources,
+				cache: StandardFileCache.new,
+				max_depth: Float::INFINITY
 			)
-				@path_resolutions = ResolutionSet.new(path_reader)
-				@http_resolutions = ResolutionSet.new(http_reader)
-				@https_resolutions = ResolutionSet.new(https_reader)
-				@cache = {}
+				@path_resolutions = ResolutionSet.new(path_reader, max_depth: max_depth)
+				@http_resolutions = ResolutionSet.new(http_reader, max_depth: max_depth)
+				@https_resolutions = ResolutionSet.new(https_reader, max_depth: max_depth)
+				@env_resolutions = ResolutionSet.new(
+					environment_reader, max_depth: max_depth
+				)
+				@deadline = Util::NoDeadline.new
+				@cache = cache
+			end
+
+			def with_deadline(deadline)
+				dup.tap do |c|
+					c.instance_eval do
+						@deadline = deadline
+					end
+				end
 			end
 
 			def cache_fetch(key, &fallback)
 				@cache.fetch(key) do
-					Promise.resolve(nil).then(&fallback).then do |result|
-						@cache[key] = result
-					end
+					Promise.resolve(nil).then(&fallback)
 				end
 			end
 
 			def resolve_path(path_source)
-				@path_resolutions.register(path_source)
+				@path_resolutions.register(
+					SourceWithDeadline.new(path_source, @deadline)
+				)
+			end
+
+			def resolve_environment(env_source)
+				@env_resolutions.register(
+					SourceWithDeadline.new(env_source, @deadline)
+				)
 			end
 
 			def resolve_http(http_source)
@@ -188,8 +302,9 @@ module Dhall
 					resolver:    self,
 					relative_to: Dhall::Import::RelativePath.new
 				).then do |headers|
+					source = http_source.with(headers: headers.normalize)
 					@http_resolutions.register(
-						http_source.with(headers: headers.normalize)
+						SourceWithDeadline.new(source, @deadline)
 					)
 				end
 			end
@@ -199,8 +314,9 @@ module Dhall
 					resolver:    self,
 					relative_to: Dhall::Import::RelativePath.new
 				).then do |headers|
+					source = https_source.with(headers: headers.normalize)
 					@https_resolutions.register(
-						https_source.with(headers: headers.normalize)
+						SourceWithDeadline.new(source, @deadline)
 					)
 				end
 			end
@@ -208,6 +324,7 @@ module Dhall
 			def finish!
 				[
 					@path_resolutions,
+					@env_resolutions,
 					@http_resolutions,
 					@https_resolutions
 				].each do |rset|
@@ -220,6 +337,7 @@ module Dhall
 				dup.tap do |c|
 					c.instance_eval do
 						@path_resolutions = @path_resolutions.child(parent_source)
+						@env_resolutions = @env_resolutions.child(parent_source)
 						@http_resolutions = @http_resolutions.child(parent_source)
 						@https_resolutions = @https_resolutions.child(parent_source)
 					end
@@ -232,27 +350,36 @@ module Dhall
 				path_reader: ReadPathSources,
 				http_reader: ReadHttpSources,
 				https_reader: http_reader,
-				ipfs_public_gateway: "cloudflare-ipfs.com"
+				environment_reader: ReadEnvironmentSources,
+				ipfs_public_gateway: URI("https://cloudflare-ipfs.com"),
+				cache: RamCache.new,
+				max_depth: 50
 			)
 				super(
-					path_reader:  ReadPathAndIPFSSources.new(
+					path_reader: ReadPathAndIPFSSources.new(
 						path_reader:    path_reader,
 						http_reader:    http_reader,
 						https_reader:   https_reader,
 						public_gateway: ipfs_public_gateway
 					),
-					http_reader:  http_reader,
-					https_reader: https_reader
+					http_reader: http_reader, https_reader: https_reader, cache: cache,
+					environment_reader: environment_reader, max_depth: max_depth
 				)
 			end
 		end
 
 		class LocalOnly < Standard
-			def initialize(path_reader: ReadPathSources)
+			def initialize(
+				path_reader: ReadPathSources,
+				environment_reader: ReadEnvironmentSources,
+				max_depth: 50
+			)
 				super(
-					path_reader:  path_reader,
-					http_reader:  RejectSources,
-					https_reader: RejectSources
+					path_reader:        path_reader,
+					environment_reader: environment_reader,
+					http_reader:        RejectSources,
+					https_reader:       RejectSources,
+					max_depth:          max_depth
 				)
 			end
 		end
@@ -260,9 +387,10 @@ module Dhall
 		class None < Default
 			def initialize
 				super(
-					path_reader:  RejectSources,
-					http_reader:  RejectSources,
-					https_reader: RejectSources
+					path_reader:        RejectSources,
+					environment_reader: RejectSources,
+					http_reader:        RejectSources,
+					https_reader:       RejectSources
 				)
 			end
 		end
@@ -291,9 +419,25 @@ module Dhall
 			).then { |h| @expr.with(h) }
 		end
 
+		class ImportAsLocationResolver < ExpressionResolver
+			def resolve(resolver:, relative_to:)
+				Promise.resolve(nil).then do
+					@expr.real_path(relative_to).location
+				end
+			end
+		end
+
 		class ImportResolver < ExpressionResolver
 			register_for Import
 
+			def self.new(expr)
+				if expr.import_type == Import::AsLocation
+					ImportAsLocationResolver.new(expr)
+				else
+					super
+				end
+			end
+
 			def resolve(resolver:, relative_to:)
 				Promise.resolve(nil).then do
 					resolver.cache_fetch(@expr.cache_key(relative_to)) do
@@ -305,7 +449,9 @@ module Dhall
 			def resolve_raw(resolver:, relative_to:)
 				real_path = @expr.real_path(relative_to)
 				real_path.resolve(resolver).then do |result|
-					@expr.parse_and_check(result).resolve(
+					@expr.parse_resolve_check(
+						result,
+						deadline:    resolver.deadline,
 						resolver:    resolver.child(real_path),
 						relative_to: real_path
 					)
@@ -316,9 +462,15 @@ module Dhall
 		class FallbackResolver < ExpressionResolver
 			register_for Operator::ImportFallback
 
-			def resolve(**kwargs)
-				ExpressionResolver.for(@expr.lhs).resolve(**kwargs).catch do
-					ExpressionResolver.for(@expr.rhs).resolve(**kwargs)
+			def resolve(resolver:, relative_to:)
+				ExpressionResolver.for(@expr.lhs).resolve(
+					resolver:    resolver,
+					relative_to: relative_to
+				).catch do
+					@expr.rhs.resolve(
+						resolver:    resolver.child(Import::MissingImport.new),
+						relative_to: relative_to
+					)
 				end
 			end
 		end

data/lib/dhall/typecheck.rb

@@ -12,7 +12,7 @@ module Dhall
 
 		def self.assert_type(expr, assertion, message, context:)
 			aexpr = self.for(expr).annotate(context)
-			type = aexpr.type
+			type = aexpr.type.normalize
 			raise TypeError, "#{message}: #{type}" unless assertion === type
 			aexpr
 		end
@@ -20,7 +20,9 @@ module Dhall
 		def self.assert_types_match(a, b, message, context:)
 			atype = self.for(a).annotate(context).type
 			btype = self.for(b).annotate(context).type
-			raise TypeError, "#{message}: #{atype}, #{btype}" unless atype == btype
+			unless atype.normalize == btype.normalize
+				raise TypeError, "#{message}: #{atype}, #{btype}"
+			end
 			atype
 		end
 
@@ -40,9 +42,13 @@ module Dhall
 			@typecheckers[node_type] ||= [typechecker, extras]
 		end
 
-		def self.type_of(expr)
+		def self.annotate(expr)
 			return if expr.nil?
-			TypeChecker.for(expr).annotate(TypeChecker::Context.new).type
+			TypeChecker.for(expr).annotate(TypeChecker::Context.new)
+		end
+
+		def self.type_of(expr)
+			annotate(expr)&.type
 		end
 
 		class Context
@@ -72,9 +78,9 @@ module Dhall
 		end
 
 		KINDS = [
-			Dhall::Variable["Type"],
-			Dhall::Variable["Kind"],
-			Dhall::Variable["Sort"]
+			Builtins[:Type],
+			Builtins[:Kind],
+			Builtins[:Sort]
 		].freeze
 
 		class Variable
@@ -84,38 +90,12 @@ module Dhall
 				@var = var
 			end
 
-			BUILTIN = {
-				"Type"     => Dhall::Variable["Kind"],
-				"Kind"     => Dhall::Variable["Sort"],
-				"Bool"     => Dhall::Variable["Type"],
-				"Natural"  => Dhall::Variable["Type"],
-				"Integer"  => Dhall::Variable["Type"],
-				"Double"   => Dhall::Variable["Type"],
-				"Text"     => Dhall::Variable["Type"],
-				"List"     => Dhall::Forall.of_arguments(
-					Dhall::Variable["Type"],
-					body: Dhall::Variable["Type"]
-				),
-				"Optional" => Dhall::Forall.of_arguments(
-					Dhall::Variable["Type"],
-					body: Dhall::Variable["Type"]
-				),
-				"None"     => Dhall::Forall.new(
-					var:  "A",
-					type: Dhall::Variable["Type"],
-					body: Dhall::Application.new(
-						function: Dhall::Variable["Optional"],
-						argument: Dhall::Variable["A"]
-					)
-				)
-			}.freeze
-
 			def annotate(context)
 				raise TypeError, "Sort has no Type, Kind, or Sort" if @var.name == "Sort"
 
 				Dhall::TypeAnnotation.new(
 					value: @var,
-					type:  BUILTIN.fetch(@var.name) { context.fetch(@var) }
+					type:  context.fetch(@var)
 				)
 			end
 		end
@@ -130,6 +110,7 @@ module Dhall
 			def initialize(lit)
 				@lit = lit
 				@type = Dhall::Variable[lit.class.name.split(/::/).last]
+				@type = Builtins[@type.name.to_sym] || @type
 			end
 
 			def annotate(*)
@@ -170,14 +151,14 @@ module Dhall
 			def annotate(context)
 				chunks = Chunks.new(@lit.chunks).map { |c|
 					TypeChecker.for(c).annotate(context).tap do |annotated|
-						TypeChecker.assert annotated.type, Dhall::Variable["Text"],
+						TypeChecker.assert annotated.type, Builtins[:Text],
 						                   "Cannot interpolate #{annotated.type}"
 					end
 				}.to_a
 
 				Dhall::TypeAnnotation.new(
 					value: @lit.with(chunks: chunks),
-					type:  Dhall::Variable["Text"]
+					type:  Builtins[:Text]
 				)
 			end
 		end
@@ -194,9 +175,9 @@ module Dhall
 
 			class AnnotatedIf
 				def initialize(expr, apred, athen, aelse, context:)
-					TypeChecker.assert apred.type, Dhall::Variable["Bool"],
+					TypeChecker.assert apred.type, Builtins[:Bool],
 					                   "If must have a predicate of type Bool"
-					TypeChecker.assert_type athen.type, Dhall::Variable["Type"],
+					TypeChecker.assert_type athen.type, Builtins[:Type],
 					                        "If branches must have types of type Type",
 					                        context: context
 					TypeChecker.assert aelse.type, athen.type,
@@ -225,13 +206,13 @@ module Dhall
 
 		class Operator
 			{
-				Dhall::Operator::And             => Dhall::Variable["Bool"],
-				Dhall::Operator::Or              => Dhall::Variable["Bool"],
-				Dhall::Operator::Equal           => Dhall::Variable["Bool"],
-				Dhall::Operator::NotEqual        => Dhall::Variable["Bool"],
-				Dhall::Operator::Plus            => Dhall::Variable["Natural"],
-				Dhall::Operator::Times           => Dhall::Variable["Natural"],
-				Dhall::Operator::TextConcatenate => Dhall::Variable["Text"]
+				Dhall::Operator::And             => Builtins[:Bool],
+				Dhall::Operator::Or              => Builtins[:Bool],
+				Dhall::Operator::Equal           => Builtins[:Bool],
+				Dhall::Operator::NotEqual        => Builtins[:Bool],
+				Dhall::Operator::Plus            => Builtins[:Natural],
+				Dhall::Operator::Times           => Builtins[:Natural],
+				Dhall::Operator::TextConcatenate => Builtins[:Text]
 			}.each do |node_type, type|
 				TypeChecker.register self, node_type, type
 			end
@@ -258,6 +239,31 @@ module Dhall
 			end
 		end
 
+		class OperatorEquivalent
+			TypeChecker.register self, Dhall::Operator::Equivalent
+
+			def initialize(expr)
+				@expr = expr
+				@lhs = expr.lhs
+				@rhs = expr.rhs
+			end
+
+			def annotate(context)
+				type = TypeChecker.assert_types_match @lhs, @rhs,
+				                                      "arguments do not match",
+				                                      context: context
+
+				TypeChecker.assert_type type, Builtins[:Type],
+				                        "arguments are not terms",
+				                        context: context
+
+				Dhall::TypeAnnotation.new(
+					value: @expr.with(lhs: @lhs.annotate(type), rhs: @rhs.annotate(type)),
+					type:  Builtins[:Type]
+				)
+			end
+		end
+
 		class OperatorListConcatenate
 			TypeChecker.register self, Dhall::Operator::ListConcatenate
 
@@ -270,7 +276,7 @@ module Dhall
 			module IsList
 				def self.===(other)
 					other.is_a?(Dhall::Application) &&
-						other.function == Dhall::Variable["List"]
+						other.function == Builtins[:List]
 				end
 			end
 
@@ -334,10 +340,6 @@ module Dhall
 				                                        "RecursiveRecordMerge got",
 				                                        context: context
 
-				TypeChecker.assert_types_match annotated_lhs.type, annotated_rhs.type,
-				                               "RecursiveRecordMerge got mixed kinds",
-				                               context: context
-
 				[annotated_lhs, annotated_rhs]
 			end
 
@@ -361,12 +363,6 @@ module Dhall
 			end
 
 			def annotate(context)
-				kind = TypeChecker.assert_types_match(
-					@expr.lhs, @expr.rhs,
-					"RecursiveRecordTypeMerge mixed kinds",
-					context: context
-				)
-
 				type = @expr.lhs.deep_merge_type(@expr.rhs)
 
 				TypeChecker.assert type, Dhall::RecordType,
@@ -375,7 +371,13 @@ module Dhall
 				# Annotate to sanity check
 				TypeChecker.for(type).annotate(context)
 
-				Dhall::TypeAnnotation.new(value: @expr, type: kind)
+				Dhall::TypeAnnotation.new(value: @expr, type: kind(context))
+			end
+
+			def kind(context)
+				lhs_kind = KINDS.index(TypeChecker.for(@expr.lhs).annotate(context).type)
+				rhs_kind = KINDS.index(TypeChecker.for(@expr.rhs).annotate(context).type)
+				KINDS[[lhs_kind, rhs_kind].max]
 			end
 		end
 
@@ -383,11 +385,17 @@ module Dhall
 			TypeChecker.register self, Dhall::EmptyList
 
 			def initialize(expr)
-				@expr = expr
+				@expr = expr.with(type: expr.type.normalize)
 			end
 
 			def annotate(context)
-				TypeChecker.assert_type @expr.element_type, Dhall::Variable["Type"],
+				TypeChecker.assert @expr.type, Dhall::Application,
+				                   "EmptyList unknown type #{@expr.type.inspect}"
+
+				TypeChecker.assert @expr.type.function, Builtins[:List],
+				                   "EmptyList unknown type #{@expr.type.inspect}"
+
+				TypeChecker.assert_type @expr.element_type, Builtins[:Type],
 				                        "EmptyList element type not of type Type",
 				                        context: context
 
@@ -408,16 +416,16 @@ module Dhall
 				end
 
 				def annotation
-					list = @alist.with(element_type: element_type)
+					list = @alist.with(type: Builtins[:List].call(element_type))
 					Dhall::TypeAnnotation.new(type: list.type, value: list)
 				end
 
 				def element_type
-					@alist.first.value&.type || @alist.element_type
+					(@alist.first.value&.type || @alist.element_type).normalize
 				end
 
 				def element_types
-					@alist.to_a.map(&:type)
+					@alist.to_a.map(&:type).map(&:normalize)
 				end
 			end
 
@@ -430,7 +438,7 @@ module Dhall
 				                   Util::ArrayOf.new(alist.element_type),
 				                   "Non-homogenous List"
 
-				TypeChecker.assert_type alist.element_type, Dhall::Variable["Type"],
+				TypeChecker.assert_type alist.element_type, Builtins[:Type],
 				                        "List type not of type Type", context: context
 
 				alist.annotation
@@ -447,7 +455,7 @@ module Dhall
 			def annotate(context)
 				TypeChecker.assert(
 					TypeChecker.for(@expr.value_type).annotate(context).type,
-					Dhall::Variable["Type"],
+					Builtins[:Type],
 					"OptionalNone element type not of type Type"
 				)
 
@@ -469,7 +477,7 @@ module Dhall
 				some = asome.with(value_type: asome.value.type)
 
 				type_type = TypeChecker.for(some.value_type).annotate(context).type
-				TypeChecker.assert type_type, Dhall::Variable["Type"],
+				TypeChecker.assert type_type, Builtins[:Type],
 				                   "Some type not of type Type, was: #{type_type}"
 
 				Dhall::TypeAnnotation.new(type: some.type, value: some)
@@ -486,20 +494,27 @@ module Dhall
 			def annotate(*)
 				Dhall::TypeAnnotation.new(
 					value: @expr,
-					type:  Dhall::Variable["Type"]
+					type:  Builtins[:Type]
 				)
 			end
 		end
 
 		class AnonymousType
 			TypeChecker.register self, Dhall::RecordType
-			TypeChecker.register self, Dhall::UnionType
 
 			def initialize(type)
 				@type = type
 			end
 
 			def annotate(context)
+				kinds = check(context)
+				type = kinds.max_by { |k| KINDS.index(k) } || KINDS.first
+				Dhall::TypeAnnotation.new(value: @type, type: type)
+			end
+
+			protected
+
+			def check(context)
 				kinds = @type.record.values.compact.map do |mtype|
 					TypeChecker.for(mtype).annotate(context).type
 				end
@@ -507,6 +522,16 @@ module Dhall
 				TypeChecker.assert (kinds - KINDS), [],
 				                   "AnonymousType field kind not one of #{KINDS}"
 
+				kinds
+			end
+		end
+
+		class UnionType < AnonymousType
+			TypeChecker.register self, Dhall::UnionType
+
+			def annotate(context)
+				kinds = check(context)
+
 				TypeChecker.assert kinds, Util::ArrayAllTheSame,
 				                   "AnonymousType field kinds not all the same"
 
@@ -562,12 +587,13 @@ module Dhall
 
 			class Selector
 				def self.for(annotated_record)
-					if annotated_record.type == Dhall::Variable["Type"]
+					typ = annotated_record.type.normalize
+					if KINDS.include?(typ)
 						TypeSelector.new(annotated_record.value)
-					elsif annotated_record.type.class == Dhall::RecordType
-						new(annotated_record.type)
+					elsif typ.class == Dhall::RecordType
+						new(typ)
 					else
-						raise TypeError, "RecordSelection on #{annotated_record.type}"
+						raise TypeError, "RecordSelection on #{typ}"
 					end
 				end
 
@@ -629,6 +655,52 @@ module Dhall
 			end
 		end
 
+		class RecordProjectionByExpression
+			TypeChecker.register self, Dhall::RecordProjectionByExpression
+
+			def initialize(projection)
+				@selector = projection.selector.normalize
+				@project_by_expression = projection
+				@project_by_keys = Dhall::RecordProjection.for(
+					@project_by_expression.record,
+					@selector.keys
+				)
+			end
+
+			def annotate(context)
+				TypeChecker.assert @selector, Dhall::RecordType,
+				                   "RecordProjectionByExpression on #{@selector.class}"
+
+				TypeChecker.assert_type @project_by_keys, @selector,
+				                        "Type doesn't match #{@selector}",
+				                        context: context
+
+				Dhall::TypeAnnotation.new(
+					value: @project_by_expression,
+					type:  @selector
+				)
+			end
+		end
+
+		class Enum
+			TypeChecker.register self, Dhall::Enum
+
+			def initialize(enum)
+				@enum = enum
+			end
+
+			def annotate(context)
+				type = Dhall::UnionType.new(
+					alternatives: { @enum.tag => nil }
+				).merge(@enum.alternatives)
+
+				# Annotate to sanity check
+				TypeChecker.for(type).annotate(context)
+
+				Dhall::TypeAnnotation.new(value: @enum, type: type)
+			end
+		end
+
 		class Union
 			TypeChecker.register self, Dhall::Union
 
@@ -654,6 +726,39 @@ module Dhall
 			end
 		end
 
+		class ToMap
+			TypeChecker.register self, Dhall::ToMap
+
+			def initialize(tomap)
+				@tomap = tomap
+				@record = TypeChecker.for(tomap.record)
+			end
+
+			def check_annotation(record_type)
+				if record_type.is_a?(Dhall::EmptyRecordType)
+					TypeChecker.assert @tomap.type, Dhall::Expression,
+					                   "toMap {=} has no annotation"
+				else
+					t = Types::MAP(v: record_type.record.values.first)
+
+					TypeChecker.assert t, (@tomap.type || t),
+					                   "toMap does not match annotation"
+				end
+			end
+
+			def annotate(context)
+				record_type = @record.annotate(context).type
+				TypeChecker.assert record_type, Dhall::RecordType,
+				                   "toMap on a non-record: #{record_type.inspect}"
+
+				TypeChecker.assert record_type.record.values, Util::ArrayAllTheSame,
+				                   "toMap heterogenous: #{record_type.inspect}"
+
+				type = check_annotation(record_type)
+				Dhall::TypeAnnotation.new(value: @tomap, type: type)
+			end
+		end
+
 		class Merge
 			TypeChecker.register self, Dhall::Merge
 
@@ -684,7 +789,7 @@ module Dhall
 				end
 
 				def keys
-					@type.record.keys
+					Set.new(@type.record.keys)
 				end
 
 				def fetch_input_type(k)
@@ -727,7 +832,7 @@ module Dhall
 
 					TypeChecker.assert(
 						kind,
-						Dhall::Variable["Type"],
+						Builtins[:Type],
 						"Merge must have kind Type"
 					)
 
@@ -735,8 +840,8 @@ module Dhall
 				end
 
 				def assert_union_and_handlers_match
-					extras = @handlers.keys - @union.type.alternatives.keys
-					TypeChecker.assert extras, [],
+					extras = @handlers.keys ^ @union.type.alternatives.keys
+					TypeChecker.assert extras.to_a, [],
 					                   "Merge handlers unknown alternatives: #{extras}"
 
 					@union.type.alternatives.each do |k, atype|
@@ -777,8 +882,6 @@ module Dhall
 						raise TypeError, "FunctionType part of this is a term"
 					end
 
-					raise TypeError, "Dependent types are not allowed" if outkind > inkind
-
 					if outkind.zero?
 						Term.new
 					else
@@ -866,8 +969,6 @@ module Dhall
 			end
 		end
 
-		TypeChecker.register ->(blk) { LetIn.for(blk.unflatten) }, Dhall::LetBlock
-
 		class LetIn
 			TypeChecker.register self, Dhall::LetIn
 
@@ -933,11 +1034,58 @@ module Dhall
 			end
 		end
 
+		class Assertion
+			TypeChecker.register self, Dhall::Assertion
+
+			def initialize(expr)
+				@expr = expr
+				@type = expr.type
+			end
+
+			def annotate(context)
+				TypeChecker.assert @type, Dhall::Operator::Equivalent,
+				                   "assert expected === got: #{@type.class}"
+
+				TypeChecker.assert_type @type, Builtins[:Type],
+				                        "=== expected to have type Type",
+				                        context: context
+
+				TypeChecker.assert @type.lhs.normalize.to_binary,
+				                   @type.rhs.normalize.to_binary,
+				                   "assert equivalence not equivalent"
+
+				@expr.with(type: @type.normalize)
+			end
+		end
+
 		BUILTIN_TYPES = {
+			"Bool"              => Builtins[:Type],
+			"Type"              => Builtins[:Kind],
+			"Kind"              => Builtins[:Sort],
+			"Natural"           => Builtins[:Type],
+			"Integer"           => Builtins[:Type],
+			"Double"            => Builtins[:Type],
+			"Text"              => Builtins[:Type],
+			"List"              => Dhall::Forall.of_arguments(
+				Builtins[:Type],
+				body: Builtins[:Type]
+			),
+			"Optional"          => Dhall::Forall.of_arguments(
+				Builtins[:Type],
+				body: Builtins[:Type]
+			),
+			"None"              => Dhall::Forall.new(
+				var:  "A",
+				type: Builtins[:Type],
+				body: Dhall::Application.new(
+					function: Builtins[:Optional],
+					argument: Dhall::Variable["A"]
+				)
+			),
 			"Natural/build"     => Dhall::Forall.of_arguments(
 				Dhall::Forall.new(
 					var:  "natural",
-					type: Dhall::Variable["Type"],
+					type: Builtins[:Type],
 					body: Dhall::Forall.new(
 						var:  "succ",
 						type: Dhall::Forall.of_arguments(
@@ -951,13 +1099,13 @@ module Dhall
 						)
 					)
 				),
-				body: Dhall::Variable["Natural"]
+				body: Builtins[:Natural]
 			),
 			"Natural/fold"      => Dhall::Forall.of_arguments(
-				Dhall::Variable["Natural"],
+				Builtins[:Natural],
 				body: Dhall::Forall.new(
 					var:  "natural",
-					type: Dhall::Variable["Type"],
+					type: Builtins[:Type],
 					body: Dhall::Forall.new(
 						var:  "succ",
 						type: Dhall::Forall.of_arguments(
@@ -972,37 +1120,42 @@ module Dhall
 					)
 				)
 			),
+			"Natural/subtract"  => Dhall::Forall.of_arguments(
+				Builtins[:Natural],
+				Builtins[:Natural],
+				body: Builtins[:Natural]
+			),
 			"Natural/isZero"    => Dhall::Forall.of_arguments(
-				Dhall::Variable["Natural"],
-				body: Dhall::Variable["Bool"]
+				Builtins[:Natural],
+				body: Builtins[:Bool]
 			),
 			"Natural/even"      => Dhall::Forall.of_arguments(
-				Dhall::Variable["Natural"],
-				body: Dhall::Variable["Bool"]
+				Builtins[:Natural],
+				body: Builtins[:Bool]
 			),
 			"Natural/odd"       => Dhall::Forall.of_arguments(
-				Dhall::Variable["Natural"],
-				body: Dhall::Variable["Bool"]
+				Builtins[:Natural],
+				body: Builtins[:Bool]
 			),
 			"Natural/toInteger" => Dhall::Forall.of_arguments(
-				Dhall::Variable["Natural"],
-				body: Dhall::Variable["Integer"]
+				Builtins[:Natural],
+				body: Builtins[:Integer]
 			),
 			"Natural/show"      => Dhall::Forall.of_arguments(
-				Dhall::Variable["Natural"],
-				body: Dhall::Variable["Text"]
+				Builtins[:Natural],
+				body: Builtins[:Text]
 			),
 			"Text/show"         => Dhall::Forall.of_arguments(
-				Dhall::Variable["Text"],
-				body: Dhall::Variable["Text"]
+				Builtins[:Text],
+				body: Builtins[:Text]
 			),
 			"List/build"        => Dhall::Forall.new(
 				var:  "a",
-				type: Dhall::Variable["Type"],
+				type: Builtins[:Type],
 				body: Dhall::Forall.of_arguments(
 					Dhall::Forall.new(
 						var:  "list",
-						type: Dhall::Variable["Type"],
+						type: Builtins[:Type],
 						body: Dhall::Forall.new(
 							var:  "cons",
 							type: Dhall::Forall.of_arguments(
@@ -1018,22 +1171,22 @@ module Dhall
 						)
 					),
 					body: Dhall::Application.new(
-						function: Dhall::Variable["List"],
+						function: Builtins[:List],
 						argument: Dhall::Variable["a"]
 					)
 				)
 			),
 			"List/fold"         => Dhall::Forall.new(
 				var:  "a",
-				type: Dhall::Variable["Type"],
+				type: Builtins[:Type],
 				body: Dhall::Forall.of_arguments(
 					Dhall::Application.new(
-						function: Dhall::Variable["List"],
+						function: Builtins[:List],
 						argument: Dhall::Variable["a"]
 					),
 					body: Dhall::Forall.new(
 						var:  "list",
-						type: Dhall::Variable["Type"],
+						type: Builtins[:Type],
 						body: Dhall::Forall.new(
 							var:  "cons",
 							type: Dhall::Forall.of_arguments(
@@ -1052,56 +1205,56 @@ module Dhall
 			),
 			"List/length"       => Dhall::Forall.new(
 				var:  "a",
-				type: Dhall::Variable["Type"],
+				type: Builtins[:Type],
 				body: Dhall::Forall.of_arguments(
 					Dhall::Application.new(
-						function: Dhall::Variable["List"],
+						function: Builtins[:List],
 						argument: Dhall::Variable["a"]
 					),
-					body: Dhall::Variable["Natural"]
+					body: Builtins[:Natural]
 				)
 			),
 			"List/head"         => Dhall::Forall.new(
 				var:  "a",
-				type: Dhall::Variable["Type"],
+				type: Builtins[:Type],
 				body: Dhall::Forall.of_arguments(
 					Dhall::Application.new(
-						function: Dhall::Variable["List"],
+						function: Builtins[:List],
 						argument: Dhall::Variable["a"]
 					),
 					body: Dhall::Application.new(
-						function: Dhall::Variable["Optional"],
+						function: Builtins[:Optional],
 						argument: Dhall::Variable["a"]
 					)
 				)
 			),
 			"List/last"         => Dhall::Forall.new(
 				var:  "a",
-				type: Dhall::Variable["Type"],
+				type: Builtins[:Type],
 				body: Dhall::Forall.of_arguments(
 					Dhall::Application.new(
-						function: Dhall::Variable["List"],
+						function: Builtins[:List],
 						argument: Dhall::Variable["a"]
 					),
 					body: Dhall::Application.new(
-						function: Dhall::Variable["Optional"],
+						function: Builtins[:Optional],
 						argument: Dhall::Variable["a"]
 					)
 				)
 			),
 			"List/indexed"      => Dhall::Forall.new(
 				var:  "a",
-				type: Dhall::Variable["Type"],
+				type: Builtins[:Type],
 				body: Dhall::Forall.of_arguments(
 					Dhall::Application.new(
-						function: Dhall::Variable["List"],
+						function: Builtins[:List],
 						argument: Dhall::Variable["a"]
 					),
 					body: Dhall::Application.new(
-						function: Dhall::Variable["List"],
+						function: Builtins[:List],
 						argument: Dhall::RecordType.new(
 							record: {
-								"index" => Dhall::Variable["Natural"],
+								"index" => Builtins[:Natural],
 								"value" => Dhall::Variable["a"]
 							}
 						)
@@ -1110,29 +1263,29 @@ module Dhall
 			),
 			"List/reverse"      => Dhall::Forall.new(
 				var:  "a",
-				type: Dhall::Variable["Type"],
+				type: Builtins[:Type],
 				body: Dhall::Forall.of_arguments(
 					Dhall::Application.new(
-						function: Dhall::Variable["List"],
+						function: Builtins[:List],
 						argument: Dhall::Variable["a"]
 					),
 					body: Dhall::Application.new(
-						function: Dhall::Variable["List"],
+						function: Builtins[:List],
 						argument: Dhall::Variable["a"]
 					)
 				)
 			),
 			"Optional/fold"     => Dhall::Forall.new(
 				var:  "a",
-				type: Dhall::Variable["Type"],
+				type: Builtins[:Type],
 				body: Dhall::Forall.of_arguments(
 					Dhall::Application.new(
-						function: Dhall::Variable["Optional"],
+						function: Builtins[:Optional],
 						argument: Dhall::Variable["a"]
 					),
 					body: Dhall::Forall.new(
 						var:  "optional",
-						type: Dhall::Variable["Type"],
+						type: Builtins[:Type],
 						body: Dhall::Forall.new(
 							var:  "just",
 							type: Dhall::Forall.of_arguments(
@@ -1150,11 +1303,11 @@ module Dhall
 			),
 			"Optional/build"    => Dhall::Forall.new(
 				var:  "a",
-				type: Dhall::Variable["Type"],
+				type: Builtins[:Type],
 				body: Dhall::Forall.of_arguments(
 					Dhall::Forall.new(
 						var:  "optional",
-						type: Dhall::Variable["Type"],
+						type: Builtins[:Type],
 						body: Dhall::Forall.new(
 							var:  "just",
 							type: Dhall::Forall.of_arguments(
@@ -1169,28 +1322,38 @@ module Dhall
 						)
 					),
 					body: Dhall::Application.new(
-						function: Dhall::Variable["Optional"],
+						function: Builtins[:Optional],
 						argument: Dhall::Variable["a"]
 					)
 				)
 			),
 			"Integer/show"      => Dhall::Forall.of_arguments(
-				Dhall::Variable["Integer"],
-				body: Dhall::Variable["Text"]
+				Builtins[:Integer],
+				body: Builtins[:Text]
 			),
 			"Integer/toDouble"  => Dhall::Forall.of_arguments(
-				Dhall::Variable["Integer"],
-				body: Dhall::Variable["Double"]
+				Builtins[:Integer],
+				body: Builtins[:Double]
 			),
 			"Double/show"       => Dhall::Forall.of_arguments(
-				Dhall::Variable["Double"],
-				body: Dhall::Variable["Text"]
+				Builtins[:Double],
+				body: Builtins[:Text]
 			)
 		}.freeze
 
 		class Builtin
 			TypeChecker.register self, Dhall::Builtin
 
+			def self.for(builtin)
+				if builtin.is_a?(Dhall::BuiltinFunction)
+					if (unfilled = builtin.unfill) != builtin
+						return TypeChecker.for(unfilled)
+					end
+				end
+
+				new(builtin)
+			end
+
 			def initialize(builtin)
 				@expr = builtin
 				@name = builtin.as_json