dhall 0.3.0 → 0.5.2

data/lib/dhall/typecheck.rb

@@ -12,7 +12,7 @@ module Dhall
 
 		def self.assert_type(expr, assertion, message, context:)
 			aexpr = self.for(expr).annotate(context)
-			type = aexpr.type
+			type = aexpr.type.normalize
 			raise TypeError, "#{message}: #{type}" unless assertion === type
 			aexpr
 		end
@@ -20,7 +20,9 @@ module Dhall
 		def self.assert_types_match(a, b, message, context:)
 			atype = self.for(a).annotate(context).type
 			btype = self.for(b).annotate(context).type
-			raise TypeError, "#{message}: #{atype}, #{btype}" unless atype == btype
+			unless atype.normalize == btype.normalize
+				raise TypeError, "#{message}: #{atype}, #{btype}"
+			end
 			atype
 		end
 
@@ -40,9 +42,13 @@ module Dhall
 			@typecheckers[node_type] ||= [typechecker, extras]
 		end
 
-		def self.type_of(expr)
+		def self.annotate(expr)
 			return if expr.nil?
-			TypeChecker.for(expr).annotate(TypeChecker::Context.new).type
+			TypeChecker.for(expr).annotate(TypeChecker::Context.new)
+		end
+
+		def self.type_of(expr)
+			annotate(expr)&.type
 		end
 
 		class Context
@@ -233,6 +239,31 @@ module Dhall
 			end
 		end
 
+		class OperatorEquivalent
+			TypeChecker.register self, Dhall::Operator::Equivalent
+
+			def initialize(expr)
+				@expr = expr
+				@lhs = expr.lhs
+				@rhs = expr.rhs
+			end
+
+			def annotate(context)
+				type = TypeChecker.assert_types_match @lhs, @rhs,
+				                                      "arguments do not match",
+				                                      context: context
+
+				TypeChecker.assert_type type, Builtins[:Type],
+				                        "arguments are not terms",
+				                        context: context
+
+				Dhall::TypeAnnotation.new(
+					value: @expr.with(lhs: @lhs.annotate(type), rhs: @rhs.annotate(type)),
+					type:  Builtins[:Type]
+				)
+			end
+		end
+
 		class OperatorListConcatenate
 			TypeChecker.register self, Dhall::Operator::ListConcatenate
 
@@ -309,10 +340,6 @@ module Dhall
 				                                        "RecursiveRecordMerge got",
 				                                        context: context
 
-				TypeChecker.assert_types_match annotated_lhs.type, annotated_rhs.type,
-				                               "RecursiveRecordMerge got mixed kinds",
-				                               context: context
-
 				[annotated_lhs, annotated_rhs]
 			end
 
@@ -336,12 +363,6 @@ module Dhall
 			end
 
 			def annotate(context)
-				kind = TypeChecker.assert_types_match(
-					@expr.lhs, @expr.rhs,
-					"RecursiveRecordTypeMerge mixed kinds",
-					context: context
-				)
-
 				type = @expr.lhs.deep_merge_type(@expr.rhs)
 
 				TypeChecker.assert type, Dhall::RecordType,
@@ -350,7 +371,13 @@ module Dhall
 				# Annotate to sanity check
 				TypeChecker.for(type).annotate(context)
 
-				Dhall::TypeAnnotation.new(value: @expr, type: kind)
+				Dhall::TypeAnnotation.new(value: @expr, type: kind(context))
+			end
+
+			def kind(context)
+				lhs_kind = KINDS.index(TypeChecker.for(@expr.lhs).annotate(context).type)
+				rhs_kind = KINDS.index(TypeChecker.for(@expr.rhs).annotate(context).type)
+				KINDS[[lhs_kind, rhs_kind].max]
 			end
 		end
 
@@ -358,10 +385,16 @@ module Dhall
 			TypeChecker.register self, Dhall::EmptyList
 
 			def initialize(expr)
