dhall 0.1.0

data/lib/dhall/normalize.rb

@@ -0,0 +1,420 @@
+# frozen_string_literal: true
+
+require "dhall/builtins"
+require "dhall/visitor"
+require "dhall/util"
+
+module Dhall
+	module 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
+			)
+		end
+	end
+
+	class Expression
+		def normalize
+			with(ExpressionVisitor.new(&:normalize).visit(self))
+		end
+
+		def shift(amount, name, min_index)
+			with(ExpressionVisitor.new { |expr|
+				expr.shift(amount, name, min_index)
+			}.visit(self))
+		end
+
+		def substitute(var, with_expr)
+			with(ExpressionVisitor.new { |expr|
+				expr.substitute(var, with_expr)
+			}.visit(self))
+		end
+
+		def fusion(*); end
+	end
+
+	class Application
+		def normalize
+			return fuse.normalize if fuse
+
+			normalized = super
+			return normalized.fuse if normalized.fuse
+
+			if normalized.function.is_a?(Builtin) ||
+			   normalized.function.is_a?(Function) ||
+			   normalized.function.is_a?(RecordSelection)
+				return normalized.function.call(normalized.argument)
+			end
+
+			normalized
+		end
+
+		def fuse
+			if function.is_a?(Application)
+				@fuse ||= function.function.fusion(function.argument, argument)
+				return @fuse if @fuse
+			end
+
+			@fuse ||= function.fusion(argument)
+		end
+	end
+
+	class Function
+		@@alpha_normalization = true
+
+		def self.disable_alpha_normalization!
+			@@alpha_normalization = false
+		end
+
+		def self.enable_alpha_normalization!
+			@@alpha_normalization = true
+		end
+
+		def shift(amount, name, min_index)
+			return super unless var == name
+
+			with(
+				type: type.shift(amount, name, min_index),
+				body: body.shift(amount, name, min_index + 1)
+			)
+		end
+
+		def substitute(svar, with_expr)
+			with(
+				type: type&.substitute(svar, with_expr),
+				body: body.substitute(
+					var == svar.name ? svar.with(index: svar.index + 1) : svar,
+					with_expr.shift(1, var, 0)
+				)
+			)
+		end
+
+		def normalize
+			return super unless alpha_normalize?
+			with(
+				var:  "_",
+				type: type&.normalize,
+				body: body
+				      .shift(1, "_", 0)
+				      .substitute(Variable[var], Variable["_"])
+				      .shift(-1, var, 0)
+				      .normalize
+			)
+		end
+
+		protected
+
+		def alpha_normalize?
+			var != "_" && @@alpha_normalization
+		end
+	end
+
+	class Forall; end
+
+	class Bool
+	end
+
+	class Variable
+		def shift(amount, name, min_index)
+			return self if self.name != name || min_index > index
+
+			with(index: index + amount)
+		end
+
+		def substitute(var, with_expr)
+			self == var ? with_expr : self
+		end
+	end
+
+	class Operator
+		class Or
+			def normalize
+				lhs.normalize | rhs.normalize
+			end
+		end
+
+		class And
+			def normalize
+				lhs.normalize & rhs.normalize
+			end
+		end
+
+		class Equal
+			def normalize
+				lhs.normalize.dhall_eq(rhs.normalize)
+			end
+		end
+
+		class NotEqual
+			def normalize
+				normalized = super
+				if normalized.lhs == Bool.new(value: false)
+					normalized.rhs
+				elsif normalized.rhs == Bool.new(value: false)
+					normalized.lhs
+				elsif normalized.lhs == normalized.rhs
+					Bool.new(value: false)
+				else
+					normalized
+				end
+			end
+		end
+
+		class Plus
+			def normalize
+				normalized = super
+				if normalized.lhs == Natural.new(value: 0)
+					normalized.rhs
+				elsif normalized.rhs == Natural.new(value: 0)
+					normalized.lhs
+				else
+					normalized.lhs + normalized.rhs
+				end
+			end
+		end
+
+		class Times
+			def normalize
+				normalized = super
+				if normalized.lhs == Natural.new(value: 1)
+					normalized.rhs
+				elsif normalized.rhs == Natural.new(value: 1)
+					normalized.lhs
+				else
+					normalized.lhs * normalized.rhs
+				end
+			end
+		end
+
+		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
+			end
+		end
+
+		class ListConcatenate
+			def normalize
+				normalized = super
+				case normalized.rhs
+				when EmptyList
+					normalized.lhs
+				else
+					normalized.lhs.concat(normalized.rhs)
+				end
+			end
+		end
+
+		class RecursiveRecordMerge
+			def normalize
+				lhs.normalize.deep_merge(rhs.normalize)
+			end
+		end
+
+		class RightBiasedRecordMerge
+			def normalize
+				lhs.normalize.merge(rhs.normalize)
+			end
+		end
+
+		class RecursiveRecordTypeMerge
+			def normalize
+				lhs.normalize.deep_merge_type(rhs.normalize)
+			end
+		end
+	end
+
+	class EmptyList
+		def normalize
+			super.with(element_type: element_type.normalize)
+		end
+	end
+
+	class Optional
+		def normalize
+			with(
+				value:      value.normalize,
+				value_type: value_type&.normalize,
+				normalized: true
+			)
+		end
+	end
+
+	class OptionalNone
+		def normalize
+			with(value_type: value_type.normalize)
+		end
+	end
+
+	class Merge
+		def normalize
+			normalized = super
+			if normalized.record.is_a?(Record) && normalized.input.is_a?(Union)
+				fetched = normalized.record.fetch(normalized.input.tag)
+				value = normalized.input.value
+				value.nil? ? fetched : fetched.call(value)
+			else
+				normalized
+			end
+		end
+	end
+
+	class Record
+		def normalize
+			with(record: Hash[
+				record.map { |k, v| [k, v.nil? ? v : v.normalize] }.sort
+			])
+		end
+
+		def shift(amount, name, min_index)
+			with(record: Hash[
+				record.map { |k, v|
+					[k, v.nil? ? v : v.shift(amount, name, min_index)]
+				}.sort
+			])
+		end
+
+		def substitute(var, with_expr)
+			with(record: Hash[
+				record.map { |k, v|
+					[k, v.nil? ? v : v.substitute(var, with_expr)]
+				}.sort
+			])
+		end
+	end
+
+	class EmptyRecord
+		def normalize
+			self
+		end
+	end
+
+	class RecordSelection
+		def normalize
+			record.normalize.fetch(selector)
+		end
+	end
+
+	class RecordProjection
+		def normalize
+			record.normalize.slice(*selectors)
+		end
+	end
+
+	class EmptyRecordProjection
+		def normalize
+			EmptyRecord.new
+		end
+	end
+
+	class UnionType
+		def normalize
+			with(alternatives: Hash[super.alternatives.sort])
+		end
+	end
+
+	class Union
+		def normalize
+			val = if value.is_a?(TypeAnnotation)
+				value.with(ExpressionVisitor.new(&:normalize).visit(value))
+			else
+				value&.normalize
+			end
+
+			with(value: val, alternatives: alternatives.normalize)
+		end
+	end
+
+	class If
+		def normalize
+			normalized = super
+			if normalized.predicate.is_a?(Bool)
+				normalized.predicate.reduce(normalized.then, normalized.else)
+			elsif normalized.trivial?
+				normalized.predicate
+			elsif normalized.then == normalized.else
+				normalized.then
+			else
+				normalized
+			end
+		end
+
+		def trivial?
+			self.then == Bool.new(value: true) &&
+				self.else == Bool.new(value: false)
+		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)
+		end
+
+		def flatten
+			with(chunks: chunks.flat_map do |chunk|
+				chunk.is_a?(TextLiteral) ? chunk.chunks : chunk
+			end)
+		end
+	end
+
+	class Import
+	end
+
+	class LetIn
+		def normalize
+			desugar.normalize
+		end
+
+		def shift(amount, name, min_index)
+			return super unless let.var == name
+
+			with(
+				let:  let.shift(amount, name, min_index),
+				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)
+		end
+	end
+
+	class TypeAnnotation
+		def normalize
+			value.normalize
+		end
+	end
+end

