dhall 0.3.0 → 0.5.2

data/lib/dhall/binary.rb

@@ -2,9 +2,11 @@
 
 require "cbor"
 require "digest/sha2"
+require "multihashes"
 
 require "dhall/ast"
 require "dhall/builtins"
+require "dhall/parser"
 
 module Dhall
 	def self.from_binary(cbor_binary)
@@ -34,10 +36,13 @@ module Dhall
 				CBOR.encode(as_json)
 			end
 		end
-		alias to_binary to_cbor
+
+		def to_binary
+			CBOR.encode(::CBOR::Tagged.new(55799, self))
+		end
 
 		def digest(digest: Digest::SHA2.new(256))
-			(digest << normalize.to_binary).freeze
+			(digest << normalize.to_cbor).freeze
 		end
 
 		def cache_key
@@ -80,15 +85,21 @@ module Dhall
 
 	class List
 		def self.decode(type, *els)
-			type = type.nil? ? nil : Dhall.decode(type)
+			type = type.nil? ? nil : Builtins[:List].call(Dhall.decode(type))
 			if els.empty?
-				EmptyList.new(element_type: type)
+				EmptyList.new(type: type)
 			else
-				List.new(elements: els.map(&Dhall.method(:decode)), element_type: type)
+				List.new(elements: els.map(&Dhall.method(:decode)), type: type)
 			end
 		end
 	end
 
+	class EmptyList
+		def self.decode(type)
+			EmptyList.new(type: Dhall.decode(type))
+		end
+	end
+
 	class Optional
 		def self.decode(type, value=nil)
 			if value.nil?
@@ -102,6 +113,15 @@ module Dhall
 		end
 	end
 
+	class ToMap
+		def self.decode(record, type=nil)
+			new(
+				record: Dhall.decode(record),
+				type:   type.nil? ? nil : Dhall.decode(type)
+			)
+		end
+	end
+
 	class Merge
 		def self.decode(record, input, type=nil)
 			new(
@@ -140,10 +160,14 @@ module Dhall
 
 	class RecordProjection
 		def self.decode(record, *selectors)
-			if selectors.empty?
-				EmptyRecordProjection.new(record: Dhall.decode(record))
+			record = Dhall.decode(record)
+			if selectors.length == 1 && selectors[0].is_a?(Array)
+				RecordProjectionByExpression.new(
+					record:   record,
+					selector: Dhall.decode(selectors[0][0])
+				)
 			else
-				new(record: Dhall.decode(record), selectors: selectors)
+				self.for(record, selectors)
 			end
 		end
 	end
@@ -189,30 +213,79 @@ 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)
+				return unless integrity_check
+
+				IntegrityCheck.new(
+					Multihashes.decode(integrity_check).select { |k, _|
+						[:code, :digest].include?(k)
+					}
+				)
+			end
+		end
+
+		class URI
+			def self.decode(headers, authority, *path, query)
+				uri = ::URI.scheme_list[name.split(/::/).last.upcase].build(
+					Parser.parse(authority, root: :authority).value.merge(
+						path: "/#{path.join("/")}"
+					)
+				)
+				uri.instance_variable_set(:@query, query)
+				new(headers: headers, uri: uri)
+			end
+		end
+
+		class Path
+			def self.decode(*args)
+				new(*args)
+			end
+		end
+
+		class EnvironmentVariable
+			def self.decode(*args)
+				new(*args)
+			end
+		end
+
+		class MissingImport
+			def self.decode(*args)
+				new(*args)
+			end
+		end
+
 		def self.decode(integrity_check, import_type, path_type, *parts)
 			parts[0] = Dhall.decode(parts[0]) if path_type < 2 && !parts[0].nil?
+			path_type = PATH_TYPES.fetch(path_type)
 
 			new(
-				IntegrityCheck.new(*integrity_check),
+				IntegrityCheck.decode(integrity_check),
 				IMPORT_TYPES[import_type],
-				PATH_TYPES[path_type].new(*parts)
+				path_type.decode(*parts)
 			)
 		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
 
@@ -268,13 +341,15 @@ module Dhall
 		Integer,
 		nil,
 		TextLiteral,
-		nil,
+		Assertion,
 		nil,
 		nil,
 		nil,
 		nil,
 		Import,
-		LetBlock,
-		TypeAnnotation
+		LetIn,
+		TypeAnnotation,
+		ToMap,
+		EmptyList
 	].freeze
 end

data/lib/dhall/builtins.rb

@@ -6,93 +6,74 @@ module Dhall
 	class Builtin < Expression
 		include(ValueSemantics.for_attributes {})
 