-				@expr = expr
+				@expr = expr.with(type: expr.type.normalize)
 			end
 
 			def annotate(context)
+				TypeChecker.assert @expr.type, Dhall::Application,
+				                   "EmptyList unknown type #{@expr.type.inspect}"
+
+				TypeChecker.assert @expr.type.function, Builtins[:List],
+				                   "EmptyList unknown type #{@expr.type.inspect}"
+
 				TypeChecker.assert_type @expr.element_type, Builtins[:Type],
 				                        "EmptyList element type not of type Type",
 				                        context: context
@@ -383,7 +416,7 @@ module Dhall
 				end
 
 				def annotation
-					list = @alist.with(element_type: element_type)
+					list = @alist.with(type: Builtins[:List].call(element_type))
 					Dhall::TypeAnnotation.new(type: list.type, value: list)
 				end
 
@@ -468,13 +501,20 @@ module Dhall
 
 		class AnonymousType
 			TypeChecker.register self, Dhall::RecordType
-			TypeChecker.register self, Dhall::UnionType
 
 			def initialize(type)
 				@type = type
 			end
 
 			def annotate(context)
+				kinds = check(context)
+				type = kinds.max_by { |k| KINDS.index(k) } || KINDS.first
+				Dhall::TypeAnnotation.new(value: @type, type: type)
+			end
+
+			protected
+
+			def check(context)
 				kinds = @type.record.values.compact.map do |mtype|
 					TypeChecker.for(mtype).annotate(context).type
 				end
@@ -482,6 +522,16 @@ module Dhall
 				TypeChecker.assert (kinds - KINDS), [],
 				                   "AnonymousType field kind not one of #{KINDS}"
 
+				kinds
+			end
+		end
+
+		class UnionType < AnonymousType
+			TypeChecker.register self, Dhall::UnionType
+
+			def annotate(context)
+				kinds = check(context)
+
 				TypeChecker.assert kinds, Util::ArrayAllTheSame,
 				                   "AnonymousType field kinds not all the same"
 
@@ -537,12 +587,13 @@ module Dhall
 
 			class Selector
 				def self.for(annotated_record)
-					if annotated_record.type == Builtins[:Type]
+					typ = annotated_record.type.normalize
+					if KINDS.include?(typ)
 						TypeSelector.new(annotated_record.value)
-					elsif annotated_record.type.class == Dhall::RecordType
-						new(annotated_record.type)
+					elsif typ.class == Dhall::RecordType
+						new(typ)
 					else
-						raise TypeError, "RecordSelection on #{annotated_record.type}"
+						raise TypeError, "RecordSelection on #{typ}"
 					end
 				end
 
@@ -604,6 +655,33 @@ module Dhall
 			end
 		end
 
+		class RecordProjectionByExpression
+			TypeChecker.register self, Dhall::RecordProjectionByExpression
+
+			def initialize(projection)
+				@selector = projection.selector.normalize
+				@project_by_expression = projection
+				@project_by_keys = Dhall::RecordProjection.for(
+					@project_by_expression.record,
+					@selector.keys
+				)
+			end
+
+			def annotate(context)
+				TypeChecker.assert @selector, Dhall::RecordType,
+				                   "RecordProjectionByExpression on #{@selector.class}"
+
+				TypeChecker.assert_type @project_by_keys, @selector,
+				                        "Type doesn't match #{@selector}",
+				                        context: context
+
+				Dhall::TypeAnnotation.new(
+					value: @project_by_expression,
+					type:  @selector
+				)
+			end
+		end
+
 		class Enum
 			TypeChecker.register self, Dhall::Enum
 
@@ -648,6 +726,39 @@ module Dhall
 			end
 		end
 
