literal 1.1.0 → 1.3.0

data/lib/literal/types/hash_type.rb

@@ -2,12 +2,18 @@
 
 # @api private
 class Literal::Types::HashType
+	include Literal::Type
+
 	def initialize(key_type, value_type)
 		@key_type = key_type
 		@value_type = value_type
 	end
 
-	def inspect = "_Hash(#{@key_type.inspect}, #{@value_type.inspect})"
+	attr_reader :key_type, :value_type
+
+	def inspect
+		"_Hash(#{@key_type.inspect}, #{@value_type.inspect})"
+	end
 
 	def ===(value)
 		return false unless Hash === value
@@ -19,6 +25,19 @@ class Literal::Types::HashType
 		true
 	end
 
+	def >=(other)
+		case other
+		when Literal::Types::HashType
+			(
+				Literal.subtype?(other.key_type, of: @key_type)
+			) && (
+				Literal.subtype?(other.value_type, of: @value_type)
+			)
+		else
+			false
+		end
+	end
+
 	def record_literal_type_errors(context)
 		unless Hash === context.actual
 			return
@@ -35,4 +54,6 @@ class Literal::Types::HashType
 			end
 		end
 	end
+
+	freeze
 end

data/lib/literal/types/interface_type.rb

@@ -2,14 +2,44 @@
 
 # @api private
 class Literal::Types::InterfaceType
+	# TODO: We can generate this and make it much more extensive.
+	METHOD_TYPE_MAPPINGS = {
+		:call => Set[Proc, Method],
+		:to_proc => Set[Proc, Method],
+		:to_s => Set[String],
+	}.freeze
+
+	include Literal::Type
+
 	def initialize(*methods)
 		raise Literal::ArgumentError.new("_Interface type must have at least one method.") if methods.size < 1
 		@methods = methods
 	end
 
-	def inspect = "_Interface(#{@methods.map(&:inspect).join(', ')})"
+	attr_reader :methods
+
+	def inspect
+		"_Interface(#{@methods.map(&:inspect).join(', ')})"
+	end
 
 	def ===(value)
 		@methods.all? { |m| value.respond_to?(m) }
 	end
+
+	def >=(other)
+		case other
+		when Literal::Types::InterfaceType
+			@methods.all? { |m| other.methods.include?(m) }
+		when Module
+			@methods.map { |m| METHOD_TYPE_MAPPINGS[m] }.all? { |types| types&.include?(other) }
+		when Literal::Types::IntersectionType
+			other.types.any? { |type| Literal.subtype?(type, of: self) }
+		when Literal::Types::ConstraintType
+			other.object_constraints.any? { |type| Literal.subtype?(type, of: self) }
+		else
+			false
+		end
+	end
+
+	freeze
 end

data/lib/literal/types/intersection_type.rb

@@ -2,12 +2,16 @@
 
 # @api private
 class Literal::Types::IntersectionType
+	include Literal::Type
+
 	def initialize(*types)
 		raise Literal::ArgumentError.new("_Intersection type must have at least one type.") if types.size < 1
 
 		@types = types
 	end
 
+	attr_reader :types
+
 	def inspect = "_Intersection(#{@types.map(&:inspect).join(', ')})"
 
 	def ===(value)
@@ -25,4 +29,27 @@ class Literal::Types::IntersectionType
 			context.add_child(label: inspect, expected: type, actual: context.actual)
 		end
 	end
+
+	def >=(other)
+		case other
+		when Literal::Types::IntersectionType
+			@types.all? do |type|
+				other.types.any? do |other_type|
+					Literal.subtype?(other_type, of: type)
+				end
+			end
+		when Literal::Types::ConstraintType
+			@types.all? do |type|
+				other.object_constraints.any? do |object_constraint|
+					Literal.subtype?(object_constraint, of: type)
+				end
+			end
+		when Literal::Types::FrozenType
+			@types.all? { |type| Literal.subtype?(other.type, of: type) }
+		else
+			false
+		end
+	end
+
+	freeze
 end

data/lib/literal/types/json_data_type.rb

@@ -1,10 +1,25 @@
 # frozen_string_literal: true
 
 # @api private
-module Literal::Types::JSONDataType
-	def self.inspect = "_JSONData"
+class Literal::Types::JSONDataType
+	Instance = new.freeze
 
-	def self.===(value)
+	include Literal::Type
+
+	COMPATIBLE_TYPES = Set[
+		Integer,
+		Float,
+		String,
+		true,
+		false,
+		nil,
+		Literal::Types::BooleanType::Instance,
+		Instance
+	].freeze
+
+	def inspect = "_JSONData"
+
+	def ===(value)
 		case value
 		when String, Integer, Float, true, false, nil
 			true
@@ -19,5 +34,36 @@ module Literal::Types::JSONDataType
 		end
 	end
 
