dhall 0.1.0 → 0.5.1

data/lib/dhall/coder.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+require "psych"
+
+module Dhall
+	class Coder
+		JSON_LIKE = [
+			::Array, ::Hash,
+			::TrueClass, ::FalseClass, ::NilClass,
+			::Integer, ::Float, ::String
+		].freeze
+
+		class Verifier
+			def initialize(*classes)
+				@classes = classes
+				@matcher = ValueSemantics::Either.new(classes)
+			end
+
+			def verify_class(klass, op)
+				if @classes.any? { |safe| klass <= safe }
+					klass
+				else
+					raise ArgumentError, "#{op} does not match "\
+					                     "#{@classes.inspect}: #{klass}"
+				end
+			end
+
+			def verify(obj, op)
+				if @matcher === obj
+					obj
+				else
+					raise ArgumentError, "#{op} does not match "\
+					                     "#{@classes.inspect}: #{obj.inspect}"
+				end
+			end
+		end
+
+		def self.load(source, transform_keys: :to_s)
+			new.load(source, transform_keys: transform_keys)
+		end
+
+		def self.dump(obj)
+			new.dump(obj)
+		end
+
+		def initialize(default: nil, safe: JSON_LIKE)
+			@default = default
+			@verifier = Verifier.new(*Array(safe))
+			@verifier.verify(default, "default value")
+		end
+
+		def load_async(source, op="load_async", transform_keys: :to_s)
+			return Promise.resolve(@default) if source.nil?
+			return Promise.resolve(source) unless source.is_a?(String)
+
+			Dhall.load(source).then do |expr|
+				decode(expr, op, transform_keys: transform_keys)
+			end
+		end
+
+		def load(source, transform_keys: :to_s)
+			load_async(source, "load", transform_keys: transform_keys).sync
+		end
+
+		module ToRuby
+			refine Expression do
+				def to_ruby
+					self
+				end
+			end
+
+			refine Natural do
+				alias_method :to_ruby, :to_i
+			end
+
+			refine Integer do
+				alias_method :to_ruby, :to_i
+			end
+
+			refine Double do
+				alias_method :to_ruby, :to_f
+			end
+
+			refine Text do
+				alias_method :to_ruby, :to_s
+			end
+
+			refine Bool do
+				def to_ruby
+					self === true
+				end
+			end
+
+			refine Record do
+				def to_ruby(&decode)
+					Hash[to_h.map { |k, v| [k, decode[v]] }]
+				end
+			end
+
+			refine EmptyRecord do
+				def to_ruby
+					{}
+				end
+			end
+
+			refine List do
+				def to_ruby(&decode)
+					arr = to_a.map(&decode)
+					unless element_type.is_a?(RecordType) &&
+					       element_type.keys == ["mapKey", "mapValue"]
+						return arr
+					end
+					Hash[arr.map { |h| h.values_at("mapKey", "mapValue") }]
+				end
+			end
+
+			refine Optional do
+				def to_ruby(&decode)
+					reduce(nil, &decode)
+				end
+			end
+
+			refine Function do
+				def to_ruby(&decode)
+					->(*args) { decode[call(*args)] }
+				end
+			end
+
+			refine Enum do
+				def to_ruby
+					extract == :None ? nil : extract
+				end
+			end
+
+			refine Union do
+				def to_ruby
+					rtag = tag.sub(/_[0-9a-f]{64}\Z/, "")
+					if tag.match(/\A\p{Upper}/) &&
+					   Object.const_defined?(rtag) && !Dhall.const_defined?(rtag, false)
+						yield extract, Object.const_get(rtag)
+					else
+						yield extract
+					end
+				end
+			end
+
+			refine TypeAnnotation do
+				def to_ruby
+					yield value
+				end
+			end
+		end
+
+		using ToRuby
+
+		module InitWith
+			refine Object do
+				def init_with(coder)
+					coder.map.each do |k, v|
+						instance_variable_set(:"@#{k}", v)
+					end
+				end
+			end
+		end
+
+		using InitWith
+
+		def revive(klass, expr, op="revive", transform_keys: :to_s)
+			@verifier.verify_class(klass, op)
+			return klass.from_dhall(expr) if klass.respond_to?(:from_dhall)
+
+			klass.allocate.tap do |o|
+				o.init_with(Util.psych_coder_for(
+					klass.name,
+					decode(expr, op, transform_keys: transform_keys)
+				))
+			end
+		end
+
+		def decode(expr, op="decode", klass: nil, transform_keys: :to_s)
+			return revive(klass, expr, op, transform_keys: transform_keys) if klass
+			@verifier.verify(
+				Util.transform_keys(
+					expr.to_ruby { |dexpr, dklass|
+						decode(dexpr, op, klass: dklass, transform_keys: transform_keys)
+					},
+					&transform_keys
+				),
+				op
+			)
+		end
+
+		def dump(obj)
+			return if obj.nil?
+
+			Dhall.dump(@verifier.verify(obj, "dump"))
+		end
+	end
+end

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
 
