dhall 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 55053ce451e1b675998712636c725380329d1fe6
-  data.tar.gz: d98038e234871e81f8c0ce3f6d2a8f7c941b8278
+  metadata.gz: 7132b6745d968ae3d719249d6b996438b99b9a3f
+  data.tar.gz: 33c3de17c1b2dc921024f3fb14aeba7fb89624c9
 SHA512:
-  metadata.gz: 4735802d9beb7c796d06ba6c887f5776ac24f12342ad754d911cc36593fb730f0c4d861b653b3667ad1590835014ffcf865e1aa4bd5a56f3c4d9b4e49274d808
-  data.tar.gz: 386cda30b6cd93ea7b6236bab460681554240355e25609c4791cb7d85cf6ff07f3b6a3d6b2a3727c2d6d9d8c2123105b4bcf1a03f1cb0272baa2651b4c0c7159
+  metadata.gz: 89f23e3937ebe15c2a2b693ef5056802a4edc5ccb529ca37e9c8eb43f611b8f9477b722116c5ac143ec10c346c8e61e03f66b3d677984efb84214fbc9d7a45b4
+  data.tar.gz: 26fcce26e98bc480b6d14adaf482debe2ad99dac6d997af1352f6e5cf89dc8930ea3a2766857b984c023d07140c50b672e0635c33f8505820e325ec5bd5a21cf

data/dhall.gemspec

@@ -34,6 +34,7 @@ Gem::Specification.new do |spec|
 	spec.add_dependency "value_semantics", "~> 3.0"
 
 	spec.add_development_dependency "abnf", "~> 0.0.1"
+	spec.add_development_dependency "minitest-fail-fast", "~> 0.1.0"
 	spec.add_development_dependency "simplecov", "~> 0.16.1"
 	spec.add_development_dependency "webmock", "~> 3.5"
 end

data/lib/dhall/ast.rb

@@ -104,6 +104,10 @@ module Dhall
 			end
 		end
 
+		def annotate(type)
+			TypeAnnotation.new(value: self, type: type)
+		end
+
 		def to_s
 			inspect
 		end
@@ -347,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
@@ -355,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
 
@@ -870,6 +911,10 @@ module Dhall
 			end
 		end
 
+		def fetch(selector)
+			record.fetch(selector)
+		end
+
 		def as_json
 			[10, record.as_json, *selectors]
 		end
@@ -881,6 +926,10 @@ module Dhall
 			selector Expression
 		end)
 
+		def fetch(selector)
+			record.fetch(selector)
+		end
+
 		def as_json
 			[10, record.as_json, [selector.as_json]]
 		end
@@ -1299,7 +1348,8 @@ module Dhall
 				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
@@ -1317,7 +1367,7 @@ module Dhall
 			def hexdigest; end
 
 			def check(expr)
-				expr
+				expr.normalize
 			end
 
 			def as_json
@@ -1402,7 +1452,7 @@ module Dhall
 			end
 
 			def path