+		class ToMap
+			TypeChecker.register self, Dhall::ToMap
+
+			def initialize(tomap)
+				@tomap = tomap
+				@record = TypeChecker.for(tomap.record)
+			end
+
+			def check_annotation(record_type)
+				if record_type.is_a?(Dhall::EmptyRecordType)
+					TypeChecker.assert @tomap.type, Dhall::Expression,
+					                   "toMap {=} has no annotation"
+				else
+					t = Types::MAP(v: record_type.record.values.first)
+
+					TypeChecker.assert t, (@tomap.type || t),
+					                   "toMap does not match annotation"
+				end
+			end
+
+			def annotate(context)
+				record_type = @record.annotate(context).type
+				TypeChecker.assert record_type, Dhall::RecordType,
+				                   "toMap on a non-record: #{record_type.inspect}"
+
+				TypeChecker.assert record_type.record.values, Util::ArrayAllTheSame,
+				                   "toMap heterogenous: #{record_type.inspect}"
+
+				type = check_annotation(record_type)
+				Dhall::TypeAnnotation.new(value: @tomap, type: type)
+			end
+		end
+
 		class Merge
 			TypeChecker.register self, Dhall::Merge
 
@@ -678,7 +789,7 @@ module Dhall
 				end
 
 				def keys
-					@type.record.keys
+					Set.new(@type.record.keys)
 				end
 
 				def fetch_input_type(k)
@@ -729,8 +840,8 @@ module Dhall
 				end
 
 				def assert_union_and_handlers_match
-					extras = @handlers.keys - @union.type.alternatives.keys
-					TypeChecker.assert extras, [],
+					extras = @handlers.keys ^ @union.type.alternatives.keys
+					TypeChecker.assert extras.to_a, [],
 					                   "Merge handlers unknown alternatives: #{extras}"
 
 					@union.type.alternatives.each do |k, atype|
@@ -771,8 +882,6 @@ module Dhall
 						raise TypeError, "FunctionType part of this is a term"
 					end
 
-					raise TypeError, "Dependent types are not allowed" if outkind > inkind
-
 					if outkind.zero?
 						Term.new
 					else
@@ -860,8 +969,6 @@ module Dhall
 			end
 		end
 
-		TypeChecker.register ->(blk) { LetIn.for(blk.unflatten) }, Dhall::LetBlock
-
 		class LetIn
 			TypeChecker.register self, Dhall::LetIn
 
@@ -927,6 +1034,30 @@ module Dhall
 			end
 		end
 
+		class Assertion
+			TypeChecker.register self, Dhall::Assertion
+
+			def initialize(expr)
+				@expr = expr
+				@type = expr.type
+			end
+
+			def annotate(context)
+				TypeChecker.assert @type, Dhall::Operator::Equivalent,
+				                   "assert expected === got: #{@type.class}"
+
+				TypeChecker.assert_type @type, Builtins[:Type],
+				                        "=== expected to have type Type",
+				                        context: context
+
+				TypeChecker.assert @type.lhs.normalize.to_binary,
+				                   @type.rhs.normalize.to_binary,
+				                   "assert equivalence not equivalent"
+
+				@expr.with(type: @type.normalize)
+			end
+		end
+
 		BUILTIN_TYPES = {
 			"Bool"              => Builtins[:Type],
 			"Type"              => Builtins[:Kind],
@@ -989,6 +1120,11 @@ module Dhall
 					)
 				)
 			),