@@ -51,7 +62,7 @@ module Dhall
 			normalized = super
 			return normalized.fuse if normalized.fuse
 
-			if normalized.function.is_a?(Builtin) ||
+			if normalized.function.is_a?(BuiltinFunction) ||
 			   normalized.function.is_a?(Function) ||
 			   normalized.function.is_a?(RecordSelection)
 				return normalized.function.call(normalized.argument)
@@ -120,15 +131,26 @@ module Dhall
 		end
 	end
 
-	class Forall; end
+	class FunctionProxyRaw
+		def shift(*)
+			self
+		end
+
+		def substitute(*)
+			raise "Cannot substitute #{self}"
+		end
 
-	class Bool
+		def normalize
+			self
+		end
 	end
 
 	class Variable
 		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
 
@@ -199,14 +221,7 @@ module Dhall
 
 		class TextConcatenate
 			def normalize
-				normalized = super
-				if normalized.lhs == Text.new(value: "")
-					normalized.rhs
-				elsif normalized.rhs == Text.new(value: "")
-					normalized.lhs
-				else
-					normalized.lhs << normalized.rhs
-				end
+				TextLiteral.for(lhs, rhs).normalize
 			end
 		end
 
@@ -230,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
 
@@ -243,7 +261,7 @@ module Dhall
 
 	class EmptyList
 		def normalize
-			super.with(element_type: element_type.normalize)
+			super.with(type: type.normalize)
 		end
 	end
 
@@ -263,6 +281,20 @@ module Dhall
 		end
 	end
 
+	class ToMap
+		def normalize
+			normalized = super
+			unless [Record, EmptyRecord].include?(normalized.record.class)
+				return normalized
+			end
+
+			List.of(*normalized.record.to_h.to_a.map do |(k, v)|
+				k = Text.new(value: k)
+				Record.new(record: { "mapKey" => k, "mapValue" => v })
+			end, type: normalized.type&.argument)
+		end
+	end
+
 	class Merge
 		def normalize
 			normalized = super
@@ -314,7 +346,19 @@ module Dhall
 
 	class RecordProjection
 		def normalize
-			record.normalize.slice(*selectors)
+			record.normalize.slice(*selectors.sort)
+		end
+	end
+
+	class RecordProjectionByExpression
+		def normalize
+			sel = selector.normalize
+
+			if sel.is_a?(RecordType)
+				RecordProjection.for(record, sel.keys).normalize
+			else
+				with(record: record.normalize, selector: sel)
+			end
 		end
 	end
 
@@ -342,6 +386,12 @@ module Dhall
 		end
 	end
 
+	class Enum
+		def normalize
+			with(alternatives: alternatives.normalize)
+		end
+	end
+
 	class If
 		def normalize
 			normalized = super
@@ -362,19 +412,16 @@ module Dhall
 		end
 	end
 
-	class Number
-	end
-
-	class Natural; end
-	class Integer; end
-	class Double; end
-
-	class Text
-	end
-
 	class TextLiteral
 		def normalize
-			TextLiteral.for(*super.flatten.chunks)
+			lit = TextLiteral.for(*super.flatten.chunks)
+
+			if lit.is_a?(TextLiteral) && lit.chunks.length == 3 &&
+			   lit.start_empty? && lit.end_empty?
+				lit.chunks[1]
+			else
+				lit
+			end
 		end
 
 		def flatten
@@ -384,9 +431,6 @@ module Dhall
 		end
 	end
 
-	class Import
-	end
-
 	class LetIn
 		def normalize
 			desugar.normalize
@@ -400,15 +444,16 @@ module Dhall
 				body: body.shift(amount, name, min_index + 1)
 			)
 		end
-	end
-
-	class LetBlock
-		def normalize
-			desugar.normalize
-		end
 