-				path = uri.path.split(/\//, -1).map(&::URI.method(:unescape))
+				path = uri.path.split(/\//, -1)
 				path = path[1..-1] if path.length > 1 && path.first.empty?
 				path
 			end
@@ -1690,8 +1740,10 @@ module Dhall
 			path.chain_onto(relative_to).canonical
 		end
 
-		def parse_and_check(raw, deadline: Util::NoDeadline.new)
-			integrity_check.check(import_type.call(raw, deadline: deadline))
+		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)
@@ -1738,10 +1790,10 @@ module Dhall
 
 		def flatten
 			flattened = body.is_a?(LetIn) ? body.flatten : body
-			if flattened.is_a?(LetIn) || flattened.is_a?(LetBlock)
-				LetBlock.for(lets: [let] + flattened.lets, body: flattened.body)
+			if flattened.is_a?(LetBlock)
+				LetBlock.new(lets: lets + flattened.lets, body: flattened.body)
 			else
-				self
+				LetBlock.new(lets: lets, body: body)
 			end
 		end
 
@@ -1764,28 +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 flatten
-			unflatten.flatten
-		end
-
 		def unflatten
 			lets.reverse.reduce(body) do |inside, let|
 				letin = LetIn.new(let: let, body: inside)
@@ -1793,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
@@ -1812,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

data/lib/dhall/binary.rb

@@ -213,6 +213,12 @@ module Dhall
 		end
 	end
 
+	class Assertion
+		def self.decode(type)
+			new(type: Dhall.decode(type))
+		end
+	end
+
 	class Import
 		class IntegrityCheck
 			def self.decode(integrity_check)
@@ -230,7 +236,7 @@ module Dhall
 			def self.decode(headers, authority, *path, query)
 				uri = ::URI.scheme_list[name.split(/::/).last.upcase].build(
 					Parser.parse(authority, root: :authority).value.merge(
-						path: Util.path_components_to_uri(*path).path
+						path: "/#{path.join("/")}"
 					)
 				)
 				uri.instance_variable_set(:@query, query)
@@ -268,18 +274,18 @@ module Dhall
 		end
 	end
 
-	class LetBlock
+	class LetIn
 		def self.decode(*parts)
 			body = Dhall.decode(parts.pop)
-			lets = parts.each_slice(3).map do |(var, type, assign)|
+			parts.each_slice(3).map { |(var, type, assign)|
 				Let.new(
 					var:    var,
 					assign: Dhall.decode(assign),
 					type:   type.nil? ? nil : Dhall.decode(type)
 				)
+			}.reverse.reduce(body) do |inside, let|
+				LetIn.new(let: let, body: inside)
 			end
-
-			self.for(lets: lets, body: body)
 		end
 	end
 
@@ -335,13 +341,13 @@ module Dhall
 		Integer,
 		nil,
 		TextLiteral,
-		nil,
+		Assertion,
 		nil,
 		nil,
 		nil,
 		nil,
 		Import,
-		LetBlock,
+		LetIn,
 		TypeAnnotation,
 		ToMap,
 		EmptyList

data/lib/dhall/builtins.rb

@@ -98,6 +98,26 @@ module Dhall
 			end
 		end
 
+		class Natural_subtract < BuiltinFunction
+			protected
+
+			def uncurried_call(x, y)
+				return y if zero?(x) || zero?(y)
+
+				return Dhall::Natural.new(value: 0) if x == y
+
+				unless x.is_a?(Dhall::Natural) && y.is_a?(Dhall::Natural)
+					return unfill(x, y)
+				end
+
+				Dhall::Natural.new(value: [y.to_i - x.to_i, 0].max)
+			end
+
+			def zero?(x)
+				Natural_isZero.new.call(x) === true
+			end
+		end
+
 		class Natural_even < BuiltinFunction
 			protected
 

data/lib/dhall/normalize.rb

@@ -1,26 +1,37 @@
 # frozen_string_literal: true
 
 require "dhall/builtins"
-require "dhall/visitor"
 require "dhall/util"
 
 module Dhall
-	module ExpressionVisitor
+	class ExpressionVisitor
 		ExpressionHash = Util::HashOf.new(
 			ValueSemantics::Anything,
 			ValueSemantics::Either.new([Expression, nil])
 		)
 
-		def self.new(&block)
-			Visitor.new(
-				Expression                    => block,
-				Util::ArrayOf.new(Expression) => lambda do |x|
-					x.map(&block)
-				end,
-				ExpressionHash                => lambda do |x|
-					Hash[x.map { |k, v| [k, v.nil? ? v : block[v]] }.sort]
-				end
-			)
+		ExpressionArray = Util::ArrayOf.new(Expression)
+
+		def initialize(&block)
+			@block = block
+		end
+
+		def visit(expr)
+			expr.to_h.each_with_object({}) do |(attr, value), h|
+				result = one_visit(value)
+				h[attr] = result if result
+			end
+		end
+
+		def one_visit(value)
+			case value
+			when Expression
+				@block[value]
+			when ExpressionArray
+				value.map(&@block)
+			when ExpressionHash
+				Hash[value.map { |k, v| [k, v.nil? ? v : @block[v]] }.sort]
+			end
 		end
 	end
 
@@ -138,6 +149,8 @@ module Dhall
 		def shift(amount, name, min_index)
 			return self if self.name != name || min_index > index
 
+			raise TypeError, "free variable" if (index + amount).negative?
+
 			with(index: index + amount)
 		end
 
@@ -232,7 +245,10 @@ module Dhall
 
 		class RightBiasedRecordMerge
 			def normalize
-				lhs.normalize.merge(rhs.normalize)
+				n_lhs = lhs.normalize
+				n_rhs = rhs.normalize
+				return n_lhs if n_lhs == n_rhs
+				n_lhs.merge(n_rhs)
 			end
 		end
 
@@ -441,20 +457,6 @@ module Dhall
 		end
 	end
 
-	class LetBlock
-		def normalize
-			desugar.normalize
-		end
-
-		def shift(amount, name, min_index)
-			unflatten.shift(amount, name, min_index)
-		end
-
-		def substitute(svar, with_expr)
-			unflatten.substitute(svar, with_expr)
-		end
-	end
-
 	class TypeAnnotation
 		def normalize
 			value.normalize

data/lib/dhall/parser.citrus

@@ -85,7 +85,7 @@ rule double_quote_literal
 	(/"/i ((double_quote_chunk)*) /"/i) <Dhall::Parser::DoubleQuoteLiteral>
 end
 rule single_quote_continue
-	(((interpolation) (single_quote_continue)) | ((escaped_quote_pair) (single_quote_continue)) | ((escaped_interpolation) (single_quote_continue)) | ((single_quote_char) (single_quote_continue)) | (`''`)) <Dhall::Parser::SingleQuoteContinue>
+	(single_quote_char+ single_quote_continue | interpolation single_quote_continue | escaped_quote_pair single_quote_continue | escaped_interpolation single_quote_continue | "''") <Dhall::Parser::SingleQuoteContinue>
 end
 rule escaped_quote_pair
 	(`'''`) <Dhall::Parser::EscapedQuotePair>
@@ -94,7 +94,7 @@ rule escaped_interpolation
 	(/(?:''(?:\u{24}))(?:\u{7b})/i) <Dhall::Parser::EscapedInterpolation>
 end
 rule single_quote_char
-	(/[\u{20}-@\u{5b}-\u{7f}]/i | (valid_non_ascii) | (tab) | (end_of_line))
+	!("${" | "''") (/[\u{20}-@\u{5b}-\u{7f}]/i | (valid_non_ascii) | (tab) | (end_of_line))
 end
 rule single_quote_literal
 	(`''` (end_of_line) (single_quote_continue)) <Dhall::Parser::SingleQuoteLiteral>
@@ -144,11 +144,14 @@ end
 rule tomap
 	("toMap")
 end
+rule assert
+	("assert")
+end
 rule keyword
 	((if) | (then) | (else) | (let) | (in) | (using) | (missing) | (as) | (infinity) | (nan) | (merge) | (some) | (tomap))
 end
 rule builtin
-	((natural_fold) | (natural_build) | (natural_iszero) | (natural_even) | (natural_odd) | (natural_tointeger) | (natural_show) | (integer_todouble) | (integer_show) | (double_show) | (list_build) | (list_fold) | (list_length) | (list_head) | (list_last) | (list_indexed) | (list_reverse) | (optional_fold) | (optional_build) | (text_show) | (bool) | (true) | (false) | (optional) | (none) | (natural) | (integer) | (double) | (text) | (list) | (type) | (kind) | (sort)) <Dhall::Parser::Builtin>
+	((natural_fold) | (natural_build) | (natural_iszero) | (natural_even) | (natural_odd) | (natural_tointeger) | (natural_show) | (integer_todouble) | (integer_show) | (natural_subtract) | (double_show) | (list_build) | (list_fold) | (list_length) | (list_head) | (list_last) | (list_indexed) | (list_reverse) | (optional_fold) | (optional_build) | (text_show) | (bool) | (true) | (false) | (optional) | (none) | (natural) | (integer) | (double) | (text) | (list) | (type) | (kind) | (sort)) <Dhall::Parser::Builtin>
 end
 rule optional
 	("Optional")
@@ -213,6 +216,9 @@ end
 rule natural_show
 	("Natural" /\//i "s" "h" "o" "w")
 end
+rule natural_subtract
+	("Natural" /\//i "s" "u" "b" "t" "r" "a" "c" "t")
+end
 rule integer_todouble
 	("Integer" /\//i "t" "o" "D" "o" "u" "b" "l" "e")
 end
@@ -258,6 +264,9 @@ end
 rule combine_types
 	(/\u{2a53}/i | (/(?:(?:(?:\/)(?:\/))(?:\u{5c}))(?:\u{5c})/i))
 end
+rule equivalent
+	(/\u{2261}/i | (/(?:(?:=)(?:=))(?:=)/i))
+end
 rule prefer
 	(/\u{2afd}/i | (/(?:\/)(?:\/)/i))
 end
@@ -424,7 +433,7 @@ rule import
 	((import_hashed) (((whsp) (as) (whsp1) ((text) | (location)))?)) <Dhall::Parser::Import>
 end
 rule expression
-	(((lambda) (whsp) /\u{28}/i (whsp) (nonreserved_label) (whsp) `:` (whsp1) (expression) (whsp) /\u{29}/i (whsp) (arrow) (whsp) (expression)) | ((if) (whsp1) (expression) (whsp) (then) (whsp1) (expression) (whsp) (else) (whsp1) (expression)) | (((let_binding)+) (in) (whsp1) (expression)) | ((forall) (whsp) /\u{28}/i (whsp) (nonreserved_label) (whsp) `:` (whsp1) (expression) (whsp) /\u{29}/i (whsp) (arrow) (whsp) (expression)) | ((operator_expression) (whsp) (arrow) (whsp) (expression)) | ((merge) (whsp1) (import_expression) (whsp1) (import_expression) (whsp) `:` (whsp1) (application_expression)) | (/\u{5b}/i (whsp) /\u{5d}/i (whsp) `:` (whsp1) (application_expression)) | ((tomap) (whsp1) (import_expression) (whsp) `:` (whsp1) (application_expression)) | (annotated_expression)) <Dhall::Parser::Expression>
+	(((lambda) (whsp) /\u{28}/i (whsp) (nonreserved_label) (whsp) `:` (whsp1) (expression) (whsp) /\u{29}/i (whsp) (arrow) (whsp) (expression)) | ((if) (whsp1) (expression) (whsp) (then) (whsp1) (expression) (whsp) (else) (whsp1) (expression)) | (((let_binding)+) (in) (whsp1) (expression)) | ((forall) (whsp) /\u{28}/i (whsp) (nonreserved_label) (whsp) `:` (whsp1) (expression) (whsp) /\u{29}/i (whsp) (arrow) (whsp) (expression)) | ((operator_expression) (whsp) (arrow) (whsp) (expression)) | ((merge) (whsp1) (import_expression) (whsp1) (import_expression) (whsp) `:` (whsp1) (application_expression)) | (empty_list_literal) | ((tomap) (whsp1) (import_expression) (whsp) `:` (whsp1) (application_expression)) | ((assert) (whsp) `:` (whsp1) (expression)) | (annotated_expression)) <Dhall::Parser::Expression>
 end
 rule annotated_expression
 	((operator_expression) (((whsp) `:` (whsp1) (expression))?)) <Dhall::Parser::AnnotatedExpression>
@@ -432,6 +441,9 @@ end
 rule let_binding
 	((let) (whsp1) (nonreserved_label) (whsp) ((`:` (whsp1) (expression) (whsp))?) /=/i (whsp) (expression) (whsp)) <Dhall::Parser::LetBinding>
 end
+rule empty_list_literal
+	(/\u{5b}/i (whsp) /\u{5d}/i (whsp) `:` (whsp1) (application_expression))
+end
 rule operator_expression
 	(import_alt_expression)
 end
@@ -469,7 +481,10 @@ rule equal_expression
 	((not_equal_expression) (((whsp) /(?:=)(?:=)/i (whsp) (not_equal_expression))*)) <Dhall::Parser::EqualExpression>
 end
 rule not_equal_expression
-	((application_expression) (((whsp) /(?:!)(?:=)/i (whsp) (application_expression))*)) <Dhall::Parser::NotEqualExpression>
+	((equivalent_expression) (((whsp) /(?:!)(?:=)/i (whsp) (equivalent_expression))*)) <Dhall::Parser::NotEqualExpression>
+end
+rule equivalent_expression
+	((application_expression) (((whsp) (equivalent) (whsp) (application_expression))*)) <Dhall::Parser::EquivalentExpression>
 end
 rule application_expression
 	((first_application_expression) (((whsp1) (import_expression))*)) <Dhall::Parser::ApplicationExpression>
@@ -493,7 +508,7 @@ rule type_selector
 	(/\u{28}/i (whsp) (expression) (whsp) /\u{29}/i)
 end
 rule primitive_expression
-	((double_literal) | (natural_literal) | (integer_literal) | (text_literal) | (/\u{7b}/i (whsp) (record_type_or_literal) (whsp) /\u{7d}/i) | (/</i (whsp) (union_type_or_literal) (whsp) />/i) | (non_empty_list_literal) | (identifier) | (/\u{28}/i (complete_expression) /\u{29}/i)) <Dhall::Parser::PrimitiveExpression>
+	((double_literal) | (natural_literal) | (integer_literal) | (text_literal) | (/\u{7b}/i (whsp) (record_type_or_literal) (whsp) /\u{7d}/i) | (/</i (whsp) (union_type) (whsp) />/i) | (non_empty_list_literal) | (identifier) | (/\u{28}/i (complete_expression) /\u{29}/i)) <Dhall::Parser::PrimitiveExpression>
 end
 rule record_type_or_literal
 	((empty_record_literal) | (non_empty_record_type_or_literal) | (empty_record_type))
@@ -519,24 +534,18 @@ end
 rule record_literal_entry
 	((any_label) (whsp) /=/i (whsp) (expression)) <Dhall::Parser::RecordLiteralEntry>
 end
-rule union_type_or_literal
-	((non_empty_union_type_or_literal) | (empty_union_type))
+rule union_type
+	((non_empty_union_type) | (empty_union_type))
 end
 rule empty_union_type
 	("") <Dhall::Parser::EmptyUnionType>
 end
-rule non_empty_union_type_or_literal
-	((any_label) (((whsp) ((union_literal_variant_value) | (union_type_or_literal_variant_type)))?)) <Dhall::Parser::NonEmptyUnionTypeOrLiteral>
-end
-rule union_literal_variant_value
-	(/=/i (whsp) (expression) (((whsp) /\u{7c}/i (whsp) (union_type_entry))*)) <Dhall::Parser::UnionLiteralVariantValue>
+rule non_empty_union_type
+	((union_type_entry) (((whsp) /\u{7c}/i (whsp) (union_type_entry))*)) <Dhall::Parser::NonEmptyUnionType>
 end
 rule union_type_entry
 	((any_label) (((whsp) `:` (whsp1) (expression))?)) <Dhall::Parser::UnionTypeEntry>
 end
-rule union_type_or_literal_variant_type
-	(((`:` (whsp1) (expression))?) (((whsp) /\u{7c}/i (whsp) (non_empty_union_type_or_literal))?)) <Dhall::Parser::UnionTypeOrLiteralVariantType>
-end
 rule non_empty_list_literal
 	(/\u{5b}/i (whsp) (expression) (whsp) ((/,/i (whsp) (expression) (whsp))*) /\u{5d}/i) <Dhall::Parser::NonEmptyListLiteral>
 end

data/lib/dhall/parser.rb

@@ -24,17 +24,18 @@ module Dhall
 				return list if string =~ /\A\[\s*\]/
 
 				key =
-					[:let_binding, :lambda, :forall, :arrow, :if, :merge, :tomap]
+					[:let_binding, :lambda, :forall, :arrow, :if, :merge, :tomap, :assert]
 					.find { |k| captures.key?(k) }
 
 				key ? public_send(key) : super
 			end
 
 			def let_binding
-				LetBlock.for(
-					lets: captures(:let_binding).map(&:value),
-					body: capture(:expression).value
-				)
+				captures(:let_binding).reverse.reduce(
+					capture(:expression).value
+				) do |inside, let|
+					LetIn.new(let: let.value, body: inside)
+				end
 			end
 
 			def lambda
@@ -86,6 +87,10 @@ module Dhall
 					type:   capture(:application_expression).value
 				)
 			end
+
+			def assert
+				Assertion.new(type: capture(:expression).value)
+			end
 		end
 
 		OPERATORS = {
@@ -100,7 +105,8 @@ module Dhall
 			combine_types_expression: :RecursiveRecordTypeMerge,
 			times_expression:         :Times,
 			equal_expression:         :Equal,
-			not_equal_expression:     :NotEqual
+			not_equal_expression:     :NotEqual,
+			equivalent_expression:    :Equivalent
 		}.freeze
 
 		OPERATORS.to_a.zip(
@@ -169,7 +175,7 @@ module Dhall
 				elsif captures.key?(:labels)
 					captures(:any_label).map(&:value)
 				else
-					string
+					super
 				end
 			end
 		end
@@ -314,7 +320,9 @@ module Dhall
 
 		module SingleQuoteLiteral
 			def value
-				chunks = capture(:single_quote_continue).value
+				chunks = capture(:single_quote_continue).value.flat_map do |chunk|
+					chunk.is_a?(String) ? chunk.gsub(/\r\n/, "\n").chars : chunk
+				end
 				indent = Util.indent_size(chunks.join)
 
 				TextLiteral.for(
@@ -384,7 +392,7 @@ module Dhall
 				key = [
 					:complete_expression,
 					:record_type_or_literal,
-					:union_type_or_literal
+					:union_type
 				].find { |k| captures.key?(k) }
 				key ? capture(key).value : super
 			end
@@ -396,31 +404,6 @@ module Dhall
 			end
 		end
 
-		module UnionTypeOrLiteralVariantType
-			def value(label)
-				rest = capture(:non_empty_union_type_or_literal)&.value
-				type = UnionType.new(
-					alternatives: { label => capture(:expression)&.value }
-				)
-				if rest.is_a?(Union)
-					rest.with(alternatives: type.merge(rest.alternatives))
-				else
-					rest ? type.merge(rest) : type
-				end
-			end
-		end
-
-		module UnionLiteralVariantValue
-			def value(label)
-				Union.new(
-					tag:          label,
-					value:        capture(:expression).value,
-					alternatives: captures(:union_type_entry).map(&:value)
-					              .reduce(UnionType.new(alternatives: {}), &:merge)
-				)
-			end
-		end
-
 		module UnionTypeEntry
 			def value
 				UnionType.new(
@@ -431,19 +414,9 @@ module Dhall
 			end
 		end
 
-		module NonEmptyUnionTypeOrLiteral
+		module NonEmptyUnionType
 			def value
-				key = [
-					:union_literal_variant_value,
-					:union_type_or_literal_variant_type
-				].find { |k| captures.key?(k) }
-
-				if key
-					capture(key).value(capture(:any_label).value)
-				else
-					no_alts = UnionType.new(alternatives: {})
-					Union.from(no_alts, capture(:any_label).value, nil)
-				end
+				captures(:union_type_entry).map(&:value).reduce(&:merge)
 			end
 		end
 

data/lib/dhall/resolve.rb

@@ -16,13 +16,13 @@ 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|
-				Promise.resolve(nil).then do
+				Util::LazyPromise.new do
 					ENV.fetch(source.var) do
 						raise ImportFailedException, "No #{source}"
 					end
@@ -53,7 +53,7 @@ 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
@@ -449,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, deadline: resolver.deadline).resolve(
+					@expr.parse_resolve_check(
+						result,
+						deadline:    resolver.deadline,
 						resolver:    resolver.child(real_path),
 						relative_to: real_path
 					)

data/lib/dhall/typecheck.rb

@@ -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
 
@@ -237,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
 
@@ -313,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
 
@@ -340,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,
@@ -354,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
 
@@ -478,13 +501,20 @@ module Dhall
 
 		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
@@ -492,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"
 
@@ -749,7 +789,7 @@ module Dhall
 				end
 
 				def keys
-					@type.record.keys
+					Set.new(@type.record.keys)
 				end
 
 				def fetch_input_type(k)
@@ -800,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|
@@ -842,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
@@ -931,8 +969,6 @@ module Dhall
 			end
 		end
 
-		TypeChecker.register ->(blk) { LetIn.for(blk.unflatten) }, Dhall::LetBlock
-
 		class LetIn
 			TypeChecker.register self, Dhall::LetIn
 
@@ -998,6 +1034,30 @@ 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],
@@ -1060,6 +1120,11 @@ module Dhall
 					)
 				)
 			),
+			"Natural/subtract"  => Dhall::Forall.of_arguments(
+				Builtins[:Natural],
+				Builtins[:Natural],
+				body: Builtins[:Natural]
+			),
 			"Natural/isZero"    => Dhall::Forall.of_arguments(
 				Builtins[:Natural],
 				body: Builtins[:Bool]

data/lib/dhall/util.rb

@@ -1,9 +1,27 @@
 # frozen_string_literal: true
 
+require "promise"
 require "timeout"
 
 module Dhall
 	module Util
+		class LazyPromise < Promise
+			def initialize(&block)
+				super
+				@block = block
+			end
+
+			def subscribe(*args)
+				super
+
+				begin
+					fulfill(@block.call)
+				rescue => e
+					reject(e)
+				end
+			end
+		end
+
 		class AllOf
 			def initialize(*validators)
 				@validators = validators

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dhall
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Stephen Paul Weber
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-07-27 00:00:00.000000000 Z
+date: 2019-10-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base32
@@ -122,6 +122,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.0.1
+- !ruby/object:Gem::Dependency
+  name: minitest-fail-fast
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -181,7 +195,6 @@ files:
 - lib/dhall/typecheck.rb
 - lib/dhall/types.rb
 - lib/dhall/util.rb
-- lib/dhall/visitor.rb
 homepage: https://git.sr.ht/~singpolyma/dhall-ruby
 licenses:
 - GPL-3.0

data/lib/dhall/visitor.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Dhall
-	class Visitor
-		def initialize(callbacks)
-			@callbacks = callbacks
-		end
-
-		def visit(expr)
-			expr.to_h.each_with_object({}) do |(attr, value), h|
-				if (callback = callback_for(value))
-					h[attr] = callback.call(value)
-				end
-			end
-		end
-
-		protected
-
-		def callback_for(x)
-			@callbacks.find { |k, _| k === x }&.last
-		end
-	end
-end