+			"Natural/subtract"  => Dhall::Forall.of_arguments(
+				Builtins[:Natural],
+				Builtins[:Natural],
+				body: Builtins[:Natural]
+			),
 			"Natural/isZero"    => Dhall::Forall.of_arguments(
 				Builtins[:Natural],
 				body: Builtins[:Bool]
@@ -1209,12 +1345,13 @@ module Dhall
 			TypeChecker.register self, Dhall::Builtin
 
 			def self.for(builtin)
-				unfilled = builtin.unfill
-				if unfilled != builtin
-					TypeChecker.for(unfilled)
-				else
-					new(builtin)
+				if builtin.is_a?(Dhall::BuiltinFunction)
+					if (unfilled = builtin.unfill) != builtin
+						return TypeChecker.for(unfilled)
+					end
 				end
+
+				new(builtin)
 			end
 
 			def initialize(builtin)

data/lib/dhall/types.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "dhall/builtins"
+
+module Dhall
+	module Types
+		def self.MAP_ENTRY(k: Builtins[:Text], v: Builtins[:Text])
+			RecordType.new(
+				record: {
+					"mapKey" => k, "mapValue" => v
+				}
+			)
+		end
+
+		def self.MAP(k: Builtins[:Text], v: Builtins[:Text])
+			Builtins[:List].call(MAP_ENTRY(k: k, v: v))
+		end
+	end
+end

data/lib/dhall/util.rb

@@ -1,9 +1,27 @@
 # frozen_string_literal: true
 
+require "promise"
 require "timeout"
 
 module Dhall
 	module Util
+		class LazyPromise < Promise
+			def initialize(&block)
+				super
+				@block = block
+			end
+
+			def subscribe(*args)
+				super
+
+				begin
+					fulfill(@block.call)
+				rescue => e
+					reject(e)
+				end
+			end
+		end
+
 		class AllOf
 			def initialize(*validators)
 				@validators = validators
@@ -181,5 +199,36 @@ module Dhall
 		def self.longest_common_prefix(a, b)
 			a.zip(b).take_while { |(x, y)| x == y }.map(&:first)
 		end
+
+		def self.indent_size(str)
+			if str.end_with?("\n")
+				0
+			else
+				str
+					.scan(/^[ \t]*(?=[^ \t\n]|\Z)/)
+					.map(&:chars)
+					.reduce(&method(:longest_common_prefix))&.length.to_i
+			end
+		end
+
+		def self.path_components_to_uri(*components)
+			URI("/#{components.map(&method(:uri_escape)).join("/")}")
+		end
+
+		def self.uri_escape(s)
+			::URI.encode_www_form_component(s).gsub("+", "%20")
+		end
+
+		def self.net_http_req_with_timeout(uri, req, timeout:)
+			Net::HTTP.start(
+				uri.hostname,
+				uri.port,
+				use_ssl:       uri.scheme == "https",
+				open_timeout:  timeout,
+				ssl_timeout:   timeout,
+				read_timeout:  timeout,
+				write_timeout: timeout
+			) { |http| http.request(req) }
+		end
 	end
 end

data/lib/dhall.rb

@@ -9,6 +9,7 @@ require "dhall/normalize"
 require "dhall/parser"
 require "dhall/resolve"
 require "dhall/typecheck"
+require "dhall/types"
 
 module Dhall
 	using Dhall::AsDhall

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: dhall
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.5.2
 platform: ruby
 authors:
 - Stephen Paul Weber
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-05-13 00:00:00.000000000 Z
+date: 2021-09-10 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: base32
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.2
 - !ruby/object:Gem::Dependency
   name: cbor
   requirement: !ruby/object:Gem::Requirement
@@ -38,6 +52,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: lazy_object
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.3
+- !ruby/object:Gem::Dependency
+  name: multihashes
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
 - !ruby/object:Gem::Dependency
   name: promise.rb
   requirement: !ruby/object:Gem::Requirement
@@ -80,6 +122,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.0.1
+- !ruby/object:Gem::Dependency
+  name: minitest-fail-fast
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -137,8 +193,8 @@ files:
 - lib/dhall/parser.rb
 - lib/dhall/resolve.rb
 - lib/dhall/typecheck.rb
+- lib/dhall/types.rb
 - lib/dhall/util.rb
-- lib/dhall/visitor.rb
 homepage: https://git.sr.ht/~singpolyma/dhall-ruby
 licenses:
 - GPL-3.0
@@ -159,7 +215,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2.1
+rubygems_version: 2.7.6.2
 signing_key: 
 specification_version: 4
 summary: The non-repetitive alternative to YAML, in Ruby