-		def shift(amount, name, min_index)
-			unflatten.shift(amount, name, min_index)
+		def substitute(svar, with_expr)
+			var = let.var
+			with(
+				let:  let.substitute(svar, with_expr),
+				body: body.substitute(
+					var == svar.name ? svar.with(index: svar.index + 1) : svar,
+					with_expr.shift(1, var, 0)
+				)
+			)
 		end
 	end
 

data/lib/dhall/parser.citrus

@@ -1,7 +1,10 @@
 grammar Dhall::Parser::CitrusParser
 	root complete_expression
 rule end_of_line
-	(/\n/i | (/(?:\r)(?:\n)/i))
+	(/\n/i | (/(?:\r)(?:\n)/i)) <Dhall::Parser::EndOfLine>
+end
+rule valid_non_ascii
+	(/[\u{80}-\u{d7ff}\u{e000}-\u{fffd}\u{10000}-\u{1fffd}\u{20000}-\u{2fffd}\u{30000}-\u{3fffd}\u{40000}-\u{4fffd}\u{50000}-\u{5fffd}\u{60000}-\u{6fffd}\u{70000}-\u{7fffd}\u{80000}-\u{8fffd}\u{90000}-\u{9fffd}\u{a0000}-\u{afffd}\u{b0000}-\u{bfffd}\u{c0000}-\u{cfffd}\u{d0000}-\u{dfffd}\u{e0000}-\u{efffd}\u{f0000}-\u{ffffd}\u{100000}-\u{10fffd}]/i)
 end
 rule tab
 	(/\t/i)
@@ -9,14 +12,14 @@ end
 rule block_comment
 	(/(?:\u{7b})(?:\u{2d})/i (block_comment_continue))
 end
-rule block_comment_chunk
-	((block_comment) | /[\u{20}-@\u{5b}-\u{10ffff}]/i | (tab) | (end_of_line))
+rule block_comment_char
+	!("{-" | "-}") (/[\u{20}-@\u{5b}-\u{7f}]/i | (valid_non_ascii) | (tab) | (end_of_line))
 end
 rule block_comment_continue
-	((/(?:\u{2d})(?:\u{7d})/i) | ((block_comment_chunk) (block_comment_continue)))
+	("-}" | block_comment_char+ block_comment_continue | (block_comment block_comment_continue))
 end
 rule not_end_of_line
-	(/[\u{20}-@\u{5b}-\u{10ffff}]/i | (tab))
+	(/[\u{20}-@\u{5b}-\u{7f}]/i | (valid_non_ascii) | (tab))
 end
 rule line_comment
 	(/(?:\u{2d})(?:\u{2d})/i ((not_end_of_line)*) (end_of_line))
@@ -36,6 +39,9 @@ end
 rule digit
 	(/\d/i)
 end
+rule alphanum
+	((alpha) | (digit))
+end
 rule hexdig
 	((digit) | /[a-f]/i | (digit) | /[a-f]/i)
 end
@@ -43,7 +49,7 @@ rule simple_label_first_char
 	((alpha) | `_`)
 end
 rule simple_label_next_char
-	((alpha) | (digit) | /[\u{2d}\/_]/i)
+	((alphanum) | /[\u{2d}\/_]/i)
 end
 rule simple_label
 	(keyword simple_label_next_char+ | !keyword (simple_label_first_char simple_label_next_char*))
@@ -58,7 +64,7 @@ rule label
 	((/`/i (quoted_label) /`/i) | (simple_label)) <Dhall::Parser::Label>
 end
 rule nonreserved_label
-	(reserved_identifier simple_label_next_char+ | !reserved_identifier label) <Dhall::Parser::NonreservedLabel>
+	(builtin simple_label_next_char+ | !builtin label) <Dhall::Parser::NonreservedLabel>
 end
 rule any_label
 	(label)
@@ -67,16 +73,19 @@ rule double_quote_chunk
 	((interpolation) | (/\u{5c}/i (double_quote_escaped)) | (double_quote_char)) <Dhall::Parser::DoubleQuoteChunk>
 end
 rule double_quote_escaped