-		def call(*args)
-			# Do not auto-normalize builtins to avoid recursion loop
-			args.reduce(self) do |f, arg|
+		def as_json
+			self.class.name&.split(/::/)&.last&.tr("_", "/").to_s
+		end
+	end
+
+	class BuiltinFunction < Builtin
+		include(ValueSemantics.for_attributes do
+			partial_application ArrayOf(Expression), default: []
+		end)
+
+		def unfill(*args)
+			(args.empty? ? partial_application : args).reduce(self.class.new) do |f, arg|
 				Application.new(function: f, argument: arg)
 			end
 		end
 
-		def unfill
-			attributes.reduce(self.class.new) do |f, attr|
-				if send(attr.name).nil?
-					f
-				else
-					Application.new(function: f, argument: send(attr.name))
-				end
+		def call(*new_args)
+			args = partial_application + new_args
+			if args.length == method(:uncurried_call).arity
+				uncurried_call(*args)
+			else
+				with(partial_application: args)
 			end
 		end
 
 		def as_json
-			if (unfilled = unfill).class != self.class
+			if (unfilled = unfill) != self
 				unfilled.as_json
 			else
-				self.class.name&.split(/::/)&.last&.tr("_", "/").to_s
+				super
 			end
 		end
+	end
 
-		protected
+	module Builtins
+		# rubocop:disable Style/ClassAndModuleCamelCase
 
-		def attributes
-			self.class.value_semantics.attributes
-		end
+		class Double_show < BuiltinFunction
+			protected
 
-		def fill_next_if_valid(value)
-			with(attributes.each_with_object({}) do |attr, h|
-				if !send(attr.name).nil?
-					h[attr.name] = send(attr.name)
-				elsif attr.validate?(value)
-					h[attr.name] = value
-					value = nil
-				else
-					return nil
-				end
-			end)
-		end
+			def uncurried_call(arg)
+				return unfill(arg) unless arg.is_a?(Dhall::Double)
 
-		def full?
-			attributes.all? { |attr| !send(attr.name).nil? }
+				Dhall::Text.new(value: arg.to_s)
+			end
 		end
 
-		def fill_or_call(arg, &block)
-			full? ? block[arg] : fill_next_if_valid(arg)
-		end
-	end
+		class Integer_show < BuiltinFunction
+			protected
 
-	module Builtins
-		# rubocop:disable Style/ClassAndModuleCamelCase
+			def uncurried_call(arg)
+				return unfill(arg) unless arg.is_a?(Dhall::Integer)
 
-		class Double_show < Builtin
-			def call(arg)
-				if arg.is_a?(Dhall::Double)
-					Dhall::Text.new(value: arg.to_s)
-				else
-					super
-				end
+				Dhall::Text.new(value: arg.to_s)
 			end
 		end
 
-		class Integer_show < Builtin
-			def call(arg)
-				if arg.is_a?(Dhall::Integer)
-					Dhall::Text.new(value: arg.to_s)
-				else
-					super
-				end
-			end
-		end
+		class Integer_toDouble < BuiltinFunction
+			protected
 
-		class Integer_toDouble < Builtin
-			def call(arg)
-				if arg.is_a?(Dhall::Integer)
-					Dhall::Double.new(value: arg.value.to_f)
-				else
-					super
-				end
+			def uncurried_call(arg)
+				return unfill(arg) unless arg.is_a?(Dhall::Integer)
+
+				Dhall::Double.new(value: arg.value.to_f)
 			end
 		end
 
-		class Natural_build < Builtin
+		class Natural_build < BuiltinFunction
 			def fusion(arg, *bogus)
 				if bogus.empty? &&
 				   arg.is_a?(Application) &&
@@ -103,7 +84,9 @@ module Dhall
 				end
 			end
 
