dhall 0.1.0

data/lib/dhall/binary.rb

@@ -0,0 +1,277 @@
+# frozen_string_literal: true
+
+require "cbor"
+require "digest/sha2"
+
+require "dhall/ast"
+require "dhall/builtins"
+
+module Dhall
+	def self.from_binary(cbor_binary)
+		decode(CBOR.decode(cbor_binary))
+	end
+
+	def self.decode(expression)
+		BINARY.each do |match, use|
+			return use[expression] if expression.is_a?(match)
+		end
+
+		raise "Unknown expression: #{expression.inspect}"
+	end
+
+	class Expression
+		def self.decode(*args)
+			return new(value: args.first) if args.length == 1
+
+			new(*args)
+		end
+
+		def to_cbor(packer=nil)
+			if packer
+				packer.write(as_json)
+				packer
+			else
+				CBOR.encode(as_json)
+			end
+		end
+		alias to_binary to_cbor
+
+		def digest(digest: Digest::SHA2.new(256))
+			(digest << normalize.to_binary).freeze
+		end
+
+		def cache_key
+			"sha256:#{digest.hexdigest}"
+		end
+	end
+
+	class Application
+		def self.decode(function, *args)
+			function = Dhall.decode(function)
+			args.map(&Dhall.method(:decode)).reduce(function) do |f, arg|
+				self.for(function: f, argument: arg)
+			end
+		end
+	end
+
+	class Function
+		def self.decode(var_or_type, type_or_body, body_or_nil=nil)
+			type_or_body = Dhall.decode(type_or_body)
+
+			if body_or_nil.nil?
+				of_arguments(Dhall.decode(var_or_type), body: type_or_body)
+			else
+				raise ArgumentError, "explicit var named _" if var_or_type == "_"
+
+				body_or_nil = Dhall.decode(body_or_nil)
+				new(var: var_or_type, type: type_or_body, body: body_or_nil)
+			end
+		end
+	end
+
+	class Operator
+		def self.decode(opcode, lhs, rhs)
+			OPERATORS[opcode].new(
+				lhs: Dhall.decode(lhs),
+				rhs: Dhall.decode(rhs)
+			)
+		end
+	end
+
+	class List
+		def self.decode(type, *els)
+			type = type.nil? ? nil : Dhall.decode(type)
+			if els.empty?
+				EmptyList.new(element_type: type)
+			else
+				List.new(elements: els.map(&Dhall.method(:decode)), element_type: type)
+			end
+		end
+	end
+
+	class Optional
+		def self.decode(type, value=nil)
+			if value.nil?
+				OptionalNone.new(value_type: Dhall.decode(type))
+			else
+				Optional.new(
+					value:      Dhall.decode(value),
+					value_type: type.nil? ? type : Dhall.decode(type)
+				)
+			end
+		end
+	end
+
+	class Merge
+		def self.decode(record, input, type=nil)
+			new(
+				record: Dhall.decode(record),
+				input:  Dhall.decode(input),
+				type:   type.nil? ? nil : Dhall.decode(type)
+			)
+		end
+	end
+
+	class RecordType
+		def self.decode(record)
+			if record.empty?
+				EmptyRecordType.new
+			else
+				new(record: Hash[record.map { |k, v| [k, Dhall.decode(v)] }])
+			end
+		end
+	end
+
+	class Record
+		def self.decode(record)
+			if record.empty?
+				EmptyRecord.new
+			else
+				new(record: Hash[record.map { |k, v| [k, Dhall.decode(v)] }])
+			end
+		end
+	end
+
+	class RecordSelection
+		def self.decode(record, selector)
+			new(record: Dhall.decode(record), selector: selector)
+		end
+	end
+
+	class RecordProjection
+		def self.decode(record, *selectors)
+			if selectors.empty?
+				EmptyRecordProjection.new(record: Dhall.decode(record))
+			else
+				new(record: Dhall.decode(record), selectors: selectors)
+			end
+		end
+	end
+
+	class UnionType
+		def self.decode(record)
+			new(alternatives: Hash[record.map do |k, v|
+				[k, v.nil? ? v : Dhall.decode(v)]
+			end])
+		end
+	end
+
+	class Union
+		def self.decode(tag, value, alternatives)
+			new(
+				tag:          tag,
+				value:        Dhall.decode(value),
+				alternatives: UnionType.decode(alternatives)
+			)
+		end
+	end
+
+	class If
+		def self.decode(pred, thn, els)
+			new(
+				predicate: Dhall.decode(pred),
+				then:      Dhall.decode(thn),
+				else:      Dhall.decode(els)
+			)
+		end
+	end
+
+	class TextLiteral
+		def self.decode(*chunks)
+			lead_text, *pairs = chunks
+			chunks =
+				[Text.new(value: lead_text)] +
+				pairs.each_slice(2).flat_map do |(e, t)|
+					[Dhall.decode(e), Text.new(value: t)]
+				end
+
+			chunks.length == 1 ? chunks.first : TextLiteral.new(chunks: chunks)
+		end
+	end
+
+	class Import
+		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
+
+			new(
+				IntegrityCheck.new(*integrity_check),
+				IMPORT_TYPES[import_type],
+				PATH_TYPES[path_type].new(*parts)
+			)
+		end
+	end
+
+	class LetBlock
+		def self.decode(*parts)
+			body = Dhall.decode(parts.pop)
+			lets = parts.each_slice(3).map do |(var, type, assign)|
+				Let.new(
+					var:    var,
+					assign: Dhall.decode(assign),
+					type:   type.nil? ? nil : Dhall.decode(type)
+				)
+			end
+
+			self.for(lets: lets, body: body)
+		end
+	end
+
+	class TypeAnnotation
+		def self.decode(value, type)
+			new(value: Dhall.decode(value), type: Dhall.decode(type))
+		end
+	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) },
+		::Integer      => ->(e) { Variable.new(index: e) },
+		::Array        => lambda { |e|
+			if e.length == 2 && e.first.is_a?(::String)
+				Variable.new(name: e[0], index: e[1])
+			else
+				tag, *body = e
+				BINARY_TAGS[tag]&.decode(*body) ||
+					(raise "Unknown expression: #{e.inspect}")
+			end
+		},
+		::CBOR::Tagged => lambda { |e|
+			return Dhall.decode(e.value) if e.tag == 55799
+
+			raise "Unknown tag: #{e.inspect}"
+		}
+	}.freeze
+
+	BINARY_TAGS = [
+		Application,
+		Function,
+		Forall,
+		Operator,
+		List,
+		Optional,
+		Merge,
+		RecordType,
+		Record,
+		RecordSelection,
+		RecordProjection,
+		UnionType,
+		Union,
+		nil,
+		If,
+		Natural,
+		Integer,
+		nil,
+		TextLiteral,
+		nil,
+		nil,
+		nil,
+		nil,
+		nil,
+		Import,
+		LetBlock,
+		TypeAnnotation
+	].freeze
+end