-	(/["\u{24}\/\u{5c}bfnrt]/ | ("u" ((hexdig) 4*4))) <Dhall::Parser::DoubleQuoteEscaped>
+	(/["\u{24}\/\u{5c}bfnrt]/ | ("u" (unicode_escape))) <Dhall::Parser::DoubleQuoteEscaped>
+end
+rule unicode_escape
+	(((hexdig) 4*4) | (/\u{7b}/i ((hexdig)+) /\u{7d}/i))
 end
 rule double_quote_char
-	(/[\u{20}!\u{23}-@\u{5b}\u{5d}-\u{10ffff}]/i)
+	(/[\u{20}!\u{23}-@\u{5b}\u{5d}-\u{7f}]/i | (valid_non_ascii))
 end
 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>
@@ -85,7 +94,7 @@ rule escaped_interpolation
 	(/(?:''(?:\u{24}))(?:\u{7b})/i) <Dhall::Parser::EscapedInterpolation>
 end
 rule single_quote_char
-	(/[\u{20}-@\u{5b}-\u{10ffff}]/i | (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>
@@ -132,8 +141,17 @@ end
 rule some
 	("Some")
 end
+rule tomap
+	("toMap")
+end
+rule assert
+	("assert")
+end
 rule keyword
-	((if) | (then) | (else) | (let) | (in) | (using) | (missing) | (as) | (infinity) | (nan) | (merge) | (some))
+	((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) | (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")
@@ -144,12 +162,111 @@ end
 rule list
 	("List")
 end
+rule location
+	("Location")
+end
+rule bool
+	("Bool")
+end
+rule true
+	("True")
+end
+rule false
+	("False")
+end
+rule none
+	("None")
+end
+rule natural
+	("Natural")
+end
+rule integer
+	("Integer")
+end
+rule double
+	("Double")
+end
+rule type
+	("Type")
+end
+rule kind
+	("Kind")
+end
+rule sort
+	("Sort")
+end
+rule natural_fold
+	("Natural" /\//i "f" "o" "l" "d")
+end
+rule natural_build
+	("Natural" /\//i "b" "u" "i" "l" "d")
+end
+rule natural_iszero
+	("Natural" /\//i "i" "s" "Z" "e" "r" "o")
+end
+rule natural_even
+	("Natural" /\//i "e" "v" "e" "n")
+end
+rule natural_odd
+	("Natural" /\//i "o" "d" "d")
+end
+rule natural_tointeger
+	("Natural" /\//i "t" "o" "I" "n" "t" "e" "g" "e" "r")
+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
+rule integer_show
+	("Integer" /\//i "s" "h" "o" "w")
+end
+rule double_show
+	("Double" /\//i "s" "h" "o" "w")
+end
+rule list_build
+	("List" /\//i "b" "u" "i" "l" "d")
+end
+rule list_fold
+	("List" /\//i "f" "o" "l" "d")
+end
+rule list_length
+	("List" /\//i "l" "e" "n" "g" "t" "h")
+end
+rule list_head
+	("List" /\//i "h" "e" "a" "d")
+end
+rule list_last
+	("List" /\//i "l" "a" "s" "t")
+end
+rule list_indexed
+	("List" /\//i "i" "n" "d" "e" "x" "e" "d")
+end
+rule list_reverse
+	("List" /\//i "r" "e" "v" "e" "r" "s" "e")
+end
+rule optional_fold
+	("Optional" /\//i "f" "o" "l" "d")
+end
+rule optional_build
+	("Optional" /\//i "b" "u" "i" "l" "d")
+end
+rule text_show
+	("Text" /\//i "s" "h" "o" "w")
+end
 rule combine
 	(/\u{2227}/i | (/(?:\/)(?:\u{5c})/i))
 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
@@ -184,13 +301,16 @@ rule integer_literal
 	(/[\u{2b}\u{2d}]/i (natural_literal)) <Dhall::Parser::IntegerLiteral>
 end
 rule identifier
-	((any_label) (((whsp) /@/i (whsp) (natural_literal))?)) <Dhall::Parser::Identifier>
+	((variable) | (builtin))
+end
+rule variable
+	((nonreserved_label) (((whsp) /@/i (whsp) (natural_literal))?)) <Dhall::Parser::Variable>
 end
 rule path_character
 	(/[!\u{24}-'\u{2a}\u{2b}\u{2d}\u{2e}0-;=@\u{5e}-z\u{7c}~]/i)
 end
 rule quoted_path_character
-	(/[\u{20}!\u{23}-\u{2e}0-@\u{5b}-\u{10ffff}]/i)
+	(/[\u{20}!\u{23}-\u{2e}0-@\u{5b}-\u{7f}]/i | (valid_non_ascii))
 end
 rule unquoted_path_component
 	((path_character)+)
@@ -220,19 +340,22 @@ rule absolute_path
 	(path) <Dhall::Parser::AbsolutePath>
 end
 rule scheme
-	("http" ("s"?))
+	("http" ("s"?)) <Dhall::Parser::Scheme>
 end
 rule http_raw
-	((scheme) /(?::(?:\/))(?:\/)/i (authority) (path) ((/\u{3f}/i (query))?))
+	((scheme) /(?::(?:\/))(?:\/)/i (authority) (url_path) ((/\u{3f}/i (query))?))
+end
+rule url_path
+	(((path_component) | (/\//i (segment)))*) <Dhall::Parser::UrlPath>
 end
 rule authority
-	((((userinfo) /@/i)?) (host) ((`:` (port))?))
+	((((userinfo) /@/i)?) (host) ((`:` (port))?)) <Dhall::Parser::Authority>
 end
 rule userinfo
 	(((unreserved) | (pct_encoded) | (sub_delims) | `:`)*)
 end
 rule host
-	((ip_literal) | (ipv4address) | (reg_name))
+	((ip_literal) | (ipv4address) | (domain))
 end
 rule port
 	((digit)*)
@@ -244,7 +367,7 @@ rule ipvfuture
 	(`v` ((hexdig)+) /\u{2e}/i (((unreserved) | (sub_delims) | `:`)+))
 end
 rule ipv6address
-	(((((h16) `:`) 6*6) (ls32)) | (`::` (((h16) `:`) 5*5) (ls32)) | (((h16)?) `::` (((h16) `:`) 4*4) (ls32)) | ((((((h16) `:`)?) (h16))?) `::` (((h16) `:`) 3*3) (ls32)) | ((((((h16) `:`) 0*2) (h16))?) `::` (((h16) `:`) 2*2) (ls32)) | ((((((h16) `:`) 0*3) (h16))?) `::` (h16) `:` (ls32)) | ((((((h16) `:`) 0*4) (h16))?) `::` (ls32)) | ((((((h16) `:`) 0*5) (h16))?) `::` (h16)) | ((((((h16) `:`) 0*6) (h16))?) `::`))
+	(((((h16) `:`) 6*6) (ls32)) | (`::` (((h16) `:`) 5*5) (ls32)) | (((h16)?) `::` (((h16) `:`) 4*4) (ls32)) | ((((h16) ((`:` (h16))?))?) `::` (((h16) `:`) 3*3) (ls32)) | ((((h16) ((`:` (h16)) 0*2))?) `::` (((h16) `:`) 2*2) (ls32)) | ((((h16) ((`:` (h16)) 0*3))?) `::` (h16) `:` (ls32)) | ((((h16) ((`:` (h16)) 0*4))?) `::` (ls32)) | ((((h16) ((`:` (h16)) 0*5))?) `::` (h16)) | ((((h16) ((`:` (h16)) 0*6))?) `::`))
 end
 rule h16
 	((hexdig) 1*4)
@@ -256,10 +379,16 @@ rule ipv4address
 	((dec_octet) /\u{2e}/i (dec_octet) /\u{2e}/i (dec_octet) /\u{2e}/i (dec_octet))
 end
 rule dec_octet
-	((digit) | (/[1-9]/i (digit)) | (`1` ((digit) 2*2)) | (/2(?:[0-4])/i (digit)) | (/25(?:[0-5])/i))
+	((/25(?:[0-5])/i) | (/2(?:[0-4])/i (digit)) | (`1` ((digit) 2*2)) | (/[1-9]/i (digit)) | (digit))
 end
-rule reg_name
-	(((unreserved) | (pct_encoded) | (sub_delims))*)
+rule domain
+	((domainlabel) ((/\u{2e}/i (domainlabel))*) (/\u{2e}/i?))
+end
+rule domainlabel
+	(((alphanum)+) (((/\u{2d}/i+) ((alphanum)+))*))
+end
+rule segment
+	((pchar)*)
 end
 rule pchar
 	((unreserved) | (pct_encoded) | (sub_delims) | /[:@]/i)
@@ -271,19 +400,19 @@ rule pct_encoded
 	(/%/i (hexdig) (hexdig))
 end
 rule unreserved
-	((alpha) | (digit) | /[\u{2d}\u{2e}_~]/i)
+	((alphanum) | /[\u{2d}\u{2e}_~]/i)
 end
 rule sub_delims
-	(/[!\u{24}&-,;=]/i)
+	(/[!\u{24}&'\u{2a}\u{2b};=]/i)
 end
 rule http
-	((http_raw) (((whsp) (using) (whsp1) ((import_hashed) | (/\u{28}/i (whsp) (import_hashed) (whsp) /\u{29}/i)))?)) <Dhall::Parser::Http>
+	((http_raw) (((whsp) (using) (whsp1) (import_expression))?)) <Dhall::Parser::Http>
 end
 rule env
 	(`env:` ((bash_environment_variable) | (/"/i (posix_environment_variable) /"/i))) <Dhall::Parser::Env>
 end
 rule bash_environment_variable
-	(((alpha) | `_`) (((alpha) | (digit) | `_`)*))
+	(((alpha) | `_`) (((alphanum) | `_`)*))
 end
 rule posix_environment_variable
 	((posix_environment_variable_character)+) <Dhall::Parser::PosixEnvironmentVariable>
@@ -301,10 +430,10 @@ rule import_hashed
 	((import_type) (((whsp1) (hash))?)) <Dhall::Parser::ImportHashed>
 end
 rule import
-	((import_hashed) (((whsp) (as) (whsp1) (text))?)) <Dhall::Parser::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) (whsp) (import_expression) (((whsp) `:` (whsp1) (application_expression))?)) | (/\u{5b}/i (whsp) ((empty_collection) | (non_empty_optional))) | (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>
@@ -312,11 +441,8 @@ end
 rule let_binding
 	((let) (whsp1) (nonreserved_label) (whsp) ((`:` (whsp1) (expression) (whsp))?) /=/i (whsp) (expression) (whsp)) <Dhall::Parser::LetBinding>
 end
-rule empty_collection
-	(/\u{5d}/i (whsp) `:` (whsp1) ((list) | (optional)) (whsp) (import_expression)) <Dhall::Parser::EmptyCollection>
-end
-rule non_empty_optional
-	((expression) (whsp) /\u{5d}/i (whsp) `:` (whsp1) (optional) (whsp) (import_expression)) <Dhall::Parser::NonEmptyOptional>
+rule empty_list_literal
+	(/\u{5b}/i (whsp) /\u{5d}/i (whsp) `:` (whsp1) (application_expression))
 end
 rule operator_expression
 	(import_alt_expression)
@@ -355,10 +481,16 @@ 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
-	((((some) (whsp1))?) (import_expression) (((whsp1) (import_expression))*)) <Dhall::Parser::ApplicationExpression>
+	((first_application_expression) (((whsp1) (import_expression))*)) <Dhall::Parser::ApplicationExpression>
+end
+rule first_application_expression
+	(((merge) (whsp1) (import_expression) (whsp1) (import_expression)) | ((some) (whsp1) (import_expression)) | ((tomap) (whsp1) (import_expression)) | (import_expression)) <Dhall::Parser::FirstApplicationExpression>
 end
 rule import_expression
 	((import) | (selector_expression))
@@ -367,13 +499,16 @@ rule selector_expression
 	((primitive_expression) (((whsp) /\u{2e}/i (whsp) (selector))*)) <Dhall::Parser::SelectorExpression>
 end
 rule selector
-	((any_label) | (labels))
+	((any_label) | (labels) | (type_selector)) <Dhall::Parser::Selector>
 end
 rule labels
-	(/\u{7b}/i (whsp) (((any_label) (whsp) ((/,/i (whsp) (any_label) (whsp))*))?) /\u{7d}/i) <Dhall::Parser::Labels>
+	(/\u{7b}/i (whsp) (((any_label) (whsp) ((/,/i (whsp) (any_label) (whsp))*))?) /\u{7d}/i)
+end
+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))
@@ -399,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
@@ -462,39 +591,4 @@ end
 rule wsp
 	((sp) | (htab))
 end
-rule reserved_identifier
-	"Natural/build" |
-	"Natural/fold" |
-	"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" |
-	"Optional" |
-	"Natural" |
-	"Integer" |
-	"Double" |
-	"Text" |
-	"List" |
-	"True" |
-	"False" |
-	"None" |
-	"Type" |
-	"Kind" |
-	"Sort"
-end
 end