dhall 0.1.0 → 0.5.1

data/lib/dhall/ast.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require "base32"
+require "lazy_object"
+require "multihashes"
 require "uri"
 require "value_semantics"
 
@@ -33,18 +36,13 @@ module Dhall
 		end
 
 		def *(other)
-			case other
-			when Natural
+			if other.is_a?(Natural) && other.zero?
 				other * self
 			else
 				Operator::Times.new(lhs: self, rhs: other)
 			end
 		end
 
-		def <<(other)
-			Operator::TextConcatenate.new(lhs: self, rhs: other)
-		end
-
 		def concat(other)
 			Operator::ListConcatenate.new(lhs: self, rhs: other)
 		end
@@ -72,7 +70,7 @@ module Dhall
 		def dhall_eq(other)
 			if self == other
 				Bool.new(value: true)
-			elsif other.is_a?(Bool)
+			elsif other == Bool.new(value: true)
 				other.dhall_eq(self)
 			else
 				Operator::Equal.new(lhs: self, rhs: other)
@@ -106,6 +104,14 @@ module Dhall
 			end
 		end
 
+		def annotate(type)
+			TypeAnnotation.new(value: self, type: type)
+		end
+
+		def to_s
+			inspect
+		end
+
 		def as_dhall
 			self
 		end
@@ -118,9 +124,7 @@ module Dhall
 		end)
 
 		def self.for(function:, argument:)
-			if function == Variable["Some"]
-				Optional.new(value: argument)
-			elsif function == Variable["None"]
+			if function == Builtins[:None]
 				OptionalNone.new(value_type: argument)
 			else
 				new(function: function, argument: argument)
@@ -130,7 +134,7 @@ module Dhall
 		def flatten
 			f, args = if function.is_a?(Application)
 				function.flatten
-			elsif function.is_a?(Builtin) &&
+			elsif function.is_a?(BuiltinFunction) &&
 			      (unfilled = function.unfill).is_a?(Application)
 				unfilled.flatten
 			else
@@ -148,7 +152,7 @@ module Dhall
 
 	class Function < Expression
 		include(ValueSemantics.for_attributes do
-			var  Util::AllOf.new(::String, Util::Not.new(Util::BuiltinName))
+			var  ::String
 			type Either(nil, Expression) # nil is not allowed in proper Dhall
 			body Expression
 		end)
@@ -163,7 +167,8 @@ module Dhall
 			end
 		end
 
-		def call(*args)
+		def call(*args, &block)
+			args += [block] if block
 			args.map! { |arg| arg&.as_dhall }
 			return super if args.length > 1
 
@@ -174,6 +179,29 @@ module Dhall
 		end
 
 		alias [] call
+		alias === call
+
+		def <<(other)
+			FunctionProxy.new(
+				->(*args, &block) { call(other.call(*args, &block)) },
+				curry: false
+			)
+		end
+
+		def >>(other)
+			FunctionProxy.new(
+				->(*args, &block) { other.call(call(*args, &block)) },
+				curry: false
+			)
+		end
+
+		def binding
+			to_proc.binding
+		end
+
+		def curry
+			self
+		end
 
 		def as_json
 			if var == "_"
@@ -194,6 +222,56 @@ module Dhall
 		end
 	end
 