+	def record_literal_type_errors(context)
+		case value = context.actual
+		when String, Integer, Float, true, false, nil
+			# nothing to do
+		when Hash
+			value.each do |k, v|
+				context.add_child(label: "[]", expected: String, actual: k) unless String === k
+				context.add_child(label: "[#{k.inspect}]", expected: self, actual: v) unless self === v
+			end
+		when Array
+			value.each_with_index do |item, index|
+				context.add_child(label: "[#{index}]", expected: self, actual: item) unless self === item
+			end
+		end
+	end
+
+	def >=(other)
+		return true if COMPATIBLE_TYPES.include?(other)
+
+		case other
+		when Literal::Types::ArrayType
+			self >= other.type
+		when Literal::Types::HashType
+			(self >= other.key_type) && (self >= other.value_type)
+		when Literal::Types::ConstraintType
+			other.object_constraints.any? { |type| self >= type }
+		else
+			false
+		end
+	end
+
 	freeze
 end

data/lib/literal/types/map_type.rb

@@ -2,10 +2,14 @@
 
 # @api private
 class Literal::Types::MapType
+	include Literal::Type
+
 	def initialize(**shape)
 		@shape = shape
 	end
 
+	attr_reader :shape
+
 	def inspect
 		"_Map(#{@shape.inspect})"
 	end
@@ -21,15 +25,29 @@ class Literal::Types::MapType
 			return
 		end
 
-		context.actual.each do |key, item|
-			unless (expected = @shape[key])
-				context.add_child(label: "[]", expected: @shape.keys, actual: key)
+		@shape.each do |key, expected|
+			unless context.actual.key?(key) || expected === nil
+				context.add_child(label: "[#{key.inspect}]", expected:, actual: nil)
 				next
 			end
 
-			unless expected === item
-				context.add_child(label: "[#{key.inspect}]", expected:, actual: item)
+			actual = context.actual[key]
+			unless expected === actual
+				context.add_child(label: "[#{key.inspect}]", expected:, actual:)
+			end
+		end
+	end
+
+	def >=(other)
+		case other
+		when Literal::Types::MapType
+			other_shape = other.shape
+
+			@shape.all? do |k, v|
+				Literal.subtype?(other_shape[k], of: v)
 			end
+		else
+			false
 		end
 	end
 end

data/lib/literal/types/never_type.rb

@@ -1,12 +1,27 @@
 # frozen_string_literal: true
 
 # @api private
-module Literal::Types::NeverType
-	def self.inspect = "_Never"
+class Literal::Types::NeverType
+	Instance = new.freeze
 
-	def self.===(value)
+	include Literal::Type
+
+	def inspect
+		"_Never"
+	end
+
+	def ===(value)
 		false
 	end
 
+	def >=(other)
+		case other
+		when Literal::Types::NeverTypeClass
+			true
+		else
+			false
+		end
+	end
+
 	freeze
 end

data/lib/literal/types/nilable_type.rb

@@ -2,13 +2,36 @@
 
 # @api private
 class Literal::Types::NilableType
+	include Literal::Type
+
 	def initialize(type)
 		@type = type
 	end
 
-	def inspect = "_Nilable(#{@type.inspect})"
+	attr_reader :type
+
+	def inspect
+		"_Nilable(#{@type.inspect})"
+	end
 
 	def ===(value)
 		nil === value || @type === value
 	end
+
+	def record_literal_type_errors(ctx)
+		@type.record_literal_type_errors(ctx) if @type.respond_to?(:record_literal_type_errors)
+	end
+
+	def >=(other)
+		case other
+		when Literal::Types::NilableType
+			Literal.subtype?(other.type, of: @type)
+		when nil
+			true
+		else
+			Literal.subtype?(other, of: @type)
+		end
+	end
+
+	freeze
 end

data/lib/literal/types/not_type.rb

@@ -2,13 +2,34 @@
 
 # @api private
 class Literal::Types::NotType
+	include Literal::Type
+
 	def initialize(type)
 		@type = type
 	end
 
-	def inspect = "_Not(#{@type.inspect})"
+	attr_reader :type
+
+	def inspect
+		"_Not(#{@type.inspect})"
+	end
 
 	def ===(value)
 		!(@type === value)
 	end
+
+	def >=(other)
+		case other
+		when Literal::Types::NotType
+			Literal.subtype?(other.type, of: @type)
+		when Literal::Types::ConstraintType
+			other.object_constraints.any? { |constraint| Literal.subtype?(constraint, of: self) }
+		when Literal::Types::IntersectionType
+			other.types.any? { |type| Literal.subtype?(type, of: self) }
+		else
+			false
+		end
+	end
+
+	freeze
 end

data/lib/literal/types/range_type.rb

@@ -2,11 +2,17 @@
 
 # @api private
 class Literal::Types::RangeType
+	include Literal::Type
+
 	def initialize(type)
 		@type = type
 	end
 
-	def inspect = "_Range(#{@type.inspect})"
+	attr_reader :type
+
+	def inspect
+		"_Range(#{@type.inspect})"
+	end
 
 	def ===(value)
 		Range === value && (
@@ -17,4 +23,15 @@ class Literal::Types::RangeType
 			)
 		)
 	end
