literal 1.5.0 → 1.7.0

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
@@ -35,17 +36,17 @@ class Literal::Types::IntersectionType
 		when Literal::Types::IntersectionType
 			@types.all? do |type|
 				other.types.any? do |other_type|
-					Literal.subtype?(other_type, of: type)
+					Literal.subtype?(other_type, type)
 				end
 			end
 		when Literal::Types::ConstraintType
 			@types.all? do |type|
 				other.object_constraints.any? do |object_constraint|
-					Literal.subtype?(object_constraint, of: type)
+					Literal.subtype?(object_constraint, type)
 				end
 			end
 		when Literal::Types::FrozenType
-			@types.all? { |type| Literal.subtype?(other.type, of: type) }
+			@types.all? { |type| Literal.subtype?(other.type, type) }
 		else
 			false
 		end

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
@@ -44,7 +45,7 @@ class Literal::Types::MapType
 			other_shape = other.shape
 
 			@shape.all? do |k, v|
-				Literal.subtype?(other_shape[k], of: v)
+				Literal.subtype?(other_shape[k], v)
 			end
 		else
 			false

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
@@ -25,11 +26,11 @@ class Literal::Types::NilableType
 	def >=(other)
 		case other
 		when Literal::Types::NilableType
-			Literal.subtype?(other.type, of: @type)
+			Literal.subtype?(other.type, @type)
 		when nil
 			true
 		else
-			Literal.subtype?(other, of: @type)
+			Literal.subtype?(other, @type)
 		end
 	end
 

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
@@ -21,11 +22,11 @@ class Literal::Types::NotType
 	def >=(other)
 		case other
 		when Literal::Types::NotType
-			Literal.subtype?(other.type, of: @type)
+			Literal.subtype?(other.type, @type)
 		when Literal::Types::ConstraintType
-			other.object_constraints.any? { |constraint| Literal.subtype?(constraint, of: self) }
+			other.object_constraints.any? { |constraint| Literal.subtype?(constraint, self) }
 		when Literal::Types::IntersectionType
-			other.types.any? { |type| Literal.subtype?(type, of: self) }
+			other.types.any? { |type| Literal.subtype?(type, self) }
 		else
 			false
 		end

data/lib/literal/types/predicate_type.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class Literal::Types::PredicateType
+	include Literal::Type
+
+	def initialize(message:, block:)
+		@message = message
+		@block = block
+
+		freeze
+	end
+
+	def inspect
+		%(_Predicate("#{@message}"))
+	end
+
+	def ===(other)
+		@block === other
+	end
+
+	freeze
+end

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
@@ -27,7 +28,7 @@ class Literal::Types::RangeType
 	def >=(other)
 		case other
 		when Literal::Types::RangeType
-			Literal.subtype?(other.type, of: @type)
+			Literal.subtype?(other.type, @type)
 		else
 			false
 		end

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
@@ -37,7 +38,7 @@ class Literal::Types::SetType
 	def >=(other)
 		case other
 		when Literal::Types::SetType
-			Literal.subtype?(other.type, of: @type)
+			Literal.subtype?(other.type, @type)
 		else
 			false
 		end

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

@@ -2,74 +2,90 @@
 
 class Literal::Types::UnionType
 	include Enumerable
+	include Literal::Type
 
-	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})"
+		"_Union(#{to_a.map(&:inspect).join(', ')})"
 	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
 			i += 1
 		end
+
+		false
 	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 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? }
+	def fetch(key)
+		self[key] or raise KeyError.new("Key not found: #{key.inspect}")
 	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?(other_type, p) } || types.any? { |t| Literal.subtype?(other_type, t) }
 			end
-		end
-	end
 
-	private
+			primitives_have_at_least_one_subtype = other.primitives.all? do |other_primitive|
+				primitives.any? { |p| Literal.subtype?(other_primitive, p) } || types.any? { |t| Literal.subtype?(other_primitive, t) }
+			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, t) } || primitives.any? { |p| Literal.subtype?(other, p) }
 		end
 	end
 

data/lib/literal/types.rb

@@ -1,150 +1,177 @@
 # frozen_string_literal: true
 
 module Literal::Types
-	autoload :AnyType, "literal/types/any_type"
-	autoload :ArrayType, "literal/types/array_type"
-	autoload :BooleanType, "literal/types/boolean_type"
-	autoload :ClassType, "literal/types/class_type"
-	autoload :ConstraintType, "literal/types/constraint_type"
-	autoload :DeferredType, "literal/deferred_type"
-	autoload :DescendantType, "literal/types/descendant_type"
-	autoload :EnumerableType, "literal/types/enumerable_type"
-	autoload :FalsyType, "literal/types/falsy_type"
-	autoload :FrozenType, "literal/types/frozen_type"
-	autoload :HashType, "literal/types/hash_type"
-	autoload :InterfaceType, "literal/types/interface_type"
-	autoload :IntersectionType, "literal/types/intersection_type"
-	autoload :JSONDataType, "literal/types/json_data_type"
-	autoload :MapType, "literal/types/map_type"
-	autoload :NeverType, "literal/types/never_type"
-	autoload :NilableType, "literal/types/nilable_type"
-	autoload :NotType, "literal/types/not_type"
-	autoload :RangeType, "literal/types/range_type"
-	autoload :SetType, "literal/types/set_type"
-	autoload :TruthyType, "literal/types/truthy_type"
-	autoload :TupleType, "literal/types/tuple_type"
-	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
+	extend self
 
 	# 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 +179,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 +200,8 @@ module Literal::Types
 
 	# Nilable version of `_Frozen`
 	def _Frozen?(...)
-		NilableType.new(
-			FrozenType.new(...)
+		_Nilable(
+			_Frozen(...)
 		)
 	end
 
@@ -182,8 +212,8 @@ module Literal::Types
 
 	# Nilable version of `_Hash`
 	def _Hash?(...)
-		NilableType.new(
-			HashType.new(...)
+		_Nilable(
+			_Hash(...)
 		)
 	end
 
@@ -210,8 +240,8 @@ module Literal::Types
 
 	# Nilable version of `_Interface`
 	def _Interface?(...)
-		NilableType.new(
-			InterfaceType.new(...)
+		_Nilable(
+			_Interface(...)
 		)
 	end
 
@@ -222,8 +252,8 @@ module Literal::Types
 
 	# Nilable version of `_Intersection`
 	def _Intersection?(...)
-		NilableType.new(
-			IntersectionType.new(...)
+		_Nilable(
+			_Intersection(...)
 		)
 	end
 
@@ -247,14 +277,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
 
@@ -278,6 +314,10 @@ module Literal::Types
 		end
 	end
 
+	def _Predicate(message, &block)
+		PredicateType.new(message:, block:)
+	end
+
 	# Matches if the value is a `Proc` or responds to `#to_proc`.
 	def _Procable
 		ProcableType
@@ -295,8 +335,8 @@ module Literal::Types
 
 	# Nilable version of `_Range`
 	def _Range?(...)
-		NilableType.new(
-			RangeType.new(...)
+		_Nilable(
+			_Range(...)
 		)
 	end
 
@@ -307,8 +347,8 @@ module Literal::Types
 
 	# Nilable version of `_Set`
 	def _Set?(...)
-		NilableType.new(
-			SetType.new(...)
+		_Nilable(
+			_Set(...)
 		)
 	end
 
@@ -356,14 +396,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 +420,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