literal 1.1.0 → 1.2.0

data/lib/literal/struct.rb

@@ -6,4 +6,30 @@ class Literal::Struct < Literal::DataStructure
 			super
 		end
 	end
+
+	def [](key)
+		case key
+		when Symbol
+		when String
+			key = key.intern
+		else
+			raise TypeError.new("expected a string or symbol, got #{key.inspect.class}")
+		end
+
+		prop = self.class.literal_properties[key] || raise(NameError.new("unknown attribute: #{key.inspect} for #{self.class}"))
+		__send__(prop.name)
+	end
+
+	def []=(key, value)
+		case key
+		when Symbol
+		when String
+			key = key.intern
+		else
+			raise TypeError.new("expected a string or symbol, got #{key.inspect.class}")
+		end
+
+		prop = self.class.literal_properties[key] || raise(NameError.new("unknown attribute: #{key.inspect} for #{self.class}"))
+		__send__(:"#{prop.name}=", value)
+	end
 end

data/lib/literal/type.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Literal::Type
+	def >=(other)
+		self == other
+	end
+end

data/lib/literal/types/any_type.rb

@@ -1,12 +1,22 @@
 # frozen_string_literal: true
 
 # @api private
-module Literal::Types::AnyType
-	def self.inspect = "_Any"
+class Literal::Types::AnyType
+	include Literal::Type
 
-	def self.===(value)
+	def inspect
+		"_Any"
+	end
+
+	def ===(value)
 		!(nil === value)
 	end
 
+	def >=(other)
+		!(other === nil)
+	end
+
+	Instance = new.freeze
+
 	freeze
 end

data/lib/literal/types/array_type.rb

@@ -2,16 +2,31 @@
 
 # @api private
 class Literal::Types::ArrayType
+	include Literal::Type
+
 	def initialize(type)
 		@type = type
 	end
 
-	def inspect = "_Array(#{@type.inspect})"
+	attr_reader :type
+
+	def inspect
+		"_Array(#{@type.inspect})"
+	end
 
 	def ===(value)
 		Array === value && value.all?(@type)
 	end
 
+	def >=(other)
+		case other
+		when Literal::Types::ArrayType
+			@type >= other.type
+		else
+			false
+		end
+	end
+
 	def record_literal_type_errors(context)
 		unless Array === context.actual
 			return
@@ -23,4 +38,6 @@ class Literal::Types::ArrayType
 			end
 		end
 	end
+
+	freeze
 end

data/lib/literal/types/boolean_type.rb

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

data/lib/literal/types/callable_type.rb

@@ -1,12 +1,31 @@
 # frozen_string_literal: true
 
 # @api private
-module Literal::Types::CallableType
-	def self.inspect = "_Callable"
+class Literal::Types::CallableType
+	include Literal::Type
 
-	def self.===(value)
+	def inspect
+		"_Callable"
+	end
+
+	def ===(value)
 		value.respond_to?(:call)
 	end
 
+	def >=(other)
+		(self == other) || (Proc == other) || (Method == other) || case 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) }
+		when Literal::Types::InterfaceType
+			other.methods.include?(:call)
+		else
+			false
+		end
+	end
+
+	Instance = new.freeze
+
 	freeze
 end

data/lib/literal/types/class_type.rb

@@ -2,13 +2,32 @@
 
 # @api private
 class Literal::Types::ClassType
+	include Literal::Type
+
 	def initialize(type)
 		@type = type
 	end
 
-	def inspect = "_Class(#{@type.name})"
+	attr_reader :type
+
+	def inspect
+		"_Class(#{@type.name})"
+	end
 
 	def ===(value)
 		Class === value && (value == @type || value < @type)
 	end
+
+	def >=(other)
+		case other
+		when Literal::Types::ClassType
+			Literal.subtype?(other.type, of: @type)
+		when Literal::Types::DescendantType
+			(Class === other.type) && Literal.subtype?(other.type, of: @type)
+		else
+			false
+		end
+	end
+
+	freeze
 end

data/lib/literal/types/constraint_type.rb

@@ -2,12 +2,19 @@
 
 # @api private
 class Literal::Types::ConstraintType
+	include Literal::Type
+
 	def initialize(*object_constraints, **property_constraints)
 		@object_constraints = object_constraints
 		@property_constraints = property_constraints
 	end
 
-	def inspect = "_Constraint(#{inspect_constraints})"
+	attr_reader :object_constraints
+	attr_reader :property_constraints
+
+	def inspect
+		"_Constraint(#{inspect_constraints})"
+	end
 
 	def ===(value)
 		object_constraints = @object_constraints
@@ -20,11 +27,40 @@ class Literal::Types::ConstraintType
 
 		@property_constraints.each do |a, t|
 			return false unless t === value.public_send(a)
+		rescue NoMethodError => e
+			raise unless e.name == a && e.receiver == value
+			return false
 		end
 
 		true
 	end
 
+	def >=(other)
+		case other
+		when Literal::Types::ConstraintType
+			other_object_constraints = other.object_constraints
+			return false unless @object_constraints.all? do |constraint|
+				other_object_constraints.all? { |c| Literal.subtype?(c, of: constraint) }
+			end
+
+			other_property_constraints = other.property_constraints
+			return false unless @property_constraints.all? do |k, v|
+				Literal.subtype?(other_property_constraints[k], of: v)
+			end
+
+			true
+		when Literal::Types::IntersectionType
+			other_object_constraints = other.types
+			return false unless @object_constraints.all? do |constraint|
+				other_object_constraints.all? { |c| Literal.subtype?(c, of: constraint) }
+			end
+
+			true
+		else
+			false
+		end
+	end
+
 	def record_literal_type_errors(context)
 		@object_constraints.each do |constraint|
 			next if constraint === context.actual