+	class RubyObjectRaw < Expression
+		def initialize(object)
+			@object = object
+		end
+
+		def unwrap
+			@object
+		end
+
+		def respond_to_missing?(m)
+			super || @object.respond_to?(m)
+		end
+
+		def method_missing(m, *args, &block)
+			if @object.respond_to?(m)
+				@object.public_send(m, *args, &block)
+			else
+				super
+			end
+		end
+	end
+
+	class FunctionProxyRaw < Function
+		def initialize(callable, curry: true)
+			@callable = if !curry
+				callable
+			elsif callable.respond_to?(:curry)
+				callable.curry
+			elsif callable.respond_to?(:to_proc)
+				callable.to_proc.curry
+			else
+				callable.method(:call).to_proc.curry
+			end
+		end
+
+		def call(*args, &block)
+			RubyObjectRaw.new(@callable.call(*args.map { |arg| arg&.as_dhall }, &block))
+		end
+
+		def as_json
+			raise "Cannot serialize #{self}"
+		end
+	end
+
+	class FunctionProxy < FunctionProxyRaw
+		def call(*args, &block)
+			super.unwrap.as_dhall
+		end
+	end
+
 	class Bool < Expression
 		include(ValueSemantics.for_attributes do
 			value Bool()
@@ -234,6 +312,10 @@ module Dhall
 		def as_json
 			value
 		end
+
+		def self.as_dhall
+			Builtins[:Bool]
+		end
 	end
 
 	class Variable < Expression
@@ -253,8 +335,6 @@ module Dhall
 		def as_json
 			if name == "_"
 				index
-			elsif index.zero?
-				name
 			else
 				[name, index]
 			end
@@ -271,6 +351,33 @@ module Dhall
 			[3, OPERATORS.index(self.class), lhs.as_json, rhs.as_json]
 		end
 
+		module FetchFromMerge
+			def fetch_second_record(first, second, selector)
+				rec = self.class.new(
+					self.class::FETCH2K => second.slice(selector),
+					self.class::FETCH1K => first
+				).normalize
+
+				if rec.class == self.class
+					RecordSelection.new(record: rec, selector: selector)
+				else
+					rec.fetch(selector)
+				end
+			end
+
+			def fetch(selector)
+				first = public_send(self.class::FETCH1K)
+				second = public_send(self.class::FETCH2K)
+				if first.is_a?(Record)
+					first.fetch(selector) { second.fetch(selector) }
+				elsif second.is_a?(Record)
+					fetch_second_record(first, second, selector)
+				else
+					super
+				end
+			end
+		end
+
 		class Or < Operator; end
 		class And < Operator; end
 		class Equal < Operator; end
@@ -279,17 +386,27 @@ module Dhall
 		class Times < Operator; end
 		class TextConcatenate < Operator; end
 		class ListConcatenate < Operator; end
-		class RecursiveRecordMerge < Operator; end
-		class RightBiasedRecordMerge < Operator; end
+		class RecursiveRecordMerge < Operator
+			FETCH1K = :lhs
+			FETCH2K = :rhs
+			include FetchFromMerge
+		end
+		class RightBiasedRecordMerge < Operator
+			FETCH1K = :rhs
+			FETCH2K = :lhs
+			include FetchFromMerge
+		end
 		class RecursiveRecordTypeMerge < Operator; end
 		class ImportFallback < Operator; end
+		class Equivalent < Operator; end
 
 		OPERATORS = [
 			Or, And, Equal, NotEqual,
 			Plus, Times,
 			TextConcatenate, ListConcatenate,
 			RecursiveRecordMerge, RightBiasedRecordMerge, RecursiveRecordTypeMerge,
-			ImportFallback
+			ImportFallback,
+			Equivalent
 		].freeze
 	end
 
@@ -298,9 +415,18 @@ module Dhall
 
 		include(ValueSemantics.for_attributes do
 			elements     Util::ArrayOf.new(Expression, min: 1)
-			element_type Either(nil, Expression), default: nil
+			type         Either(nil, Expression), default: nil
 		end)
 
+		def initialize(attrs)
+			if attrs.key?(:element_type)
+				et = attrs.delete(:element_type)
+				attrs[:type] = self.class.as_dhall.call(et) if et
+			end
+
+			super
+		end
+
 		def self.of(*args, type: nil)
 			if args.empty?
 				EmptyList.new(element_type: type)
@@ -309,11 +435,17 @@ module Dhall
 			end
 		end
 
-		def type
-			Dhall::Application.new(
-				function: Dhall::Variable["List"],
-				argument: element_type
-			)
+		def self.as_dhall
+			Builtins[:List]
+		end
+
+		def element_type
+			if type.nil?
+			elsif type.is_a?(Application) && type.function == Builtins[:List]
+				type.argument
+			else
+				raise "Cannot get element_type of: #{type.inspect}"
+			end
 		end
 
 		def as_json
@@ -321,7 +453,11 @@ module Dhall
 		end
 
 		def map(type: nil, &block)
-			with(elements: elements.each_with_index.map(&block), element_type: type)
+			type = type.nil? ? nil : Builtins[:List].call(type.as_dhall)
+			with(
+				elements: elements.each_with_index.map(&block),
+				type:     type
+			)
 		end
 
 		def each(&block)
@@ -368,11 +504,22 @@ module Dhall
 
 	class EmptyList < List
 		include(ValueSemantics.for_attributes do
-			element_type Either(nil, Expression)
+			type Either(nil, Expression)
 		end)
 
+		def initialize(attrs)
+			if attrs.key?(:element_type)
+				et = attrs.delete(:element_type)
+				attrs[:type] = self.class.as_dhall.call(et) if et
+			end
+
+			super
+		end
+
 		def as_json
 			[4, element_type.as_json]
+		rescue
+			[28, type.as_json]
 		end
 
 		def map(type: nil)
@@ -407,6 +554,10 @@ module Dhall
 			self
 		end
 
+		def join(*)
+			""
+		end
+
 		def concat(other)
 			other
 		end
@@ -426,6 +577,10 @@ module Dhall
 			end
 		end
 
+		def self.as_dhall
+			Builtins[:Natural]
+		end
+
 		def initialize(normalized: false, **attrs)
 			@normalized = normalized
 			super(**attrs)
@@ -435,7 +590,7 @@ module Dhall
 			return unless value_type
 
 			Dhall::Application.new(
-				function: Dhall::Variable["Optional"],
+				function: Builtins[:Optional],
 				argument: value_type
 			)
 		end
@@ -462,6 +617,10 @@ module Dhall
 			value_type Expression
 		end)
 
