literal 1.4.0 → 1.6.0

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,112 +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
 
-	def _Deferred(...)
-		DeferredType.new(...)
+	# Matches if the value is a `Date` and matches the given constraints.
+	# 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`.
+	def _Date?(...)
+		_Nilable(
+			_Date(...)
+		)
+	end
+
+	# 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
@@ -139,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(...)
@@ -157,8 +225,8 @@ module Literal::Types
 
 	# Nilable version of `_Frozen`
 	def _Frozen?(...)
-		NilableType.new(
-			FrozenType.new(...)
+		_Nilable(
+			_Frozen(...)
 		)
 	end
 
@@ -169,8 +237,8 @@ module Literal::Types
 
 	# Nilable version of `_Hash`
 	def _Hash?(...)
-		NilableType.new(
-			HashType.new(...)
+		_Nilable(
+			_Hash(...)
 		)
 	end
 
@@ -197,8 +265,8 @@ module Literal::Types
 
 	# Nilable version of `_Interface`
 	def _Interface?(...)
-		NilableType.new(
-			InterfaceType.new(...)
+		_Nilable(
+			_Interface(...)
 		)
 	end
 
@@ -209,8 +277,8 @@ module Literal::Types
 
 	# Nilable version of `_Intersection`
 	def _Intersection?(...)
-		NilableType.new(
-			IntersectionType.new(...)
+		_Nilable(
+			_Intersection(...)
 		)
 	end
 
@@ -234,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
 
@@ -282,8 +356,8 @@ module Literal::Types
 
 	# Nilable version of `_Range`
 	def _Range?(...)
-		NilableType.new(
-			RangeType.new(...)
+		_Nilable(
+			_Range(...)
 		)
 	end
 
@@ -294,8 +368,8 @@ module Literal::Types
 
 	# Nilable version of `_Set`
 	def _Set?(...)
-		NilableType.new(
-			SetType.new(...)
+		_Nilable(
+			_Set(...)
 		)
 	end
 
@@ -324,20 +398,39 @@ module Literal::Types
 		)
 	end
 
+	# Matches if the value is a `Time` and matches the given constraints.
+	# If you don't need any constraints, use `Time` instead of `_Time`.
+	def _Time(...)
+		_Constraint(Time, ...)
+	end
+
+	# Nilable version of `_Time`
+	def _Time?(...)
+		_Nilable(
+			_Time(...)
+		)
+	end
+
 	# Matches *"truthy"* values (anything except `nil` and `false`).
 	def _Truthy
 		TruthyType::Instance
 	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
 
@@ -348,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.4.0"
+	VERSION = "1.6.0"
 end

data/lib/literal.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 module Literal
-	TYPE_CHECKS_DISABLED = ENV["LITERAL_TYPE_CHECKS"] == "false"
-
 	autoload :Array, "literal/array"
 	autoload :Data, "literal/data"
 	autoload :DataProperty, "literal/data_property"
@@ -33,7 +31,7 @@ module Literal
 
 	def self.Enum(type)
 		Class.new(Literal::Enum) do
-			prop :value, type, :positional
+			prop :value, type, :positional, reader: :public
 		end
 	end
 
@@ -65,15 +63,35 @@ module Literal
 	end
 
 	def self.subtype?(type, of:)
-		type = type.block.call if Types::DeferredType === type
+		supertype = of
+		subtype = type
+
+		subtype = subtype.block.call if Types::DeferredType === subtype
+
+		return true if supertype == subtype
 
-		(of == type) || case of
+		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