literal 1.5.0 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e3b0596d3836316a8c9f2dc13b42707da7e4b158cdf17af864c22be88856e76c
-  data.tar.gz: be38909c66845eb4d09187803903f46cbe8d4392d0245d089aa7aec03c0ac7af
+  metadata.gz: 98bc237de806f82733e8c812bccc840c5451183afd22f369ecffc6720c3b88ba
+  data.tar.gz: b340a2c25c5d23d033a83dbf3ab1483a9b071424f343f0edf5c104bee83402c2
 SHA512:
-  metadata.gz: cfe44962b770aa87464249cd41540e2c26cce61a1b59292fca71b3d79331595483214e22eaa907e3b8453d49a75365219291d196854d843ec09ac1c4ed3b19dd
-  data.tar.gz: 3b6cd6cfeb4fd440c43385462ac3147606389f2afe046eab45cdd3cd9b626dc1fd6e7cdce39c4c5f9b060ea659b99b6ffb7a9ab930a5edb393a11e64f7234557
+  metadata.gz: 17b16bdea93b6dff73b9fdcbdd269053648e996f3e2b5d6773933710281b756a50eb93684d727b46711aef990858985111f9d59d80250d20a3f71963767032ca
+  data.tar.gz: 67647cf3e25cdbdbdb12638081a7cbd40b5bee6771d9be54ca4100646740a97989259f24242b60064c41b016c7687d91a3969632d2195a0715c6015bede8e839

data/lib/literal/enum.rb

@@ -24,7 +24,7 @@ class Literal::Enum
 				@names = {}
 			end
 
-			if RUBY_ENGINE != "truffleruby"
+			if subclass.name && RUBY_ENGINE != "truffleruby"
 				TracePoint.trace(:end) do |tp|
 					if tp.self == subclass
 						tp.self.__after_defined__
@@ -71,9 +71,8 @@ class Literal::Enum
 				raise ArgumentError.new("You can only use `find_by` on unique indexes.")
 			end
 
-			unless (type = @indexes_definitions.fetch(key)[0]) === value
-				raise Literal::TypeError.expected(value, to_be_a: type)
-			end
+			type = @indexes_definitions.fetch(key)[0]
+			Literal.check(actual: value, expected: type)
 
 			@indexes.fetch(key)[value]&.first
 		end

data/lib/literal/properties/schema.rb

@@ -102,7 +102,7 @@ class Literal::Properties::Schema
 		i, n = 0, sorted_properties.size
 		while i < n
 			property = sorted_properties[i]
-			buffer << "  @" << property.name.name << " == other." << property.name.name
+			buffer << "  @#{property.name.name} == other.instance_variable_get(:@#{property.name.name})"
 			buffer << " &&\n  " if i < n - 1
 			i += 1
 		end

data/lib/literal/properties.rb

@@ -30,7 +30,7 @@ module Literal::Properties
 		end
 
 		unless Literal::Property::VISIBILITY_OPTIONS.include?(predicate)
-				raise Literal::ArgumentError.new("The predicate must be one of #{Literal::Property::VISIBILITY_OPTIONS.map(&:inspect).join(', ')}.")
+			raise Literal::ArgumentError.new("The predicate must be one of #{Literal::Property::VISIBILITY_OPTIONS.map(&:inspect).join(', ')}.")
 		end
 
 		if reader && :class == name
@@ -90,7 +90,7 @@ module Literal::Properties
 				end
 
 				def to_h
-						{}
+					{}
 				end
 
 				set_temporary_name "Literal::Properties(Extension)" if respond_to?(:set_temporary_name)

data/lib/literal/rails/enum_type.rb

@@ -6,6 +6,10 @@ class Literal::Rails::EnumType < ActiveModel::Type::Value
 		super()
 	end
 
+	def type
+		:literal_enum
+	end
+
 	def cast(value)
 		case value
 		when nil

data/lib/literal/types/array_type.rb

@@ -6,6 +6,7 @@ class Literal::Types::ArrayType
 
 	def initialize(type)
 		@type = type
+		freeze
 	end
 
 	attr_reader :type

data/lib/literal/types/class_type.rb

@@ -6,6 +6,7 @@ class Literal::Types::ClassType
 
 	def initialize(type)
 		@type = type
+		freeze
 	end
 
 	attr_reader :type

data/lib/literal/types/constraint_type.rb

@@ -7,6 +7,7 @@ class Literal::Types::ConstraintType
 	def initialize(*object_constraints, **property_constraints)
 		@object_constraints = object_constraints
 		@property_constraints = property_constraints