+		def self.as_dhall
+			Builtins[:None]
+		end
+
 		def map(type: nil)
 			type.nil? ? self : with(value_type: type)
 		end
@@ -475,7 +634,10 @@ module Dhall
 		end
 
 		def as_json
-			[0, Variable["None"].as_json, value_type.as_json]
+			Application.new(
+				function: self.class.as_dhall,
+				argument: value_type
+			).as_json
 		end
 	end
 
@@ -483,7 +645,7 @@ module Dhall
 		include(ValueSemantics.for_attributes do
 			record Expression
 			input  Expression
-			type   Either(Expression, nil)
+			type   Either(Expression, nil), default: nil
 		end)
 
 		def as_json
@@ -492,6 +654,18 @@ module Dhall
 		end
 	end
 
+	class ToMap < Expression
+		include(ValueSemantics.for_attributes do
+			record Expression
+			type   Either(Expression, nil), default: nil
+		end)
+
+		def as_json
+			[27, record.as_json] +
+				(type.nil? ? [] : [type.as_json])
+		end
+	end
+
 	class RecordType < Expression
 		include(ValueSemantics.for_attributes do
 			record Util::HashOf.new(::String, Expression, min: 1)
@@ -729,11 +903,38 @@ module Dhall
 			selectors Util::ArrayOf.new(::String, min: 1)
 		end)
 
+		def self.for(record, selectors)
+			if selectors.empty?
+				EmptyRecordProjection.new(record: record)
+			else
+				new(record: record, selectors: selectors)
+			end
+		end
+
+		def fetch(selector)
+			record.fetch(selector)
+		end
+
 		def as_json
 			[10, record.as_json, *selectors]
 		end
 	end
 
