dhall 0.1.0 → 0.5.1

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,31 +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?
-			parts[0] = EnvironmentVariable.decode(parts[0]) if path_type == 6
+			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
 
@@ -223,13 +295,21 @@ module Dhall
 		end
 	end
 
+	def self.handle_tag(e)
+		return e unless e.is_a?(::CBOR::Tagged)
+		return e.value if e.tag == 55799
+
+		raise "Unknown tag: #{e.inspect}"
+	end
+
 	BINARY = {
 		::TrueClass    => ->(e) { Bool.new(value: e) },
 		::FalseClass   => ->(e) { Bool.new(value: e) },
 		::Float        => ->(e) { Double.new(value: e) },
-		::String       => ->(e) { Builtins::ALL[e]&.new || Variable.new(name: e) },
+		::String       => ->(e) { Builtins[e.to_sym] || (raise "Unknown builtin") },
 		::Integer      => ->(e) { Variable.new(index: e) },
 		::Array        => lambda { |e|
+			e = e.map(&method(:handle_tag))
 			if e.length == 2 && e.first.is_a?(::String)
 				Variable.new(name: e[0], index: e[1])
 			else
@@ -238,11 +318,7 @@ module Dhall
 					(raise "Unknown expression: #{e.inspect}")
 			end
 		},
-		::CBOR::Tagged => lambda { |e|
-			return Dhall.decode(e.value) if e.tag == 55799
-
-			raise "Unknown tag: #{e.inspect}"
-		}
+		::CBOR::Tagged => ->(e) { Dhall.decode(handle_tag(e)) }
 	}.freeze
 
 	BINARY_TAGS = [
@@ -265,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?(Double)
-					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?(Integer)
-					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?(Integer)
-					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,91 +84,105 @@ module Dhall
 				end
 			end
 
-			def call(arg)
+			protected
+
+			def uncurried_call(arg)
 				arg.call(
-					Variable.new(name: "Natural"),
+					Natural.new,
 					Function.of_arguments(
-						Variable.new(name: "Natural"),
-						body: Variable["_"] + Natural.new(value: 1)
+						Natural.new,
+						body: Variable["_"] + Dhall::Natural.new(value: 1)
 					),
-					Natural.new(value: 0)
+					Dhall::Natural.new(value: 0)
 				)
 			end
 		end
 
-		class Natural_even < Builtin
-			def call(nat)
-				if nat.is_a?(Natural)
-					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, 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?(Natural)
-					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?(Natural)
-					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?(Natural)
-					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?(Natural)
-					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,80 +194,55 @@ module Dhall
 				end
 			end
 
-			def call(arg)
-				fill_or_call(arg) do
-					arg.call(
-						Variable["List"].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,
-					Variable["List"].call(type.shift(1, "_", 0)),
-					body: List.of(Variable["_", 1]).concat(Variable["_"])
+					List.new.call(type.shift(1, "_", 0)),
+					body: Dhall::List.of(Variable["_", 1]).concat(Variable["_"])
 				)
 			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?(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 call(arg)
-				fill_or_call(arg) do
-					if arg.is_a?(List)
-						_call(arg)
-					else
-						super
-					end
-				end
+			def uncurried_call(type, list)
+				return unfill(type, list) unless list.is_a?(Dhall::List)
+
+				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" => Natural.new(value: idx),
+							"index" => Dhall::Natural.new(value: idx),
 							"value" => x
 						}
 					)
@@ -282,66 +252,44 @@ module Dhall
 			def indexed_type(value_type)
 				RecordType.new(
 					record: {
-						"index" => Variable.new(name: "Natural"),
+						"index" => Natural.new,
 						"value" => value_type
 					}
 				)
 			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?(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?(List)
-						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?(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,22 +301,20 @@ module Dhall
 				end
 			end
 
-			def call(arg)
-				fill_or_call(arg) do
-					arg.call(
-						Variable["Optional"].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: Optional.new(
+					body: Dhall::Optional.new(
 						value:      Variable["_"],
 						value_type: type
 					)
@@ -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,22 +345,61 @@ module Dhall
 				"\t" => "\\t"
 			)
 
+			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
+
+		class Bool < Builtin
+		end
+
+		class Optional < Builtin
+		end
+
+		class Natural < Builtin
+		end
+
+		class Integer < Builtin
+		end
+
+		class Double < Builtin
+		end
+
+		class Text < Builtin
+		end
+
+		class List < Builtin
+		end
+
+		class None < Builtin
 			def call(arg)
-				if arg.is_a?(Text)
-					Text.new(
-						value: "\"#{arg.value.gsub(
-							/["\$\\\b\f\n\r\t\u0000-\u001F]/,
-							&ENCODE
-						)}\""
-					)
-				else
-					super
-				end
+				OptionalNone.new(value_type: arg)
 			end
 		end
 
+		class Type < Builtin
+		end
+
+		class Kind < Builtin
+		end
+
+		class Sort < Builtin
+		end
+
 		# rubocop:enable Style/ClassAndModuleCamelCase
 
-		ALL = Hash[constants.map { |c| [c.to_s.tr("_", "/"), const_get(c)] }]
+		def self.[](k)
+			const = constants.find { |c| c.to_s.tr("_", "/").to_sym == k }
+			const && const_get(const).new
+		end
 	end
 end