+		freeze
 	end
 
 	attr_reader :object_constraints

data/lib/literal/types/descendant_type.rb

@@ -5,6 +5,7 @@ class Literal::Types::DescendantType
 
 	def initialize(type)
 		@type = type
+		freeze
 	end
 
 	attr_reader :type

data/lib/literal/types/enumerable_type.rb

@@ -6,6 +6,7 @@ class Literal::Types::EnumerableType
 
 	def initialize(type)
 		@type = type
+		freeze
 	end
 
 	attr_reader :type

data/lib/literal/types/frozen_type.rb

@@ -12,6 +12,7 @@ class Literal::Types::FrozenType
 		end
 
 		@type = type
+		freeze
 	end
 
 	attr_reader :type

data/lib/literal/types/hash_type.rb

@@ -7,6 +7,7 @@ class Literal::Types::HashType
 	def initialize(key_type, value_type)
 		@key_type = key_type
 		@value_type = value_type
+		freeze
 	end
 
 	attr_reader :key_type, :value_type

data/lib/literal/types/interface_type.rb

@@ -14,6 +14,7 @@ class Literal::Types::InterfaceType
 	def initialize(*methods)
 		raise Literal::ArgumentError.new("_Interface type must have at least one method.") if methods.size < 1
 		@methods = methods
+		freeze
 	end
 
 	attr_reader :methods

data/lib/literal/types/intersection_type.rb

@@ -8,6 +8,7 @@ class Literal::Types::IntersectionType
 		raise Literal::ArgumentError.new("_Intersection type must have at least one type.") if types.size < 1
 
 		@types = types
+		freeze
 	end
 
 	attr_reader :types

data/lib/literal/types/map_type.rb

@@ -6,6 +6,7 @@ class Literal::Types::MapType
 
 	def initialize(**shape)
 		@shape = shape
+		freeze
 	end
 
 	attr_reader :shape

data/lib/literal/types/nilable_type.rb

@@ -6,6 +6,7 @@ class Literal::Types::NilableType
 
 	def initialize(type)
 		@type = type
+		freeze
 	end
 
 	attr_reader :type

data/lib/literal/types/not_type.rb

@@ -6,6 +6,7 @@ class Literal::Types::NotType
 
 	def initialize(type)
 		@type = type
+		freeze
 	end
 
 	attr_reader :type

data/lib/literal/types/range_type.rb

@@ -6,6 +6,7 @@ class Literal::Types::RangeType
 
 	def initialize(type)
 		@type = type
+		freeze
 	end
 
 	attr_reader :type

data/lib/literal/types/set_type.rb

@@ -6,6 +6,7 @@ class Literal::Types::SetType
 
 	def initialize(type)
 		@type = type
+		freeze
 	end
 
 	attr_reader :type

data/lib/literal/types/tuple_type.rb

@@ -8,6 +8,7 @@ class Literal::Types::TupleType
 		raise Literal::ArgumentError.new("_Tuple type must have at least one type.") if types.size < 1
 
 		@types = types
+		freeze
 	end
 
 	attr_reader :types

data/lib/literal/types/union_type.rb

@@ -3,23 +3,43 @@
 class Literal::Types::UnionType
 	include Enumerable
 
-	def initialize(*types)
-		raise Literal::ArgumentError.new("_Union type must have at least one type.") if types.size < 1
+	def initialize(*queue)
+		raise Literal::ArgumentError.new("_Union type must have at least one type.") if queue.size < 1
+		types = []
+		primitives = Set[]
+
+		while queue.length > 0
+			type = queue.shift
+			case type
+			when Literal::Types::UnionType
+				queue.concat(type.types, type.primitives.to_a)
+			when Array, Hash, String, Symbol, Integer, Float, Complex, Rational, true, false, nil
+				primitives << type
+			else
+				types << type
+			end
+		end
+
+		types.uniq!
+		@types = types
+		@primitives = primitives
 
-		@types = []
-		load_types(types)
-		@types.uniq!
 		@types.freeze
+		@primitives.freeze
+		freeze
 	end
 
-	attr_reader :types
+	attr_reader :types, :primitives
 
 	def inspect
 		"_Union(#{@types.inspect})"
 	end
 
 	def ===(value)
+		return true if @primitives.include?(value)
+
 		types = @types
+
 		i, len = 0, types.size
 		while i < len
 			return true if types[i] === value
@@ -28,48 +48,49 @@ class Literal::Types::UnionType
 	end
 
 	def each(&)