+	class RecordProjectionByExpression < Expression
+		include(ValueSemantics.for_attributes do
+			record Expression
+			selector Expression
+		end)
+
+		def fetch(selector)
+			record.fetch(selector)
+		end
+
+		def as_json
+			[10, record.as_json, [selector.as_json]]
+		end
+	end
+
 	class EmptyRecordProjection < Expression
 		include(ValueSemantics.for_attributes do
 			record Expression
@@ -750,9 +951,22 @@ module Dhall
 
 	class UnionType < Expression
 		include(ValueSemantics.for_attributes do
-			alternatives Util::HashOf.new(::String, Either(Expression, nil))
+			alternatives Util::HashOf.new(::String, Either(Expression, nil)), default: {}
 		end)
 
+		def empty?
+			alternatives.empty?
+		end
+
+		def [](k)
+			alternatives.fetch(k)
+		end
+
+		def without(*keys)
+			keys.map!(&:to_s)
+			with(alternatives: alternatives.reject { |k, _| keys.include?(k) })
+		end
+
 		def record
 			alternatives
 		end
@@ -765,8 +979,8 @@ module Dhall
 			self == other
 		end
 
-		def merge(other)
-			with(alternatives: alternatives.merge(other.alternatives))
+		def merge(other, &block)
+			with(alternatives: alternatives.merge(other.alternatives, &block))
 		end
 
 		def fetch(k, default=nil)
@@ -780,10 +994,9 @@ module Dhall
 		end
 
 		def get_constructor(selector)
-			var = Util::BuiltinName === selector ? "_" : selector
 			type = alternatives.fetch(selector)
-			body = Union.from(self, selector, Variable[var])
-			Function.new(var: var, type: type, body: body)
+			body = Union.from(self, selector, Variable[selector])
+			Function.new(var: selector, type: type, body: body)
 		end
 
 		def constructor_types
@@ -791,8 +1004,7 @@ module Dhall
 				ctypes[k] = if type.nil?
 					self
 				else
-					var = Util::BuiltinName === k ? "_" : k
-					Forall.new(var: var, type: type, body: self)
+					Forall.new(var: k, type: type, body: self)
 				end
 			end
 		end
@@ -805,31 +1017,28 @@ module Dhall
 	class Union < Expression
 		include(ValueSemantics.for_attributes do
 			tag          ::String
-			value        Either(Expression, nil)
+			value        Expression
 			alternatives UnionType
 		end)
 
 		def self.from(alts, tag, value)
-			new(
-				tag:          tag,
-				value:        value && TypeAnnotation.new(
-					value: value,
-					type:  alts.alternatives[tag]
-				),
-				alternatives: alts.with(
-					alternatives: alts.alternatives.reject { |alt, _| alt == tag }
+			if value.nil?
+				Enum.new(tag: tag, alternatives: alts.without(tag))
+			else
+				new(
+					tag:          tag,
+					value:        TypeAnnotation.new(value: value, type: alts[tag]),
+					alternatives: alts.without(tag)
 				)
-			)
+			end
 		end
 
 		def to_s
-			value.nil? ? tag : extract.to_s
+			extract.to_s
 		end
 
 		def extract
-			if value.nil?
-				tag.to_sym
-			elsif value.is_a?(TypeAnnotation)
+			if value.is_a?(TypeAnnotation)
 				value.value
 			else
 				value
@@ -839,12 +1048,8 @@ module Dhall
 		def reduce(handlers)
 			handlers = handlers.to_h
 			handler = handlers.fetch(tag.to_sym) { handlers.fetch(tag) }
-			if value.nil?
-				handler
-			else
-				(handler.respond_to?(:to_proc) ? handler.to_proc : handler)
-					.call(extract)
-			end
+			(handler.respond_to?(:to_proc) ? handler.to_proc : handler)
+				.call(extract)
 		end
 
 		def selection_syntax
@@ -857,18 +1062,14 @@ module Dhall
 		end
 
 		def syntax
-			if value.nil?
-				selection_syntax
-			else
-				Application.new(
-					function: selection_syntax,
-					argument: value.is_a?(TypeAnnotation) ? value.value : value
-				)
-			end
+			Application.new(
+				function: selection_syntax,
+				argument: value.is_a?(TypeAnnotation) ? value.value : value
+			)
 		end
 
 		def as_json
-			if value.nil? || value.respond_to?(:type)
+			if value.respond_to?(:type)
 				syntax.as_json
 			else
 				[12, tag, value&.as_json, alternatives.as_json.last]
@@ -876,11 +1077,36 @@ module Dhall
 		end
 	end
 
+	class Enum < Union
+		include(ValueSemantics.for_attributes do
+			tag          ::String
+			alternatives UnionType
+		end)
+
+		def reduce(handlers)
+			handlers = handlers.to_h
+			handler = handlers.fetch(tag.to_sym) { handlers.fetch(tag) }
+			handler
+		end
+
+		def to_s
+			tag
+		end
+
+		def extract
+			tag.to_sym
+		end
+
+		def as_json
+			selection_syntax.as_json
+		end
+	end
+
 	class If < Expression
 		include(ValueSemantics.for_attributes do
 			predicate Expression
-			self.then Expression
-			self.else Expression
+			def_attr :then, Expression
+			def_attr :else, Expression
 		end)
 
 		def as_json
@@ -893,6 +1119,10 @@ module Dhall
 			value (0..Float::INFINITY)
 		end)
 
+		def self.as_dhall
+			Builtins[:Natural]
+		end
+
 		def coerce(other)
 			[other.as_dhall, self]
 		end
@@ -954,6 +1184,10 @@ module Dhall
 			value ::Integer
 		end)
 