-			def call(arg)
+			protected
+
+			def uncurried_call(arg)
 				arg.call(
 					Natural.new,
 					Function.of_arguments(
@@ -115,79 +98,91 @@ module Dhall
 			end
 		end
 
-		class Natural_even < Builtin
-			def call(nat)
-				if nat.is_a?(Dhall::Natural)
-					Dhall::Bool.new(value: nat.even?)
-				else
-					super
+		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_fold < Builtin
-			include(ValueSemantics.for_attributes do
-				nat  Either(nil, Dhall::Natural), default: nil
-				type Either(nil, Expression),     default: nil
-				f    Either(nil, Expression),     default: nil
-			end)
+		class Natural_even < BuiltinFunction
+			protected
 
-			def call(arg)
-				fill_or_call(arg) do
-					if @nat.zero?
-						arg.normalize
-					else
-						@f.call(with(nat: nat.pred).call(arg))
-					end
-				end || super
+			def uncurried_call(nat)
+				return unfill(nat) unless nat.is_a?(Dhall::Natural)
+
+				Dhall::Bool.new(value: nat.even?)
 			end
 		end
 
-		class Natural_isZero < Builtin
-			def call(nat)
-				if nat.is_a?(Dhall::Natural)
-					Dhall::Bool.new(value: nat.zero?)
+		class Natural_fold < BuiltinFunction
+			protected
+
+			def uncurried_call(nat, type, f, z)
+				return unfill(nat, type, f, z) unless nat.is_a?(Dhall::Natural)
+
+				if nat.zero?
+					z.normalize
 				else
-					super
+					f.call(Natural_fold.new.call(nat.pred, type, f, z))
 				end
 			end
 		end
 
-		class Natural_odd < Builtin
-			def call(nat)
-				if nat.is_a?(Dhall::Natural)
-					Dhall::Bool.new(value: nat.odd?)
-				else
-					super
-				end
+		class Natural_isZero < BuiltinFunction
+			protected
+
+			def uncurried_call(nat)
+				return unfill(nat) unless nat.is_a?(Dhall::Natural)
+
+				Dhall::Bool.new(value: nat.zero?)
 			end
 		end
 
-		class Natural_show < Builtin
-			def call(nat)
-				if nat.is_a?(Dhall::Natural)
-					Dhall::Text.new(value: nat.to_s)
-				else
-					super
-				end
+		class Natural_odd < BuiltinFunction
+			protected
+
+			def uncurried_call(nat)
+				return unfill(nat) unless nat.is_a?(Dhall::Natural)
+
+				Dhall::Bool.new(value: nat.odd?)
 			end
 		end
 
-		class Natural_toInteger < Builtin
-			def call(nat)
-				if nat.is_a?(Dhall::Natural)
-					Dhall::Integer.new(value: nat.value)
-				else
-					super
-				end
+		class Natural_show < BuiltinFunction
+			protected
+
+			def uncurried_call(nat)
+				return unfill(nat) unless nat.is_a?(Dhall::Natural)
+
+				Dhall::Text.new(value: nat.to_s)
 			end
 		end
 
-		class List_build < Builtin
-			include(ValueSemantics.for_attributes do
-				type Either(nil, Expression), default: nil
-			end)
+		class Natural_toInteger < BuiltinFunction
+			protected
 
+			def uncurried_call(nat)
+				return unfill(nat) unless nat.is_a?(Dhall::Natural)
+
+				Dhall::Integer.new(value: nat.value)
+			end
+		end
+
+		class List_build < BuiltinFunction
 			def fusion(*args)
 				_, arg, = args
 				if arg.is_a?(Application) &&
@@ -199,19 +194,17 @@ module Dhall
 				end
 			end
 
-			def call(arg)
-				fill_or_call(arg) do
-					arg.call(
-						List.new.call(type),
-						cons,
-						EmptyList.new(element_type: type)
-					)
-				end
-			end
-
 			protected
 
-			def cons
+			def uncurried_call(type, arg)
+				arg.call(
+					List.new.call(type),
+					cons(type),
+					EmptyList.new(element_type: type)
+				)
+			end
+
+			def cons(type)
 				Function.of_arguments(
 					type,
 					List.new.call(type.shift(1, "_", 0)),
@@ -220,56 +213,33 @@ module Dhall
 			end
 		end
 
-		class List_fold < Builtin
-			include(ValueSemantics.for_attributes do
-				ltype Either(nil, Expression), default: nil
-				list  Either(nil, List),       default: nil
-				ztype Either(nil, Expression), default: nil
-				f     Either(nil, Expression), default: nil
-			end)
-
-			def call(arg)
-				fill_or_call(arg) do
-					list.reduce(arg, &f).normalize
-				end || super
-			end
-		end
+		class List_fold < BuiltinFunction
+			protected
 
-		class List_head < Builtin
-			include(ValueSemantics.for_attributes do
-				type Either(nil, Expression), default: nil
-			end)
+			def uncurried_call(ltype, list, ztype, f, z)
+				return unfill(ltype, list, ztype, f, z) unless list.is_a?(Dhall::List)
 
-			def call(arg)
-				fill_or_call(arg) do
-					if arg.is_a?(Dhall::List)
-						arg.first
-					else
-						super
-					end
-				end
+				list.reduce(z, &f).normalize
 			end
 		end
 
-		class List_indexed < Builtin
-			include(ValueSemantics.for_attributes do
-				type Either(nil, Expression), default: nil
-			end)
+		class List_head < BuiltinFunction
+			protected
+
+			def uncurried_call(type, list)
+				return unfill(type, list) unless list.is_a?(Dhall::List)
 
-			def call(arg)
-				fill_or_call(arg) do
-					if arg.is_a?(Dhall::List)
-						_call(arg)
-					else
-						super
-					end
-				end
+				list.first
 			end
+		end
 
+		class List_indexed < BuiltinFunction
 			protected
 
-			def _call(arg)
-				arg.map(type: indexed_type(type)) { |x, idx|
+			def uncurried_call(type, list)
+				return unfill(type, list) unless list.is_a?(Dhall::List)
+
+				list.map(type: indexed_type(type)) { |x, idx|
 					Record.new(
 						record: {
 							"index" => Dhall::Natural.new(value: idx),
@@ -289,59 +259,37 @@ module Dhall
 			end
 		end
 
-		class List_last < Builtin
-			include(ValueSemantics.for_attributes do
-				type Either(nil, Expression), default: nil
-			end)
+		class List_last < BuiltinFunction
+			protected
 
-			def call(arg)
-				fill_or_call(arg) do
-					if arg.is_a?(Dhall::List)
-						arg.last
-					else
-						super
-					end
-				end
+			def uncurried_call(type, list)
+				return unfill(type, list) unless list.is_a?(Dhall::List)
+
+				list.last
 			end
 		end
 
-		class List_length < Builtin
-			include(ValueSemantics.for_attributes do
-				type Either(nil, Expression), default: nil
-			end)
+		class List_length < BuiltinFunction
+			protected
 
-			def call(arg)
-				fill_or_call(arg) do
-					if arg.is_a?(Dhall::List)
-						Dhall::Natural.new(value: arg.length)
-					else
-						super
-					end
-				end
+			def uncurried_call(type, list)
+				return unfill(type, list) unless list.is_a?(Dhall::List)
+
+				Dhall::Natural.new(value: list.length)
 			end
 		end
 
-		class List_reverse < Builtin
-			include(ValueSemantics.for_attributes do
-				type Either(nil, Expression), default: nil
-			end)
+		class List_reverse < BuiltinFunction
+			protected
 
-			def call(arg)
-				fill_or_call(arg) do
-					if arg.is_a?(Dhall::List)
-						arg.reverse
-					else
-						super
-					end
-				end
+			def uncurried_call(type, list)
+				return unfill(type, list) unless list.is_a?(Dhall::List)
+
+				list.reverse
 			end
 		end
 
-		class Optional_build < Builtin
-			include(ValueSemantics.for_attributes do
-				type Either(nil, Expression), default: nil
-			end)
-
+		class Optional_build < BuiltinFunction
 			def fusion(*args)
 				_, arg, = args
 				if arg.is_a?(Application) &&
@@ -353,19 +301,17 @@ module Dhall
 				end
 			end
 
-			def call(arg)
-				fill_or_call(arg) do
-					arg.call(
-						Optional.new.call(type),
-						some,
-						OptionalNone.new(value_type: type)
-					)
-				end
-			end
-
 			protected
 
-			def some
+			def uncurried_call(type, f)
+				f.call(
+					Optional.new.call(type),
+					some(type),
+					OptionalNone.new(value_type: type)
+				)
+			end
+
+			def some(type)
 				Function.of_arguments(
 					type,
 					body: Dhall::Optional.new(
@@ -376,24 +322,19 @@ module Dhall
 			end
 		end
 
-		class Optional_fold < Builtin
-			include(ValueSemantics.for_attributes do
-				type     Either(nil, Expression), default: nil
-				optional Either(nil, Optional),   default: nil
-				ztype    Either(nil, Expression), default: nil
-				f        Either(nil, Expression), default: nil
-			end)
+		class Optional_fold < BuiltinFunction
+			protected
 
-			def call(*args)
-				args.reduce(self) do |fold, arg|
-					fold.fill_or_call(arg) do
-						fold.optional.reduce(arg, &fold.f)
-					end || super
+			def uncurried_call(type, optional, ztype, f, z)
+				unless optional.is_a?(Dhall::Optional)
+					return unfill(type, optional, ztype, f, z)
 				end
+
+				optional.reduce(z, &f)
 			end
 		end
 
-		class Text_show < Builtin
+		class Text_show < BuiltinFunction
 			ENCODE = (Hash.new { |_, x| "\\u%04x" % x.ord }).merge(
 				"\"" => "\\\"",
 				"\\" => "\\\\",
@@ -404,17 +345,17 @@ module Dhall
 				"\t" => "\\t"
 			)
 
-			def call(arg)
-				if arg.is_a?(Dhall::Text)
-					Dhall::Text.new(
-						value: "\"#{arg.value.gsub(
-							/["\$\\\b\f\n\r\t\u0000-\u001F]/,
-							&ENCODE
-						)}\""
-					)
-				else
-					super
-				end
+			protected
+
+			def uncurried_call(text)
+				return unfill(text) unless text.is_a?(Dhall::Text)
+
+				Dhall::Text.new(
+					value: "\"#{text.to_s.gsub(
+						/["\$\\\b\f\n\r\t\u0000-\u001F]/,
+						&ENCODE
+					)}\""
+				)
 			end
 		end