data/lib/dhall/builtins.rb

@@ -0,0 +1,425 @@
+# frozen_string_literal: true
+
+require "dhall/ast"
+
+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|
+				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
+			end
+		end
+
+		def as_json
+			if (unfilled = unfill).class != self.class
+				unfilled.as_json
+			else
+				self.class.name&.split(/::/)&.last&.tr("_", "/").to_s
+			end
+		end
+
+		protected
+
+		def attributes
+			self.class.value_semantics.attributes
+		end
+
+		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 full?
+			attributes.all? { |attr| !send(attr.name).nil? }
+		end
+
+		def fill_or_call(arg, &block)
+			full? ? block[arg] : fill_next_if_valid(arg)
+		end
+	end
+
+	module Builtins
+		# rubocop:disable Style/ClassAndModuleCamelCase
+
+		class Double_show < Builtin
+			def call(arg)
+				if arg.is_a?(Double)
+					Text.new(value: arg.to_s)
+				else
+					super
+				end
+			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 < Builtin
+			def call(arg)
+				if arg.is_a?(Integer)
+					Double.new(value: arg.value.to_f)
+				else
+					super
+				end
+			end
+		end
+
+		class Natural_build < Builtin
+			def fusion(arg, *bogus)
+				if bogus.empty? &&
+				   arg.is_a?(Application) &&
+				   arg.function == Natural_fold.new
+					arg.argument
+				else
+					super
+				end
+			end
+
+			def call(arg)
+				arg.call(
+					Variable.new(name: "Natural"),
+					Function.of_arguments(
+						Variable.new(name: "Natural"),
+						body: Variable["_"] + Natural.new(value: 1)
+					),
+					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
+				end
+			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)
+
+			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
+			end
+		end
+
+		class Natural_isZero < Builtin
+			def call(nat)
+				if nat.is_a?(Natural)
+					Bool.new(value: nat.zero?)
+				else
+					super
+				end
+			end
+		end
+
+		class Natural_odd < Builtin
+			def call(nat)
+				if nat.is_a?(Natural)
+					Bool.new(value: nat.odd?)
+				else
+					super
+				end
+			end
+		end
+
+		class Natural_show < Builtin
+			def call(nat)
+				if nat.is_a?(Natural)
+					Text.new(value: nat.to_s)
+				else
+					super
+				end
+			end
+		end
+
+		class Natural_toInteger < Builtin
+			def call(nat)
+				if nat.is_a?(Natural)
+					Integer.new(value: nat.value)
+				else
+					super
+				end
+			end
+		end
+
+		class List_build < Builtin
+			include(ValueSemantics.for_attributes do
+				type Either(nil, Expression), default: nil
+			end)
+
+			def fusion(*args)
+				_, arg, = args
+				if arg.is_a?(Application) &&
+				   arg.function.is_a?(Application) &&
+				   arg.function.function == List_fold.new
+					arg.argument
+				else
+					super
+				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
+				Function.of_arguments(
+					type,
+					Variable["List"].call(type.shift(1, "_", 0)),
+					body: 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_head < Builtin
+			include(ValueSemantics.for_attributes do
+				type Either(nil, Expression), default: nil
+			end)
+
+			def call(arg)
+				fill_or_call(arg) do
+					if arg.is_a?(List)
+						arg.first
+					else
+						super
+					end
+				end
+			end
+		end
+
+		class List_indexed < Builtin
+			include(ValueSemantics.for_attributes do
+				type Either(nil, Expression), default: nil
+			end)
+
+			def call(arg)
+				fill_or_call(arg) do
+					if arg.is_a?(List)
+						_call(arg)
+					else
+						super
+					end
+				end
+			end
+
+			protected
+
+			def _call(arg)
+				arg.map(type: indexed_type(type)) { |x, idx|
+					Record.new(
+						record: {
+							"index" => Natural.new(value: idx),
+							"value" => x
+						}
+					)
+				}.normalize
+			end
+
+			def indexed_type(value_type)
+				RecordType.new(
+					record: {
+						"index" => Variable.new(name: "Natural"),
+						"value" => value_type
+					}
+				)
+			end
+		end
+
+		class List_last < Builtin
+			include(ValueSemantics.for_attributes do
+				type Either(nil, Expression), default: nil
+			end)
+
+			def call(arg)
+				fill_or_call(arg) do
+					if arg.is_a?(List)
+						arg.last
+					else
+						super
+					end
+				end
+			end
+		end
+
+		class List_length < Builtin
+			include(ValueSemantics.for_attributes do
+				type Either(nil, Expression), default: nil
+			end)
+
+			def call(arg)
+				fill_or_call(arg) do
+					if arg.is_a?(List)
+						Natural.new(value: arg.length)
+					else
+						super
+					end
+				end
+			end
+		end
+
+		class List_reverse < Builtin
+			include(ValueSemantics.for_attributes do
+				type Either(nil, Expression), default: nil
+			end)
+
+			def call(arg)
+				fill_or_call(arg) do
+					if arg.is_a?(List)
+						arg.reverse
+					else
+						super
+					end
+				end
+			end
+		end
+
+		class Optional_build < Builtin
+			include(ValueSemantics.for_attributes do
+				type Either(nil, Expression), default: nil
+			end)
+
+			def fusion(*args)
+				_, arg, = args
+				if arg.is_a?(Application) &&
+				   arg.function.is_a?(Application) &&
+				   arg.function.function == Optional_fold.new
+					arg.argument
+				else
+					super
+				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
+				Function.of_arguments(
+					type,
+					body: Optional.new(
+						value:      Variable["_"],
+						value_type: type
+					)
+				)
+			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)
+
+			def call(*args)
+				args.reduce(self) do |fold, arg|
+					fold.fill_or_call(arg) do
+						fold.optional.reduce(arg, &fold.f)
+					end || super
+				end
+			end
+		end
+
+		class Text_show < Builtin
+			ENCODE = (Hash.new { |_, x| "\\u%04x" % x.ord }).merge(
+				"\"" => "\\\"",
+				"\\" => "\\\\",
+				"\b" => "\\b",
+				"\f" => "\\f",
+				"\n" => "\\n",
+				"\r" => "\\r",
+				"\t" => "\\t"
+			)
+
+			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
+			end
+		end
+
+		# rubocop:enable Style/ClassAndModuleCamelCase
+
+		ALL = Hash[constants.map { |c| [c.to_s.tr("_", "/"), const_get(c)] }]
+	end
+end