+		def self.as_dhall
+			Builtins[:Integer]
+		end
+
 		def to_s
 			"#{value >= 0 ? "+" : ""}#{value}"
 		end
@@ -976,6 +1210,10 @@ module Dhall
 			value ::Float
 		end)
 
+		def self.as_dhall
+			Builtins[:Double]
+		end
+
 		def to_s
 			value.to_s
 		end
@@ -1030,12 +1268,16 @@ module Dhall
 			value ::String, coerce: ->(s) { s.encode("UTF-8") }
 		end)
 
+		def self.as_dhall
+			Builtins[:Text]
+		end
+
+		def empty?
+			value.empty?
+		end
+
 		def <<(other)
-			if other.is_a?(Text)
-				with(value: value + other.value)
-			else
-				super
-			end
+			with(value: value + other.value)
 		end
 
 		def to_s
@@ -1068,6 +1310,14 @@ module Dhall
 			fixed.length == 1 ? fixed.first : new(chunks: fixed)
 		end
 
+		def start_empty?
+			chunks.first.empty?
+		end
+
+		def end_empty?
+			chunks.last.empty?
+		end
+
 		def as_json
 			[18, *chunks.map { |chunk| chunk.is_a?(Text) ? chunk.value : chunk.as_json }]
 		end
@@ -1076,89 +1326,90 @@ module Dhall
 	class Import < Expression
 		class IntegrityCheck
 			include(ValueSemantics.for_attributes do
-				protocol Either("sha256", :nocheck)
-				data     Either(::String, nil)
+				code   ::Integer
+				digest ::String
 			end)
 
 			class FailureException < StandardError; end
 
-			def initialize(protocol=:nocheck, data=nil)
-				super(
-					protocol: protocol,
-					data:     data
-				)
+			def to_s
+				"#{Multihashes::TABLE[code].sub(/\Asha2-/, "sha")}:#{hexdigest}"
 			end
 
-			def to_s
-				"#{@protocol}:#{@data}"
+			def hexdigest
+				digest.unpack("H*").first.encode(Encoding::UTF_8)
 			end
 
-			def check(expr)
-				return expr if @protocol == :nocheck
+			def ipfs
+				"/ipfs/b#{Base32.encode("\x01\x55" + as_json).downcase.sub(/=*$/, "")}"
+			end
 
+			def check(expr)
 				expr = expr.normalize
 				return expr if expr.cache_key == to_s
 
-				raise FailureException, "#{expr} does not match #{self}"
+				raise FailureException, "#{expr} hash #{expr.cache_key}" \
+				                        " does not match #{self}"
 			end
 
 			def as_json
-				@protocol == :nocheck ? nil : [@protocol, @data]
+				Multihashes.encode(digest, Multihashes::TABLE[code])
 			end
 		end
 
-		class URI
-			include(ValueSemantics.for_attributes do
-				headers   Either(nil, Expression)
-				authority ::String
-				path      ArrayOf(::String)
-				query     Either(nil, ::String)
-			end)
+		class NoIntegrityCheck < IntegrityCheck
+			def initialize; end
 
-			HeaderType = RecordType.new(
-				record: {
-					"header" => Variable["Text"],
-					"value"  => Variable["Text"]
-				}
-			)
+			def to_s
+				""
+			end
 
-			def initialize(headers, authority, *path, query)
-				super(
-					headers:   headers,
-					authority: authority,
-					path:      path,
-					query:     query,
-				)
+			def hexdigest; end
+
+			def check(expr)
+				expr.normalize
 			end
 