data/lib/dhall/parser.citrus

@@ -0,0 +1,500 @@
+grammar Dhall::Parser::CitrusParser
+	root complete_expression
+rule end_of_line
+	(/\n/i | (/(?:\r)(?:\n)/i))
+end
+rule tab
+	(/\t/i)
+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))
+end
+rule block_comment_continue
+	((/(?:\u{2d})(?:\u{7d})/i) | ((block_comment_chunk) (block_comment_continue)))
+end
+rule not_end_of_line
+	(/[\u{20}-@\u{5b}-\u{10ffff}]/i | (tab))
+end
+rule line_comment
+	(/(?:\u{2d})(?:\u{2d})/i ((not_end_of_line)*) (end_of_line))
+end
+rule whitespace_chunk
+	(/\u{20}/i | (tab) | (end_of_line) | (line_comment) | (block_comment))
+end
+rule whsp
+	((whitespace_chunk)*)
+end
+rule whsp1
+	((whitespace_chunk)+)
+end
+rule alpha
+	(/[a-z]/i)
+end
+rule digit
+	(/\d/i)
+end
+rule hexdig
+	((digit) | /[a-f]/i | (digit) | /[a-f]/i)
+end
+rule simple_label_first_char
+	((alpha) | `_`)
+end
+rule simple_label_next_char
+	((alpha) | (digit) | /[\u{2d}\/_]/i)
+end
+rule simple_label
+	(keyword simple_label_next_char+ | !keyword (simple_label_first_char simple_label_next_char*))
+end
+rule quoted_label_char
+	(/[\u{20}-@\u{5b}-_a-~]/i)
+end
+rule quoted_label
+	((quoted_label_char)+)
+end
+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>
+end
+rule any_label
+	(label)
+end
+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>
+end
+rule double_quote_char
+	(/[\u{20}!\u{23}-@\u{5b}\u{5d}-\u{10ffff}]/i)
+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>
+end
+rule escaped_quote_pair
+	(`'''`) <Dhall::Parser::EscapedQuotePair>
+end
+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))
+end
+rule single_quote_literal
+	(`''` (end_of_line) (single_quote_continue)) <Dhall::Parser::SingleQuoteLiteral>
+end
+rule interpolation
+	(/(?:\u{24})(?:\u{7b})/i (complete_expression) /\u{7d}/i) <Dhall::Parser::Interpolation>
+end
+rule text_literal
+	((double_quote_literal) | (single_quote_literal))
+end
+rule if
+	("if")
+end
+rule then
+	("then")
+end
+rule else
+	("else")
+end
+rule let
+	("let")
+end
+rule in
+	("in")
+end
+rule as
+	("as")
+end
+rule using
+	("using")
+end
+rule merge
+	("merge")
+end
+rule missing
+	("missing") <Dhall::Parser::Missing>
+end
+rule infinity
+	("Infinity")
+end
+rule nan
+	("NaN") <Dhall::Parser::Nan>
+end
+rule some
+	("Some")
+end
+rule keyword
+	((if) | (then) | (else) | (let) | (in) | (using) | (missing) | (as) | (infinity) | (nan) | (merge) | (some))
+end
+rule optional
+	("Optional")
+end
+rule text
+	("Text")
+end
+rule list
+	("List")
+end
+rule combine
+	(/\u{2227}/i | (/(?:\/)(?:\u{5c})/i))
+end
+rule combine_types
+	(/\u{2a53}/i | (/(?:(?:(?:\/)(?:\/))(?:\u{5c}))(?:\u{5c})/i))
+end
+rule prefer
+	(/\u{2afd}/i | (/(?:\/)(?:\/)/i))
+end
+rule lambda
+	(/[\u{5c}\u{3bb}]/i)
+end
+rule forall
+	(/\u{2200}/i | ("forall"))
+end
+rule arrow
+	(/\u{2192}/i | (/(?:\u{2d})(?:>)/i))
+end
+rule exponent
+	(`e` (/[\u{2b}\u{2d}]/i?) ((digit)+))
+end
+rule numeric_double_literal
+	((/[\u{2b}\u{2d}]/i?) ((digit)+) ((/\u{2e}/i ((digit)+) ((exponent)?)) | (exponent))) <Dhall::Parser::NumericDoubleLiteral>
+end
+rule minus_infinity_literal
+	(/\u{2d}/i (infinity)) <Dhall::Parser::MinusInfinityLiteral>
+end
+rule plus_infinity_literal
+	(infinity) <Dhall::Parser::PlusInfinityLiteral>
+end
+rule double_literal
+	((numeric_double_literal) | (minus_infinity_literal) | (plus_infinity_literal) | (nan))
+end
+rule natural_literal
+	((digit)+) <Dhall::Parser::NaturalLiteral>
+end
+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>
+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)
+end
+rule unquoted_path_component
+	((path_character)+)
+end
+rule quoted_path_component
+	((quoted_path_character)+)
+end
+rule path_component
+	(/\//i ((unquoted_path_component) | (/"/i (quoted_path_component) /"/i))) <Dhall::Parser::PathComponent>
+end
+rule path
+	((path_component)+) <Dhall::Parser::Path>
+end
+rule local
+	((parent_path) | (here_path) | (home_path) | (absolute_path))
+end
+rule parent_path
+	(/(?:\u{2e})(?:\u{2e})/i (path)) <Dhall::Parser::ParentPath>
+end
+rule here_path
+	(/\u{2e}/i (path)) <Dhall::Parser::HerePath>
+end
+rule home_path
+	(/~/i (path)) <Dhall::Parser::HomePath>
+end
+rule absolute_path
+	(path) <Dhall::Parser::AbsolutePath>
+end
+rule scheme
+	("http" ("s"?))
+end
+rule http_raw
+	((scheme) /(?::(?:\/))(?:\/)/i (authority) (path) ((/\u{3f}/i (query))?))
+end
+rule authority
+	((((userinfo) /@/i)?) (host) ((`:` (port))?))
+end
+rule userinfo
+	(((unreserved) | (pct_encoded) | (sub_delims) | `:`)*)
+end
+rule host
+	((ip_literal) | (ipv4address) | (reg_name))
+end
+rule port
+	((digit)*)
+end
+rule ip_literal
+	(/\u{5b}/i ((ipv6address) | (ipvfuture)) /\u{5d}/i)
+end
+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))?) `::`))
+end
+rule h16
+	((hexdig) 1*4)
+end
+rule ls32
+	(((h16) `:` (h16)) | (ipv4address))
+end
+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))
+end
+rule reg_name
+	(((unreserved) | (pct_encoded) | (sub_delims))*)
+end
+rule pchar
+	((unreserved) | (pct_encoded) | (sub_delims) | /[:@]/i)
+end
+rule query
+	(((pchar) | /[\/\u{3f}]/i)*)
+end
+rule pct_encoded
+	(/%/i (hexdig) (hexdig))
+end
+rule unreserved
+	((alpha) | (digit) | /[\u{2d}\u{2e}_~]/i)
+end
+rule sub_delims
+	(/[!\u{24}&-,;=]/i)
+end
+rule http
+	((http_raw) (((whsp) (using) (whsp1) ((import_hashed) | (/\u{28}/i (whsp) (import_hashed) (whsp) /\u{29}/i)))?)) <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) | `_`)*))
+end
+rule posix_environment_variable
+	((posix_environment_variable_character)+) <Dhall::Parser::PosixEnvironmentVariable>
+end
+rule posix_environment_variable_character
+	((/\u{5c}/i /["\u{5c}abfnrtv]/) | /[\u{20}!\u{23}-<>-@\u{5b}\u{5d}-~]/i) <Dhall::Parser::PosixEnvironmentVariableCharacter>
+end
+rule import_type
+	((missing) | (local) | (http) | (env))
+end
+rule hash
+	("sha" `2` `5` `6` `:` ((hexdig) 64*64)) <Dhall::Parser::Hash>
+end
+rule import_hashed
+	((import_type) (((whsp1) (hash))?)) <Dhall::Parser::ImportHashed>
+end
+rule import
+	((import_hashed) (((whsp) (as) (whsp1) (text))?)) <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>
+end
+rule annotated_expression
+	((operator_expression) (((whsp) `:` (whsp1) (expression))?)) <Dhall::Parser::AnnotatedExpression>
+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>
+end
+rule operator_expression
+	(import_alt_expression)
+end
+rule import_alt_expression
+	((or_expression) (((whsp) /\u{3f}/i (whsp1) (or_expression))*)) <Dhall::Parser::ImportAltExpression>
+end
+rule or_expression
+	((plus_expression) (((whsp) /(?:\u{7c})(?:\u{7c})/i (whsp) (plus_expression))*)) <Dhall::Parser::OrExpression>
+end
+rule plus_expression
+	((text_append_expression) (((whsp) /\u{2b}/i (whsp1) (text_append_expression))*)) <Dhall::Parser::PlusExpression>
+end
+rule text_append_expression
+	((list_append_expression) (((whsp) /(?:\u{2b})(?:\u{2b})/i (whsp) (list_append_expression))*)) <Dhall::Parser::TextAppendExpression>
+end
+rule list_append_expression
+	((and_expression) (((whsp) /\u{23}/i (whsp) (and_expression))*)) <Dhall::Parser::ListAppendExpression>
+end
+rule and_expression
+	((combine_expression) (((whsp) /(?:&)(?:&)/i (whsp) (combine_expression))*)) <Dhall::Parser::AndExpression>
+end
+rule combine_expression
+	((prefer_expression) (((whsp) (combine) (whsp) (prefer_expression))*)) <Dhall::Parser::CombineExpression>
+end
+rule prefer_expression
+	((combine_types_expression) (((whsp) (prefer) (whsp) (combine_types_expression))*)) <Dhall::Parser::PreferExpression>
+end
+rule combine_types_expression
+	((times_expression) (((whsp) (combine_types) (whsp) (times_expression))*)) <Dhall::Parser::CombineTypesExpression>
+end
+rule times_expression
+	((equal_expression) (((whsp) /\u{2a}/i (whsp) (equal_expression))*)) <Dhall::Parser::TimesExpression>
+end
+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>
+end
+rule application_expression
+	((((some) (whsp1))?) (import_expression) (((whsp1) (import_expression))*)) <Dhall::Parser::ApplicationExpression>
+end
+rule import_expression
+	((import) | (selector_expression))
+end
+rule selector_expression
+	((primitive_expression) (((whsp) /\u{2e}/i (whsp) (selector))*)) <Dhall::Parser::SelectorExpression>
+end
+rule selector
+	((any_label) | (labels))
+end
+rule labels
+	(/\u{7b}/i (whsp) (((any_label) (whsp) ((/,/i (whsp) (any_label) (whsp))*))?) /\u{7d}/i) <Dhall::Parser::Labels>
+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>
+end
+rule record_type_or_literal
+	((empty_record_literal) | (non_empty_record_type_or_literal) | (empty_record_type))
+end
+rule empty_record_literal
+	(/=/i) <Dhall::Parser::EmptyRecordLiteral>
+end
+rule empty_record_type
+	("") <Dhall::Parser::EmptyRecordType>
+end
+rule non_empty_record_type_or_literal
+	((any_label) (whsp) ((non_empty_record_literal) | (non_empty_record_type))) <Dhall::Parser::NonEmptyRecordTypeOrLiteral>
+end
+rule non_empty_record_type
+	(`:` (whsp1) (expression) (((whsp) /,/i (whsp) (record_type_entry))*)) <Dhall::Parser::NonEmptyRecordType>
+end
+rule record_type_entry
+	((any_label) (whsp) `:` (whsp1) (expression)) <Dhall::Parser::RecordTypeEntry>
+end
+rule non_empty_record_literal
+	(/=/i (whsp) (expression) (((whsp) /,/i (whsp) (record_literal_entry))*)) <Dhall::Parser::NonEmptyRecordLiteral>
+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))
+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>
+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
+rule complete_expression
+	((whsp) (expression) (whsp)) <Dhall::Parser::CompleteExpression>
+end
+rule bit
+	(/[01]/i)
+end
+rule char
+	(/[\u{01}-@\u{5b}-\u{7f}]/i)
+end
+rule cr
+	(/\r/i)
+end
+rule crlf
+	((cr) (lf))
+end
+rule ctl
+	(/[\u{00}-\u{1f}\u{7f}]/i)
+end
+rule dquote
+	(/"/i)
+end
+rule htab
+	(/\t/i)
+end
+rule lf
+	(/\n/i)
+end
+rule lwsp
+	(((wsp) | ((crlf) (wsp)))*)
+end
+rule octet
+	(/[\u{00}-@\u{5b}-\u{ff}]/i)
+end
+rule sp
+	(/\u{20}/i)
+end
+rule vchar
+	(/[!-@\u{5b}-~]/i)
+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