dhall 0.3.0 → 0.5.2

data/lib/dhall/coder.rb

@@ -105,7 +105,12 @@ module Dhall
 
 			refine List do
 				def to_ruby(&decode)
-					to_a.map(&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
 

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,7 +131,7 @@ module Dhall
 		end
 	end
 
-	class FunctionProxy
+	class FunctionProxyRaw
 		def shift(*)
 			self
 		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
 
@@ -245,7 +261,7 @@ module Dhall
 
 	class EmptyList
 		def normalize
-			super.with(element_type: element_type.normalize)
+			super.with(type: type.normalize)
 		end
 	end
 
@@ -265,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
@@ -316,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
 
@@ -415,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

@@ -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)
@@ -10,13 +13,13 @@ rule block_comment
 	(/(?:\u{7b})(?:\u{2d})/i (block_comment_continue))
 end
 rule block_comment_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 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*))
@@ -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,11 +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) | (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")
@@ -147,6 +162,9 @@ end
 rule list
 	("List")
 end
+rule location
+	("Location")
+end
 rule bool
 	("Bool")
 end
@@ -198,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
@@ -243,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
@@ -286,7 +310,7 @@ 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)+)
@@ -316,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)*)
@@ -354,8 +381,14 @@ end
 rule dec_octet
 	((/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)
@@ -367,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>
@@ -397,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) (whsp1) (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>
@@ -408,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)
@@ -451,13 +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
 	((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)) | (import_expression)) <Dhall::Parser::FirstApplicationExpression>
+	(((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))
@@ -466,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))
@@ -498,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