@@ -33,6 +69,7 @@ class Literal::Types::ConstraintType
 		end
 
 		@property_constraints.each do |property, constraint|
+			next unless context.actual.respond_to?(property)
 			actual = context.actual.public_send(property)
 			next if constraint === actual
 
@@ -57,4 +94,6 @@ class Literal::Types::ConstraintType
 			@property_constraints.map { |k, t| "#{k}: #{t.inspect}" }.join(", ")
 		end
 	end
+
+	freeze
 end

data/lib/literal/types/descendant_type.rb

@@ -1,13 +1,30 @@
 # frozen_string_literal: true
 
 class Literal::Types::DescendantType
+	include Literal::Type
+
 	def initialize(type)
 		@type = type
 	end
 
-	def inspect = "_Descendant(#{@type})"
+	attr_reader :type
+
+	def inspect
+		"_Descendant(#{@type})"
+	end
 
 	def ===(value)
 		Module === value && value < @type
 	end
+
+	def >=(other)
+		case other
+		when Literal::Types::DescendantType, Literal::Types::ClassType
+			Literal.subtype?(other.type, of: @type)
+		else
+			false
+		end
+	end
+
+	freeze
 end

data/lib/literal/types/enumerable_type.rb

@@ -2,13 +2,30 @@
 
 # @api private
 class Literal::Types::EnumerableType
+	include Literal::Type
+
 	def initialize(type)
 		@type = type
 	end
 
-	def inspect = "_Enumerable(#{@type.inspect})"
+	attr_reader :type
+
+	def inspect
+		"_Enumerable(#{@type.inspect})"
+	end
 
 	def ===(value)
 		Enumerable === value && value.all?(@type)
 	end
+
+	def >=(other)
+		case other
+		when Literal::Types::EnumerableType
+			Literal.subtype?(other.type, of: @type)
+		else
+			false
+		end
+	end
+
+	freeze
 end

data/lib/literal/types/falsy_type.rb

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

data/lib/literal/types/interface_type.rb

@@ -7,6 +7,8 @@ class Literal::Types::InterfaceType
 		@methods = methods
 	end
 
+	attr_reader :methods
+
 	def inspect = "_Interface(#{@methods.map(&:inspect).join(', ')})"
 
 	def ===(value)

data/lib/literal/types/intersection_type.rb

@@ -8,6 +8,8 @@ class Literal::Types::IntersectionType
 		@types = types
 	end
 
+	attr_reader :types
+
 	def inspect = "_Intersection(#{@types.map(&:inspect).join(', ')})"
 
 	def ===(value)

data/lib/literal/types/json_data_type.rb

@@ -19,5 +19,21 @@ module Literal::Types::JSONDataType
 		end
 	end
 
+	def self.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
+
 	freeze
 end

data/lib/literal/types/map_type.rb

@@ -21,14 +21,15 @@ 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: "[]", expected: key, 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

data/lib/literal/types/nilable_type.rb

@@ -11,4 +11,10 @@ class Literal::Types::NilableType
 	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
+
+	freeze
 end

data/lib/literal/types/set_type.rb

@@ -17,4 +17,14 @@ 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
 end

data/lib/literal/types/union_type.rb

@@ -39,6 +39,13 @@ class Literal::Types::UnionType
 		end
 	end
 
+	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
+
 	protected
 
 	attr_reader :types

data/lib/literal/types.rb

@@ -32,15 +32,15 @@ module Literal::Types
 	autoload :UnionType, "literal/types/union_type"
 	autoload :VoidType, "literal/types/void_type"
 
-	NilableBooleanType = NilableType.new(BooleanType)
-	NilableCallableType = NilableType.new(CallableType)
-	NilableJSONDataType = NilableType.new(JSONDataType)
-	NilableLambdaType = NilableType.new(LambdaType)
-	NilableProcableType = NilableType.new(ProcableType)
+	NilableBooleanType = NilableType.new(BooleanType::Instance).freeze
+	NilableCallableType = NilableType.new(CallableType::Instance).freeze
+	NilableJSONDataType = NilableType.new(JSONDataType).freeze
+	NilableLambdaType = NilableType.new(LambdaType).freeze
+	NilableProcableType = NilableType.new(ProcableType).freeze
 
 	# Matches any value except `nil`. Use `_Any?` or `_Void` to match any value including `nil`.
 	def _Any
-		AnyType
+		AnyType::Instance
 	end
 
 	def _Any?
@@ -61,7 +61,7 @@ module Literal::Types
 
 	# Matches if the value is `true` or `false`.
 	def _Boolean
-		BooleanType
+		BooleanType::Instance
 	end
 
 	# Nilable version of `_Boolean`
@@ -71,7 +71,7 @@ module Literal::Types
 
 	# Matches if the value responds to `#call`.
 	def _Callable
-		CallableType
+		CallableType::Instance
 	end
 
 	# Nilabl version of `_Callable`
@@ -131,7 +131,7 @@ module Literal::Types
 
 	# Matches *"falsy"* values (`nil` and `false`).
 	def _Falsy
-		FalsyType
+		FalsyType::Instance
 	end
 
 	# Matches if the value is a `Float` and matches the given constraint.
@@ -166,9 +166,9 @@ module Literal::Types
 	end
 
 	# Nilable version of `_Hash`
-	def _Hash?
+	def _Hash?(...)
 		NilableType.new(
-			HashType.new,
+			HashType.new(...),
 		)
 	end
 
@@ -184,7 +184,7 @@ module Literal::Types
 	# Nilable version of `_Integer`
 	def _Integer?(...)
 		NilableType.new(
-			IntegerType(...),
+			IntegerType.new(...),
 		)
 	end
 

data/lib/literal/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Literal
-	VERSION = "1.1.0"
+	VERSION = "1.2.0"
 end