-			def with(hash)
-				self.class.new(
-					hash.fetch(:headers, headers),
-					hash.fetch(:authority, authority),
-					*hash.fetch(:path, path),
-					hash.fetch(:query, query)
-				)
+			def as_json
+				nil
 			end
+		end
 
-			def self.from_uri(uri)
-				(uri.scheme == "https" ? Https : Http).new(
-					nil,
-					"#{uri.host}:#{uri.port}",
-					*uri.path.split(/\//)[1..-1],
-					uri.query,
-					nil
-				)
+		Location = LazyObject.new do
+			UnionType.new(
+				alternatives: {
+					"Local"       => Builtins[:Text],
+					"Remote"      => Builtins[:Text],
+					"Environment" => Builtins[:Text],
+					"Missing"     => nil
+				}
+			)
+		end
+
+		class URI
+			include(ValueSemantics.for_attributes do
+				uri       ::URI
+				headers   Either(nil, Expression), default: nil
+			end)
+
+			def with(attrs)
+				if attrs.key?(:path)
+					attrs[:uri] =
+						uri + Util.path_components_to_uri(*attrs.delete(:path))
+				end
+
+				super
 			end
 
 			def headers
-				super || EmptyList.new(element_type: HeaderType)
-			end
+				header_type = RecordType.new(
+					record: {
+						"mapKey"   => Builtins[:Text],
+						"mapValue" => Builtins[:Text]
+					}
+				)
 
-			def uri
-				escaped_path = path.map do |c|
-					::URI.encode_www_form_component(c).gsub("+", "%20")
-				end
-				URI("#{scheme}://#{authority}/#{escaped_path.join("/")}?#{query}")
+				super || EmptyList.new(element_type: header_type)
 			end
 
 			def chain_onto(relative_to)
@@ -1171,23 +1422,43 @@ module Dhall
 
 			def canonical
 				with(
-					path: (path[1..-1] + [""])
-					.reduce([[], path.first]) { |(pth, prev), c|
+					path: (path[1..-1] + [""]).reduce([[], path.first]) { |(pth, prev), c|
 						c == ".." ? [pth, prev] : [pth + [prev], c]
 					}.first.reject { |c| c == "." }
 				)
 			end
 
+			def port
+				uri.port && uri.port != uri.default_port ? uri.port : nil
+			end
+
+			def authority
+				[
+					uri.userinfo,
+					[uri.host, port].compact.join(":")
+				].compact.join("@")
+			end
+
 			def origin
-				"#{scheme}://#{authority}"
+				"#{uri.scheme}://#{authority}"
 			end
 
 			def to_s
 				uri.to_s
 			end
 
+			def location
+				Union.from(Location, "Remote", to_s.as_dhall)
+			end
+
+			def path
+				path = uri.path.split(/\//, -1)
+				path = path[1..-1] if path.length > 1 && path.first.empty?
+				path
+			end
+
 			def as_json
-				[@headers&.as_json, authority, *path, query]
+				[@headers&.as_json, authority, *path, uri.query]
 			end
 		end
 
@@ -1195,20 +1466,12 @@ module Dhall
 			def resolve(resolver)
 				resolver.resolve_http(self)
 			end
-
-			def scheme
-				"http"
-			end
 		end
 
 		class Https < URI
 			def resolve(resolver)
 				resolver.resolve_https(self)
 			end
-
-			def scheme
-				"https"
-			end
 		end
 
 		class Path
@@ -1225,13 +1488,15 @@ module Dhall
 			end
 
 			def self.from_string(s)
-				parts = s.to_s.split(/\//)
-				if parts.first == ""
-					AbsolutePath.new(*parts[1..-1])
-				elsif parts.first == "~"
-					RelativeToHomePath.new(*parts[1..-1])
+				prefix, *suffix = s.to_s.split(/\//)
+				if prefix == ""
+					AbsolutePath.new(*suffix)
+				elsif prefix == "~"
+					RelativeToHomePath.new(*suffix)
+				elsif prefix == ".."
+					RelativeToParentPath.new(*suffix)
 				else
-					RelativePath.new(*parts)
+					RelativePath.new(prefix, *suffix)
 				end
 			end
 
@@ -1251,6 +1516,10 @@ module Dhall
 				pathname.to_s
 			end
 
+			def location
+				Union.from(Location, "Local", to_s.as_dhall)
+			end
+
 			def as_json
 				path
 			end
@@ -1261,8 +1530,8 @@ module Dhall
 				Pathname.new("/").join(*path)
 			end
 
-			def to_uri(scheme, authority)
-				scheme.new(nil, authority, *path, nil)
+			def to_uri(scheme, base_uri)
+				scheme.new(uri: base_uri + Util.path_components_to_uri(*path))
 			end
 
 			def chain_onto(relative_to)
@@ -1279,6 +1548,10 @@ module Dhall
 				Pathname.new(".").join(*path)
 			end
 
+			def to_s
+				"./#{pathname}"
+			end
+
 			def chain_onto(relative_to)
 				relative_to.with(
 					path: relative_to.path[0..-2] + path
@@ -1303,7 +1576,7 @@ module Dhall
 				Pathname.new("~").join(*@path)
 			end
 
-			def chain_onto(*)
+			def chain_onto(relative_to)
 				if relative_to.is_a?(URI)
 					raise ImportBannedException, "remote import cannot import #{self}"
 				end
@@ -1313,23 +1586,7 @@ module Dhall
 		end
 
 		class EnvironmentVariable
-			ESCAPES = {
-				"\"" => "\"",
-				"\\" => "\\",
-				"a"  => "\a",
-				"b"  => "\b",
-				"f"  => "\f",
-				"n"  => "\n",
-				"r"  => "\r",
-				"t"  => "\t",
-				"v"  => "\v"
-			}.freeze
-
-			def self.decode(var)
-				var.gsub(/\\[\"\\abfnrtv]/) do |escape|
-					ESCAPES.fetch(escape[1])
-				end
-			end
+			attr_reader :var
 
 			def initialize(var)
 				@var = var
@@ -1340,28 +1597,27 @@ module Dhall
 					raise ImportBannedException, "remote import cannot import #{self}"
 				end
 
-				real_path.chain_onto(relative_to)
+				self
+			end
+
+			def path
+				[]
+			end
+
+			def with(path:)
+				Path.from_string(path.join("/"))
 			end
 
 			def canonical
-				real_path.canonical
+				self
 			end
 
 			def real_path
-				val = ENV.fetch(@var) do
-					raise ImportFailedException, "No #{self}"
-				end
-				if val =~ /\Ahttps?:\/\//
-					URI.from_uri(URI(val))
-				else
-					Path.from_string(val)
-				end
+				self
 			end
 
 			def resolve(resolver)
-				Promise.resolve(nil).then do
-					real_path.resolve(resolver)
-				end
+				resolver.resolve_environment(self)
 			end
 
 			def origin
@@ -1369,13 +1625,27 @@ module Dhall
 			end
 
 			def to_s
-				"env:#{as_json}"
+				escapes = Parser::PosixEnvironmentVariableCharacter::ESCAPES
+				"env:#{@var.gsub(/[\"\\\a\b\f\n\r\t\v]/) do |c|
+					"\\" + escapes.find { |(_, v)| v == c }.first
+				end}"
+			end
+
+			def location
+				Union.from(Location, "Environment", to_s.as_dhall)
 			end
 
+			def hash
+				@var.hash
+			end
+
+			def eql?(other)
+				other.is_a?(self.class) && other.var == var
+			end
+			alias == eql?
+
 			def as_json
-				@var.gsub(/[\"\\\a\b\f\n\r\t\v]/) do |c|
-					"\\" + ESCAPES.find { |(_, v)| v == c }.first
-				end
+				@var
 			end
 		end
 
@@ -1398,26 +1668,44 @@ module Dhall
 				"missing"
 			end
 
+			def location
+				Union.from(Location, "Missing", nil)
+			end
+
+			def eql?(other)
+				other.class == self.class
+			end
+			alias == eql?
+
 			def as_json
 				[]
 			end
 		end
 
 		class Expression
-			def self.call(import_value)
-				Dhall.load_raw(import_value)
+			def self.call(import_value, deadline: Util::NoDeadline.new)
+				return import_value if import_value.is_a?(Dhall::Expression)
+
+				Dhall.load_raw(import_value, timeout: deadline.timeout)
 			end
 		end
 
 		class Text
-			def self.call(import_value)
+			def self.call(import_value, deadline: Util::NoDeadline.new)
 				Dhall::Text.new(value: import_value)
 			end
 		end
 
+		class AsLocation
+			def self.call(*)
+				raise "AsLocation is only a marker, you don't actually call it"
+			end
+		end
+
 		IMPORT_TYPES = [
 			Expression,
-			Text
+			Text,
+			AsLocation
 		].freeze
 
 		PATH_TYPES = [
@@ -1427,14 +1715,14 @@ module Dhall
 		].freeze
 
 		include(ValueSemantics.for_attributes do
-			integrity_check IntegrityCheck, default: IntegrityCheck.new
+			integrity_check IntegrityCheck, default: NoIntegrityCheck.new
 			import_type     Class
 			path            Either(*PATH_TYPES)
 		end)
 
 		def initialize(integrity_check, import_type, path)
 			super(
-				integrity_check: integrity_check || IntegrityCheck.new,
+				integrity_check: integrity_check || NoIntegrityCheck.new,
 				import_type:     import_type,
 				path:            path
 			)
@@ -1452,15 +1740,18 @@ module Dhall
 			path.chain_onto(relative_to).canonical
 		end
 
-		def parse_and_check(raw)
-			integrity_check.check(import_type.call(raw))
+		def parse_resolve_check(raw, deadline: Util::NoDeadline.new, **kwargs)
+			import_type.call(raw, deadline: deadline).resolve(**kwargs).then do |e|
+				integrity_check.check(TypeChecker.annotate(e))
+			end
 		end
 
 		def cache_key(relative_to)
-			if integrity_check.protocol == :nocheck
-				real_path(relative_to).to_s
+			key = integrity_check.to_s
+			if key.empty?
+				real_path(relative_to)
 			else
-				integrity_check.to_s
+				key
 			end
 		end
 
@@ -1477,7 +1768,7 @@ module Dhall
 
 	class Let < Expression
 		include(ValueSemantics.for_attributes do
-			var    Util::AllOf.new(::String, Util::Not.new(Util::BuiltinName))
+			var    ::String
 			assign Expression
 			type   Either(nil, Expression)
 		end)
@@ -1493,6 +1784,19 @@ module Dhall
 			body Expression
 		end)
 
+		def lets
+			[let]
+		end
+
+		def flatten
+			flattened = body.is_a?(LetIn) ? body.flatten : body
+			if flattened.is_a?(LetBlock)
+				LetBlock.new(lets: lets + flattened.lets, body: flattened.body)
+			else
+				LetBlock.new(lets: lets, body: body)
+			end
+		end
+
 		def desugar
 			Application.new(
 				function: Function.new(
@@ -1512,24 +1816,16 @@ module Dhall
 		end
 
 		def as_json
-			[25, *let.as_json, body.as_json]
+			flatten.as_json
 		end
 	end
 
-	class LetBlock < Expression
+	class LetBlock
 		include(ValueSemantics.for_attributes do
-			lets Util::ArrayOf.new(Let, min: 2)
+			lets Util::ArrayOf.new(Let)
 			body Expression
 		end)
 
-		def self.for(lets:, body:)
-			if lets.length == 1
-				LetIn.new(let: lets.first, body: body)
-			else
-				new(lets: lets, body: body)
-			end
-		end
-
 		def unflatten
 			lets.reverse.reduce(body) do |inside, let|
 				letin = LetIn.new(let: let, body: inside)
@@ -1537,10 +1833,6 @@ module Dhall
 			end
 		end
 
-		def desugar
-			unflatten(&:desugar)
-		end
-
 		def as_json
 			[25, *lets.flat_map(&:as_json), body.as_json]
 		end
@@ -1556,4 +1848,14 @@ module Dhall
 			[26, value.as_json, type.as_json]
 		end
 	end
+
+	class Assertion < Expression
+		include(ValueSemantics.for_attributes do
+			type Expression
+		end)
+
+		def as_json
+			[19, type.as_json]
+		end
+	end
 end