+		@primitives.each(&)
 		@types.each(&)
 	end
 
 	def deconstruct
-		@types.to_a
+		to_a
 	end
 
 	def [](key)
-		if @types.include?(key)
+		if @primitives.include?(key) || @types.include?(key)
 			key
-		else
-			raise ArgumentError.new("#{key} not in #{inspect}")
 		end
 	end
 
+	def fetch(key)
+		self[key] or raise KeyError.new("Key not found: #{key.inspect}")
+	end
+
 	def record_literal_type_errors(ctx)
-		@types.each do |type|
+		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
 
 	def >=(other)
+		types = @types
+		primitives = @primitives
+
 		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)
+			types_have_at_least_one_subtype = other.types.all? do |other_type|
+				primitives.any? { |p| Literal.subtype?(p, of: other_type) } || types.any? { |t| Literal.subtype?(t, of: other_type) }
 			end
-		end
-	end
 
-	private
+			primitives_have_at_least_one_subtype = other.primitives.all? do |other_primitive|
+				primitives.any? { |p| Literal.subtype?(p, of: other_primitive) } || types.any? { |t| Literal.subtype?(t, of: other_primitive) }
+			end
 
-	def load_types(types)
-		types.each do |type|
-			(Literal::Types::UnionType === type) ? load_types(type.types) : @types << type
+			types_have_at_least_one_subtype && primitives_have_at_least_one_subtype
+		else
+			types.any? { |t| Literal.subtype?(other, of: t) } || primitives.any? { |p| Literal.subtype?(other, of: p) }
 		end
 	end
 

data/lib/literal/types.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 module Literal::Types
+	extend self
+
 	autoload :AnyType, "literal/types/any_type"
 	autoload :ArrayType, "literal/types/array_type"
 	autoload :BooleanType, "literal/types/boolean_type"
@@ -26,125 +28,175 @@ module Literal::Types
 	autoload :UnionType, "literal/types/union_type"
 	autoload :VoidType, "literal/types/void_type"
 
-	ProcableType = InterfaceType.new(:to_proc).freeze
-	CallableType = InterfaceType.new(:call).freeze
-	LambdaType = ConstraintType.new(Proc, lambda?: true).freeze
-
-	NilableBooleanType = NilableType.new(BooleanType::Instance).freeze
-	NilableCallableType = NilableType.new(CallableType).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`.
+	# ```ruby
+	# _Any
+	# ```
 	def _Any
 		AnyType::Instance
 	end
 
+	# Matches any value including `nil`. This is the same as `_Void` and the opposite of `_Never`.
+	# ```ruby
+	# _Any?
+	# ```
 	def _Any?
 		VoidType::Instance
 	end
 
-	# Matches if the value is an `Array` and all the elements match the given type.
-	def _Array(...)
-		ArrayType.new(...)
+	# Matches if the value is an `Array` and all the elements of the array match the given type.
+	# ```ruby
+	# _Array(String)
+	# ```
+	def _Array(type)
+		ArrayType.new(type)
 	end
 