+
+	def >=(other)
+		case other
+		when Literal::Types::RangeType
+			Literal.subtype?(other.type, of: @type)
+		else
+			false
+		end
+	end
+
+	freeze
 end

data/lib/literal/types/set_type.rb

@@ -2,11 +2,17 @@
 
 # @api private
 class Literal::Types::SetType
+	include Literal::Type
+
 	def initialize(type)
 		@type = type
 	end
 
-	def inspect = "_Set(#{@type.inspect})"
+	attr_reader :type
+
+	def inspect
+		"_Set(#{@type.inspect})"
+	end
 
 	def ===(value)
 		return false unless Set === value
@@ -17,4 +23,25 @@ class Literal::Types::SetType
 
 		true
 	end
+
+	def record_literal_type_errors(context)
+		return unless Set === context.actual
+
+		context.actual.each do |actual|
+			unless @type === actual
+				context.add_child(label: "[]", expected: @type, actual:)
+			end
+		end
+	end
+
+	def >=(other)
+		case other
+		when Literal::Types::SetType
+			Literal.subtype?(other.type, of: @type)
+		else
+			false
+		end
+	end
+
+	freeze
 end

data/lib/literal/types/truthy_type.rb

@@ -1,12 +1,26 @@
 # frozen_string_literal: true
 
 # @api private
-module Literal::Types::TruthyType
-	def self.inspect = "_Truthy"
+class Literal::Types::TruthyType
+	Instance = new.freeze
+	include Literal::Type
 
-	def self.===(value)
+	def inspect
+		"_Truthy"
+	end
+
+	def ===(value)
 		!!value
 	end
 
+	def >=(other)
+		case other
+		when Literal::Types::TruthyType, true
+			true
+		else
+			false
+		end
+	end
+
 	freeze
 end

data/lib/literal/types/tuple_type.rb

@@ -2,13 +2,19 @@
 
 # @api private
 class Literal::Types::TupleType
+	include Literal::Type
+
 	def initialize(*types)
 		raise Literal::ArgumentError.new("_Tuple type must have at least one type.") if types.size < 1
 
 		@types = types
 	end
 
-	def inspect = "_Tuple(#{@types.map(&:inspect).join(', ')})"
+	attr_reader :types
+
+	def inspect
+		"_Tuple(#{@types.map(&:inspect).join(', ')})"
+	end
 
 	def ===(value)
 		return false unless Array === value
@@ -32,11 +38,22 @@ class Literal::Types::TupleType
 		while i < len
 			actual = context.actual[i]
 			if !(expected = @types[i])
-				context.add_child(label: "[#{i}]", expected: Literal::Types::NeverType, actual:)
+				context.add_child(label: "[#{i}]", expected: Literal::Types::NeverType::Instance, actual:)
 			elsif !(expected === actual)
 				context.add_child(label: "[#{i}]", expected:, actual:)
 			end
 			i += 1
 		end
 	end
+
+	def >=(other)
+		case other
+		when Literal::Types::TupleType
+			@types == other.types
+		else
+			false
+		end
+	end
+
+	freeze
 end

data/lib/literal/types/union_type.rb

@@ -12,7 +12,11 @@ class Literal::Types::UnionType
 		@types.freeze
 	end
 
-	def inspect = "_Union(#{@types.inspect})"
+	attr_reader :types
+
+	def inspect
+		"_Union(#{@types.inspect})"
+	end
 
 	def ===(value)
 		types = @types
@@ -39,9 +43,27 @@ class Literal::Types::UnionType
 		end
 	end
 
-	protected
+	def record_literal_type_errors(ctx)
+		@types.each do |type|
+			ctx.add_child(label: type.inspect, expected: type, actual: ctx.actual)
+		end
+		ctx.children.clear if ctx.children.none? { |c| c.children.any? }
+	end
 
-	attr_reader :types
+	def >=(other)
+		case other
+		when Literal::Types::UnionType
+			other.types.all? do |other_type|
+				@types.any? do |type|
+					Literal.subtype?(type, of: other_type)
+				end
+			end
+		else
+			@types.any? do |type|
+				Literal.subtype?(other, of: type)
+			end
+		end
+	end
 
 	private
 
@@ -50,4 +72,6 @@ class Literal::Types::UnionType
 			(Literal::Types::UnionType === type) ? load_types(type.types) : @types << type
 		end
 	end
+
+	freeze
 end

data/lib/literal/types/void_type.rb

@@ -1,10 +1,20 @@
 # frozen_string_literal: true
 
 # @api private
-module Literal::Types::VoidType
-	def self.inspect = "_Void"
+class Literal::Types::VoidType
+	Instance = new.freeze
 
-	def self.===(_)
+	include Literal::Type
+
+	def inspect
+		"_Void"
+	end
+
+	def ===(_)
+		true
+	end
+
+	def >=(_)
 		true
 	end