-	# Nilable version of `_Array`
-	def _Array?(...)
-		NilableType.new(
-			ArrayType.new(...)
+	# Nilable version of `_Array`.
+	# ```ruby
+	# _Array?(String)
+	# ```
+	def _Array?(type)
+		_Nilable(
+			_Array(type)
 		)
 	end
 
-	# Matches if the value is `true` or `false`.
+	# Matches if the value is either `true` or `false`. This is equivalent to `_Union(true, false)`.
+	# ```ruby
+	# _Boolean
+	# ```
 	def _Boolean
 		BooleanType::Instance
 	end
 
-	# Nilable version of `_Boolean`
+	# Nilable version of `_Boolean`.
+	# ```ruby
+	# _Boolean?
+	# ```
 	def _Boolean?
 		NilableBooleanType
 	end
 
 	# Matches if the value responds to `#call`.
+	# ```ruby
+	# _Callable
+	# ```
 	def _Callable
 		CallableType
 	end
 
-	# Nilabl version of `_Callable`
+	# Nilable version of `_Callable`.
+	# ```ruby
+	# _Callable?
+	# ```
 	def _Callable?
 		NilableCallableType
 	end
 
 	# Matches if the value either the given class or a subclass of it.
-	def _Class(...)
-		ClassType.new(...)
+	# ```ruby
+	# _Class(ActiveRecord::Base)
+	# ```
+	def _Class(expected_class)
+		ClassType.new(expected_class)
 	end
 
-	# Nilable version of `_Class`
+	# Nilable version of `_Class`.
+	# ```ruby
+	# _Class?(ActiveRecord::Base)
+	# ```
 	def _Class?(...)
-		NilableType.new(
-			ClassType.new(...)
+		_Nilable(
+			_Class(...)
 		)
 	end
 
 	# Similar to `_Intersection`, but allows you to specify attribute constraints as keyword arguments.
-	# @example
-	# 	_Constraint(Array, size: 1..3)
-	def _Constraint(...)
-		ConstraintType.new(...)
+	# ```ruby
+	# _Constraint(Array, size: 1..3)
+	# ```
+	def _Constraint(*a, **k)
+		if a.length == 1 && k.length == 0
+			a[0]
+		else
+			ConstraintType.new(*a, **k)
+		end
 	end
 
 	# Nilable version of `_Constraint`
+	# ```ruby
+	# _Constraint?(Array, size: 1..3)
+	# ```
 	def _Constraint?(...)
-		NilableType.new(
-			ConstraintType.new(...)
+		_Nilable(
+			_Constraint(...)
 		)
 	end
 
 	# Matches if the value is a `Date` and matches the given constraints.
-	# If you don't need any constraints, use `Date` instead of `_Date`.
+	# If you don't need any constraints, use `Date` instead of `_Date`. See also `_Constraint`.
+	# ```ruby
+	# _Date((Date.today)..)
+	# _Date(year: 2025)
+	# ```
 	def _Date(...)
 		_Constraint(Date, ...)
 	end
 
-	# Nilable version of `_Date`
+	# Nilable version of `_Date`.
 	def _Date?(...)
 		_Nilable(
 			_Date(...)
 		)
 	end
 
-	def _Deferred(...)
-		DeferredType.new(...)
+	# Takes a type as a block so it can be resolved when needed. This is useful if declaring your type now would cause an error because constants haven’t been defined yet.
+	# ```ruby
+	# _Deferred { _Class(SomeFutureConstant) }
+	# ```
+	def _Deferred(&type)
+		DeferredType.new(&type)
+	end
+
+	# Nilable version of `_Deferred`.
+	def _Deferred?(&type)
+		_Nilable(
+			_Deferred(&type)
+		)
 	end
 
 	# Matches if the value is a descendant of the given class.
+	# ```ruby
+	# _Descendant(ActiveRecord::Base)
+	# ```
 	def _Descendant(...)
 		DescendantType.new(...)
 	end
 
-	# Nilable version of `_Descendant`
+	# Nilable version of `_Descendant`.
 	def _Descendant?(...)
-		NilableType.new(
-			DescendantType.new(...)
+		_Nilable(
+			_Descendant(...)
 		)
 	end
 
 	#  Matches if the value is an `Enumerable` and all its elements match the given type.
-	def _Enumerable(...)
-		EnumerableType.new(...)
+	# ```ruby
+	# _Enumerable(String)
+	# ```
+	def _Enumerable(type)
+		EnumerableType.new(type)
 	end
 
-	# Nilable version of `_Enumerable`
+	# Nilable version of `_Enumerable`.
 	def _Enumerable?(...)
-		NilableType.new(
-			EnumerableType.new(...)
+		_Nilable(
+			_Enumerable(...)
 		)
 	end
 
-	# Matches *"falsy"* values (`nil` and `false`).
+	# Matches *"falsy"* values (`nil` and `false`). This is equivalent to `_Nilable(false)` or `_Union(nil, false)`.
 	def _Falsy
 		FalsyType::Instance
 	end
@@ -152,11 +204,14 @@ module Literal::Types
 	# Matches if the value is a `Float` and matches the given constraints.
 	# You could use a `Range`, for example, as a constraint.
 	# If you don't need a constraint, use `Float` instead of `_Float`.
+	# ```ruby
+	# _Float(5..10)
+	# ```
 	def _Float(...)
 		_Constraint(Float, ...)
 	end
 
-	# Nilable version of `_Float`
+	# Nilable version of `_Float`.
 	def _Float?(...)
 		_Nilable(
 			_Float(...)
@@ -170,8 +225,8 @@ module Literal::Types
 
 	# Nilable version of `_Frozen`
 	def _Frozen?(...)
-		NilableType.new(
-			FrozenType.new(...)
+		_Nilable(
+			_Frozen(...)
 		)
 	end
 
@@ -182,8 +237,8 @@ module Literal::Types
 
 	# Nilable version of `_Hash`
 	def _Hash?(...)
-		NilableType.new(
-			HashType.new(...)
+		_Nilable(
+			_Hash(...)
 		)
 	end
 
@@ -210,8 +265,8 @@ module Literal::Types
 
 	# Nilable version of `_Interface`
 	def _Interface?(...)
-		NilableType.new(
-			InterfaceType.new(...)
+		_Nilable(
+			_Interface(...)
 		)
 	end
 
@@ -222,8 +277,8 @@ module Literal::Types
 
 	# Nilable version of `_Intersection`
 	def _Intersection?(...)
-		NilableType.new(
-			IntersectionType.new(...)
+		_Nilable(
+			_Intersection(...)
 		)
 	end
 
@@ -247,14 +302,20 @@ module Literal::Types
 		NilableLambdaType
 	end
 
+	# ```ruby
+	# _Map(name: String, age: Integer)
+	# ```
 	def _Map(...)
 		MapType.new(...)
 	end
 
 	# Nilable version of `_Map`
+	# ```ruby
+	# _Map?(name: String, age: Integer)
+	# ```
 	def _Map?(...)
-		NilableType.new(
-			MapType.new(...)
+		_Nilable(
+			_Map(...)
 		)
 	end
 
@@ -295,8 +356,8 @@ module Literal::Types
 
 	# Nilable version of `_Range`
 	def _Range?(...)
-		NilableType.new(
-			RangeType.new(...)
+		_Nilable(
+			_Range(...)
 		)
 	end
 
@@ -307,8 +368,8 @@ module Literal::Types
 
 	# Nilable version of `_Set`
 	def _Set?(...)
-		NilableType.new(
-			SetType.new(...)
+		_Nilable(
+			_Set(...)
 		)
 	end
 
@@ -356,14 +417,20 @@ module Literal::Types
 	end
 
 	# Matches if the value is an `Array` and each element matches the given types in order.
+	# ```ruby
+	# _Tuple(String, Integer, Integer)
+	# ```
 	def _Tuple(...)
 		TupleType.new(...)
 	end
 
 	# Nilable version of `_Typle`
+	# ```ruby
+	# _Tuple?(String, Integer, Integer)
+	# ```
 	def _Tuple?(...)
-		NilableType.new(
-			TupleType.new(...)
+		_Nilable(
+			_Tuple(...)
 		)
 	end
 
@@ -374,12 +441,22 @@ module Literal::Types
 
 	# Nilable version of `_Union`
 	def _Union?(...)
-		NilableType.new(
-			UnionType.new(...)
+		_Nilable(
+			_Union(...)
 		)
 	end
 
 	def _Void
 		VoidType::Instance
 	end
+
+	ProcableType = _Interface(:to_proc)
+	CallableType = _Interface(:call)
+	LambdaType = _Constraint(Proc, lambda?: true)
+
+	NilableBooleanType = _Nilable(BooleanType::Instance)
+	NilableCallableType = _Nilable(CallableType)
+	NilableJSONDataType = _Nilable(JSONDataType)
+	NilableLambdaType = _Nilable(LambdaType)
+	NilableProcableType = _Nilable(ProcableType)
 end

data/lib/literal/version.rb

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

data/lib/literal.rb

@@ -63,15 +63,35 @@ module Literal
 	end
 
 	def self.subtype?(type, of:)
-		type = type.block.call if Types::DeferredType === type
+		supertype = of
+		subtype = type
 
-		(of == type) || case of
+		subtype = subtype.block.call if Types::DeferredType === subtype
+
+		return true if supertype == subtype
+
+		case supertype
 		when Literal::Type
-			of >= type
+			supertype >= subtype
 		when Module
-			(Module === type) ? of >= type : false
+			case subtype
+			when Module
+				supertype >= subtype
+			when Numeric
+				Numeric >= supertype
+			when String
+				String >= supertype
+			when Symbol
+				Symbol >= supertype
+			when ::Array
+				::Array >= supertype
+			when ::Hash
+				::Hash >= supertype
+			else
+				false
+			end
 		when Range
-			of.cover?(type)
+			supertype.cover?(subtype)
 		else
 			false
 		end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: literal
 version: !ruby/object:Gem::Version
-  version: 1.5.0
+  version: 1.6.0
 platform: ruby
 authors:
 - Joel Drapper
 bindir: bin
 cert_chain: []
-date: 2025-01-17 00:00:00.000000000 Z
+date: 2025-03-10 00:00:00.000000000 Z
 dependencies: []
 description: Enums, properties, generics, structured objects and runtime type checking.
 email: