literal 1.6.0 → 1.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 98bc237de806f82733e8c812bccc840c5451183afd22f369ecffc6720c3b88ba
-  data.tar.gz: b340a2c25c5d23d033a83dbf3ab1483a9b071424f343f0edf5c104bee83402c2
+  metadata.gz: bfccfa4acf4ec640c3a47a2bab9d34aec7295a29abc387a20e81f6fb3beb085b
+  data.tar.gz: a5a029b15bfc36d930338fc5c2dd6b52abdab0ad1315d54725d2ad90e681bb97
 SHA512:
-  metadata.gz: 17b16bdea93b6dff73b9fdcbdd269053648e996f3e2b5d6773933710281b756a50eb93684d727b46711aef990858985111f9d59d80250d20a3f71963767032ca
-  data.tar.gz: 67647cf3e25cdbdbdb12638081a7cbd40b5bee6771d9be54ca4100646740a97989259f24242b60064c41b016c7687d91a3969632d2195a0715c6015bede8e839
+  metadata.gz: 9207d8ba24e146a2d9400c640b6d4c5d6fa97694d95097cf86ac09ebedf16613daa7b1cd4b7946b447809d71aef2e3dca8cd805c59902e3744d00d5b10da37a1
+  data.tar.gz: f02700e76bd9a65ef3d3885f3c79984cec164ac47af50f153bb034026d71576926245bc7a481f728c46ea6410a984d45d97d217d16ed1b34b6bf72233179033b

data/lib/literal/array.rb

@@ -17,13 +17,13 @@ class Literal::Array
 		alias_method :[], :new
 
 		def ===(value)
-			Literal::Array === value && Literal.subtype?(value.__type__, of: @type)
+			Literal::Array === value && Literal.subtype?(value.__type__, @type)
 		end
 
 		def >=(other)
 			case other
 			when Literal::Array::Generic
-				Literal.subtype?(other.type, of: @type)
+				Literal.subtype?(other.type, @type)
 			else
 				false
 			end
@@ -51,7 +51,7 @@ class Literal::Array
 	include Literal::Types
 
 	def initialize(value, type:)
-		Literal.check(actual: value, expected: _Array(type)) do |c|
+		Literal.check(value, _Array(type)) do |c|
 			c.fill_receiver(receiver: self, method: "#initialize")
 		end
 
@@ -98,7 +98,7 @@ class Literal::Array
 	def +(other)
 		case other
 		when ::Array
-			Literal.check(actual: other, expected: _Array(@__type__)) do |c|
+			Literal.check(other, _Array(@__type__)) do |c|
 				c.fill_receiver(receiver: self, method: "#+")
 			end
 
@@ -129,7 +129,7 @@ class Literal::Array
 	end
 
 	def <<(value)
-		Literal.check(actual: value, expected: @__type__) do |c|
+		Literal.check(value, @__type__) do |c|
 			c.fill_receiver(receiver: self, method: "#<<")
 		end
 
@@ -157,7 +157,7 @@ class Literal::Array
 	end
 
 	def []=(index, value)
-		Literal.check(actual: value, expected: @__type__) do |c|
+		Literal.check(value, @__type__) do |c|
 			c.fill_receiver(receiver: self, method: "#[]=")
 		end
 
@@ -284,7 +284,7 @@ class Literal::Array
 	alias_method :index, :find_index
 
 	def insert(index, *value)
-		Literal.check(actual: value, expected: _Array(@__type__)) do |c|
+		Literal.check(value, _Array(@__type__)) do |c|
 			c.fill_receiver(receiver: self, method: "#insert")
 		end
 
@@ -344,9 +344,9 @@ class Literal::Array
 
 	def map(type, &block)
 		my_type = @__type__
-		transform_type = Literal::TRANSFORMS.dig(my_type, block)
+		transform_type = Literal::Transforms.dig(my_type, block)
 
-		if transform_type && Literal.subtype?(transform_type, of: my_type)
+		if transform_type && Literal.subtype?(transform_type, my_type)
 			Literal::Array.allocate.__initialize_without_check__(
 				@__value__.map(&block),
 				type:,
@@ -392,13 +392,13 @@ class Literal::Array
 	end
 
 	def narrow(type)
-		unless Literal.subtype?(type, of: @__type__)
+		unless Literal.subtype?(type, @__type__)
 			raise ArgumentError.new("Cannot narrow #{@__type__} to #{type}")
 		end
 
 		if __type__ != type
 			@__value__.each do |item|
-				Literal.check(actual: item, expected: type) do |c|
+				Literal.check(item, type) do |c|
 					c.fill_receiver(receiver: self, method: "#narrow")
 				end
 			end
@@ -453,7 +453,7 @@ class Literal::Array
 	end
 
 	def push(*value)
-		Literal.check(actual: value, expected: _Array(@__type__)) do |c|
+		Literal.check(value, _Array(@__type__)) do |c|
 			c.fill_receiver(receiver: self, method: "#push")
 		end
 
@@ -475,7 +475,7 @@ class Literal::Array
 	def replace(value)
 		case value
 		when Array
-			Literal.check(actual: value, expected: _Array(@__type__)) do |c|
+			Literal.check(value, _Array(@__type__)) do |c|
 				c.fill_receiver(receiver: self, method: "#replace")
 			end
 
@@ -597,7 +597,7 @@ class Literal::Array
 	end
 
 	def unshift(value)
-		Literal.check(actual: value, expected: @__type__) do |c|
+		Literal.check(value, @__type__) do |c|
 			c.fill_receiver(receiver: self, method: "#unshift")
 		end
 
@@ -636,7 +636,7 @@ class Literal::Array
 	def |(other)
 		case other
 		when ::Array
-			Literal.check(actual: other, expected: _Array(@__type__)) do |c|
+			Literal.check(other, _Array(@__type__)) do |c|
 				c.fill_receiver(receiver: self, method: "#|")
 			end
 

data/lib/literal/data_structure.rb

@@ -38,7 +38,7 @@ class Literal::DataStructure
 	end
 
 	def marshal_dump
-		[1, to_h, frozen?]
+		[1, to_h, frozen?].freeze
 	end
 
 	def hash
@@ -46,9 +46,10 @@ class Literal::DataStructure
 	end
 
 	def ==(other)
-		other.is_a?(self.class) && other.class.literal_properties.empty?
+		self.class === other && other.class.literal_properties.empty?
 	end
-	alias eql? ==
+
+	alias_method :eql?, :==
 
 	def self.__generate_literal_methods__(new_property, buffer = +"")
 		super

data/lib/literal/delegator.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class Literal::Delegator < SimpleDelegator
+	def self.to_proc
+		-> (value) { new(value) }
+	end
+
+	def self.[](value)
+		new(value)
+	end
+
+	def initialize(value)
+		Literal.check(value, __type__)
+		super
+		freeze
+	end
+
+	def ===(other)
+		self.class === other && __getobj__ == other.__getobj__
+	end
+
+	alias_method :==, :===
+
+	freeze
+end

data/lib/literal/enum.rb

@@ -55,7 +55,7 @@ class Literal::Enum
 
 			types = @indexes_definitions.fetch(key)
 			type = types.first
-			Literal.check(actual: value, expected: type) { |c| raise NotImplementedError }
+			Literal.check(value, type) { |c| raise NotImplementedError }
 
 			@indexes.fetch(key)[value]
 		end
@@ -72,7 +72,7 @@ class Literal::Enum
 			end
 
 			type = @indexes_definitions.fetch(key)[0]
-			Literal.check(actual: value, expected: type)
+			Literal.check(value, type)
 
 			@indexes.fetch(key)[value]&.first
 		end

data/lib/literal/flags/flags_16.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Literal::Flags16 < Literal::Flags
+	BYTES = 2
+	BITS = BYTES * 8
+	PACKER = "S"
+end

data/lib/literal/flags/flags_32.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Literal::Flags32 < Literal::Flags
+	BYTES = 4
+	BITS = BYTES * 8
+	PACKER = "L"
+end

data/lib/literal/flags/flags_64.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Literal::Flags64 < Literal::Flags
+	BYTES = 8
+	BITS = BYTES * 8
+	PACKER = "Q"
+end

data/lib/literal/flags/flags_8.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Literal::Flags8 < Literal::Flags
+	BYTES = 1
+	BITS = BYTES * 8
+	PACKER = "C"
+end

data/lib/literal/flags.rb

@@ -219,27 +219,3 @@ class Literal::Flags
 		2 ** self.class::FLAGS.fetch(key)
 	end
 end
-
-class Literal::Flags8 < Literal::Flags
-	BYTES = 1
-	BITS = BYTES * 8
-	PACKER = "C"
-end
-
-class Literal::Flags16 < Literal::Flags
-	BYTES = 2
-	BITS = BYTES * 8
-	PACKER = "S"
-end
-
-class Literal::Flags32 < Literal::Flags
-	BYTES = 4
-	BITS = BYTES * 8
-	PACKER = "L"
-end
-
-class Literal::Flags64 < Literal::Flags
-	BYTES = 8
-	BITS = BYTES * 8
-	PACKER = "Q"
-end

data/lib/literal/hash.rb

@@ -25,7 +25,7 @@ class Literal::Hash
 	def initialize(value, key_type:, value_type:)
 		collection_type = Literal::Types::HashType.new(key_type, value_type)
 
-		Literal.check(actual: value, expected: collection_type) do |c|
+		Literal.check(value, collection_type) do |c|
 			c.fill_receiver(receiver: self, method: "#initialize")
 		end
 

data/lib/literal/properties/schema.rb

@@ -62,7 +62,7 @@ class Literal::Properties::Schema
 	end
 
 	def generate_after_initializer(buffer = +"")
-		buffer << "  after_initialize if respond_to?(:after_initialize)\n"
+		buffer << "  after_initialize if respond_to?(:after_initialize, true)\n"
 	end
 
 	def generate_to_h(buffer = +"")
@@ -96,7 +96,7 @@ class Literal::Properties::Schema
 
 	def generate_eq(buffer = +"")
 		buffer << "def ==(other)\n"
-		buffer << "  return false unless other.is_a?(self.class) && other.class.literal_properties.size == self.class.literal_properties.size\n"
+		buffer << "  return false unless self.class === other && other.class.literal_properties.size == self.class.literal_properties.size\n"
 
 		sorted_properties = @sorted_properties
 		i, n = 0, sorted_properties.size

data/lib/literal/properties.rb

@@ -1,9 +1,6 @@
 # frozen_string_literal: true
 
 module Literal::Properties
-	autoload :Schema, "literal/properties/schema"
-	autoload :DataSchema, "literal/properties/data_schema"
-
 	include Literal::Types
 
 	module DocString
@@ -57,12 +54,14 @@ module Literal::Properties
 		literal_properties << property
 		__define_literal_methods__(property)
 		include(__literal_extension__)
+
+		name
 	end
 
 	def literal_properties
 		return @literal_properties if defined?(@literal_properties)
 
-		if superclass.is_a?(Literal::Properties)
+		if Literal::Properties === superclass
 			@literal_properties = superclass.literal_properties.dup
 		else
 			@literal_properties = Literal::Properties::Schema.new

data/lib/literal/property.rb

@@ -97,15 +97,15 @@ class Literal::Property
 	def check(value, &)
 		raise ArgumentError.new("Cannot check type without a block") unless block_given?
 
-		Literal.check(actual: value, expected: @type, &)
+		Literal.check(value, @type, &)
 	end
 
 	def check_writer(receiver, value)
-		Literal.check(actual: value, expected: @type) { |c| c.fill_receiver(receiver:, method: "##{@name.name}=(value)") }
+		Literal.check(value, @type) { |c| c.fill_receiver(receiver:, method: "##{@name.name}=(value)") }
 	end
 
 	def check_initializer(receiver, value)
-		Literal.check(actual: value, expected: @type) { |c| c.fill_receiver(receiver:, method: "#initialize", label: param) }
+		Literal.check(value, @type) { |c| c.fill_receiver(receiver:, method: "#initialize", label: param) }
 	end
 
 	def generate_reader_method(buffer = +"")

data/lib/literal/rails/active_record_relation_patch.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Literal::Rails
+	module ActiveRecordRelationPatch
+		def Relation(model)
+			RelationType.new(model)
+		end
+	end
+end

data/lib/literal/rails/relation_type.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Literal::Rails
+	class RelationType
+		def initialize(model_class)
+			unless Class === model_class && model_class < ActiveRecord::Base
+				raise Literal::TypeError.new(
+						context: Literal::TypeError::Context.new(
+							expected: ActiveRecord::Base, actual: model_class
+						)
+					)
+			end
+
+			@model_class = model_class
+		end
+
+		def inspect = "ActiveRecord::Relation(#{@model_class.name})"
+
+		def ===(value)
+			case value
+				when ActiveRecord::Relation, ActiveRecord::Associations::CollectionProxy, ActiveRecord::AssociationRelation
+					@model_class == value.model || value.model < @model_class
+				else
+					false
+			end
+		end
+	end
+end

data/lib/literal/railtie.rb

@@ -1,15 +1,42 @@
 # frozen_string_literal: true
 
+module Literal::Rails
+	if defined?(::ActiveJob)
+		require_relative "rails/enum_serializer"
+	end
+
+	if defined?(::ActiveRecord::Relation)
+		require_relative "rails/relation_type"
+		require_relative "rails/active_record_relation_patch"
+		::ActiveRecord.extend(ActiveRecordRelationPatch)
+	end
+end
+
 class Literal::Railtie < Rails::Railtie
-	initializer "literal.register_literal_enum_type" do
-		[ActiveRecord::Type, ActiveModel::Type].each do |registry|
-			registry.register(:literal_enum) do |name, type:|
+	if defined?(::ActiveModel::Type)
+		require_relative "rails/enum_type"
+		require_relative "rails/flags_type"
+
+		initializer "literal.register_active_model_types" do
+			ActiveModel::Type.register(:literal_enum) do |name, type:|
 				Literal::Rails::EnumType.new(type)
 			end
 
-			registry.register(:literal_flags) do |name, type:|
+			ActiveModel::Type.register(:literal_flags) do |name, type:|
 				Literal::Rails::FlagsType.new(type)
 			end
 		end
+
+		if defined?(::ActiveRecord::Type)
+			initializer "literal.register_active_record_types" do
+				ActiveRecord::Type.register(:literal_enum) do |name, type:|
+					Literal::Rails::EnumType.new(type)
+				end
+
+				ActiveRecord::Type.register(:literal_flags) do |name, type:|
+					Literal::Rails::FlagsType.new(type)
+				end
+			end
+		end
 	end
 end

data/lib/literal/set.rb

@@ -26,7 +26,7 @@ class Literal::Set
 	def initialize(value, type:)
 		collection_type = Literal::Types::SetType.new(type)
 
-		Literal.check(actual: value, expected: collection_type) do |c|
+		Literal.check(value, collection_type) do |c|
 			c.fill_receiver(receiver: self, method: "#initialize")
 		end
 

data/lib/literal/transforms.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # A map of core types to transform Procs mapping to the new type.
-Literal::TRANSFORMS = {
+Literal::Transforms = {
 	Integer => {
 		abs: Integer,
 		ceil: Integer,
@@ -140,4 +140,4 @@ Literal::TRANSFORMS = {
 		to_s: String,
 		year: Integer,
 	},
-}.transform_values! { |it| it.transform_keys(&:to_proc) }.freeze
+}.transform_values! { |it| it.transform_keys(&:to_proc).freeze }.freeze

data/lib/literal/tuple.rb

@@ -19,7 +19,7 @@ class Literal::Tuple
 
 			i, len = 0, types.size
 			while i < len
-				return false unless Literal.subtype?(other_types[i], of: types[i])
+				return false unless Literal.subtype?(other_types[i], types[i])
 				i += 1
 			end
 
@@ -36,7 +36,7 @@ class Literal::Tuple
 
 				i, len = 0, types.size
 				while i < len
-					return false unless Literal.subtype?(other_types[i], of: types[i])
+					return false unless Literal.subtype?(other_types[i], types[i])
 					i += 1
 				end
 

data/lib/literal/types/class_type.rb

@@ -22,9 +22,9 @@ class Literal::Types::ClassType
 	def >=(other)
 		case other
 		when Literal::Types::ClassType
-			Literal.subtype?(other.type, of: @type)
+			Literal.subtype?(other.type, @type)
 		when Literal::Types::DescendantType
-			(Class === other.type) && Literal.subtype?(other.type, of: @type)
+			(Class === other.type) && Literal.subtype?(other.type, @type)
 		else
 			false
 		end

data/lib/literal/types/constraint_type.rb

@@ -46,24 +46,24 @@ class Literal::Types::ConstraintType
 		when Literal::Types::ConstraintType
 			other_object_constraints = other.object_constraints
 			return false unless @object_constraints.all? do |constraint|
-				other_object_constraints.any? { |c| Literal.subtype?(c, of: constraint) }
+				other_object_constraints.any? { |c| Literal.subtype?(c, 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)
+				Literal.subtype?(other_property_constraints[k], v)
 			end
 
 			true
 		when Literal::Types::IntersectionType
 			other_object_constraints = other.types
 			return false unless @object_constraints.all? do |constraint|
-				other_object_constraints.any? { |c| Literal.subtype?(c, of: constraint) }
+				other_object_constraints.any? { |c| Literal.subtype?(c, constraint) }
 			end
 
 			true
 		when Literal::Types::FrozenType
-			@object_constraints.all? { |constraint| Literal.subtype?(other.type, of: constraint) }
+			@object_constraints.all? { |constraint| Literal.subtype?(other.type, constraint) }
 		else
 			false
 		end

data/lib/literal/{deferred_type.rb → types/deferred_type.rb}

@@ -18,6 +18,6 @@ class Literal::Types::DeferredType
 	end
 
 	def >=(other)
-		Literal.subtype?(other, of: @block.call)
+		Literal.subtype?(other, @block.call)
 	end
 end

data/lib/literal/types/descendant_type.rb

@@ -21,7 +21,7 @@ class Literal::Types::DescendantType
 	def >=(other)
 		case other
 		when Literal::Types::DescendantType, Literal::Types::ClassType
-			Literal.subtype?(other.type, of: @type)
+			Literal.subtype?(other.type, @type)
 		else
 			false
 		end

data/lib/literal/types/enumerable_type.rb

@@ -22,7 +22,7 @@ class Literal::Types::EnumerableType
 	def >=(other)
 		case other
 		when Literal::Types::EnumerableType
-			Literal.subtype?(other.type, of: @type)
+			Literal.subtype?(other.type, @type)
 		else
 			false
 		end

data/lib/literal/types/frozen_type.rb

@@ -31,11 +31,11 @@ class Literal::Types::FrozenType
 			@type >= other.type
 		when Literal::Types::ConstraintType
 			type_match = false
-			frozen_match = Literal.subtype?(other.property_constraints[:frozen?], of: true)
+			frozen_match = Literal.subtype?(other.property_constraints[:frozen?], true)
 
 			other.object_constraints.each do |constraint|
 				frozen_match ||= ALWAYS_FROZEN.include?(constraint)
-				type_match ||= Literal.subtype?(constraint, of: @type)
+				type_match ||= Literal.subtype?(constraint, @type)
 				return true if frozen_match && type_match
 			end
 

data/lib/literal/types/hash_type.rb

@@ -30,9 +30,9 @@ class Literal::Types::HashType
 		case other
 		when Literal::Types::HashType
 			(
-				Literal.subtype?(other.key_type, of: @key_type)
+				Literal.subtype?(other.key_type, @key_type)
 			) && (
-				Literal.subtype?(other.value_type, of: @value_type)
+				Literal.subtype?(other.value_type, @value_type)
 			)
 		else
 			false

data/lib/literal/types/interface_type.rb

@@ -2,18 +2,14 @@
 
 # @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
 
+	# List of `===` method owners where the comparison will only match for objects with the same class
+	OwnClassTypeMethodOwners = Set[String, Integer, Kernel, Float, NilClass, TrueClass, FalseClass].freeze
+
 	def initialize(*methods)
 		raise Literal::ArgumentError.new("_Interface type must have at least one method.") if methods.size < 1
-		@methods = methods
+		@methods = methods.to_set.freeze
 		freeze
 	end
 
@@ -24,21 +20,30 @@ class Literal::Types::InterfaceType
 	end
 
 	def ===(value)
-		@methods.all? { |m| value.respond_to?(m) }
+		@methods.each do |method|
+			return false unless value.respond_to?(method)
+		end
+
+		true
 	end
 
 	def >=(other)
 		case other
 		when Literal::Types::InterfaceType
-			@methods.all? { |m| other.methods.include?(m) }
+			@methods.subset?(other.methods)
 		when Module
-			@methods.map { |m| METHOD_TYPE_MAPPINGS[m] }.all? { |types| types&.include?(other) }
+			public_methods = other.public_instance_methods.to_set
+			@methods.subset?(public_methods)
 		when Literal::Types::IntersectionType
-			other.types.any? { |type| Literal.subtype?(type, of: self) }
+			other.types.any? { |type| Literal.subtype?(type, self) }
 		when Literal::Types::ConstraintType
-			other.object_constraints.any? { |type| Literal.subtype?(type, of: self) }
+			other.object_constraints.any? { |type| Literal.subtype?(type, self) }
 		else
-			false
+			if OwnClassTypeMethodOwners.include?(other.method(:===).owner)
+				self === other
+			else
+				false
+			end
 		end
 	end
 

data/lib/literal/types/intersection_type.rb

@@ -36,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

@@ -45,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

@@ -26,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

@@ -22,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

@@ -28,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

@@ -38,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/union_type.rb

@@ -2,6 +2,7 @@
 
 class Literal::Types::UnionType
 	include Enumerable
+	include Literal::Type
 
 	def initialize(*queue)
 		raise Literal::ArgumentError.new("_Union type must have at least one type.") if queue.size < 1
@@ -32,7 +33,7 @@ class Literal::Types::UnionType
 	attr_reader :types, :primitives
 
 	def inspect
-		"_Union(#{@types.inspect})"
+		"_Union(#{to_a.map(&:inspect).join(', ')})"
 	end
 
 	def ===(value)
@@ -45,6 +46,8 @@ class Literal::Types::UnionType
 			return true if types[i] === value
 			i += 1
 		end
+
+		false
 	end
 
 	def each(&)
@@ -66,14 +69,6 @@ class Literal::Types::UnionType
 		self[key] or raise KeyError.new("Key not found: #{key.inspect}")
 	end
 
-	def record_literal_type_errors(ctx)
-		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
@@ -81,16 +76,16 @@ class Literal::Types::UnionType
 		case other
 		when Literal::Types::UnionType
 			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) }
+				primitives.any? { |p| Literal.subtype?(other_type, p) } || types.any? { |t| Literal.subtype?(other_type, t) }
 			end
 
 			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) }
+				primitives.any? { |p| Literal.subtype?(other_primitive, p) } || types.any? { |t| Literal.subtype?(other_primitive, t) }
 			end
 
 			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) }
+			types.any? { |t| Literal.subtype?(other, t) } || primitives.any? { |p| Literal.subtype?(other, p) }
 		end
 	end
 

data/lib/literal/types.rb

@@ -3,31 +3,6 @@
 module Literal::Types
 	extend self
 
-	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"
-
 	# Matches any value except `nil`. Use `_Any?` or `_Void` to match any value including `nil`.
 	# ```ruby
 	# _Any
@@ -339,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

data/lib/literal/value.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+class Literal::Value
+	def self.to_proc
+		-> (value) { new(value) }
+	end
+
+	def self.[](value)
+		new(value)
+	end
+
+	def self.from_pack(payload)
+		object = allocate
+		object.marshal_load(payload)
+		object
+	end
+
+	# Takes a list of method names and delegates them to the underlying value.
+	def self.delegate(*methods)
+		methods.each do |method_name|
+			class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+				# frozen_string_literal: true
+
+				def #{method_name}(...)
+					@value.#{method_name}(...)
+				end
+			RUBY
+		end
+	end
+
+	def initialize(value)
+		Literal.check(value, __type__)
+		@value = value
+		freeze
+	end
+
+	attr_reader :value
+
+	def inspect
+		"#{self.class.name}(#{value.inspect})"
+	end
+
+	def ===(other)
+		self.class === other && @value == other.value
+	end
+
+	alias_method :==, :===
+
+	def as_pack
+		marshal_dump
+	end
+
+	def marshal_load(payload)
+		_version, value, was_frozen = payload
+
+		@value = value
+		freeze if was_frozen
+	end
+
+	def marshal_dump
+		[1, @value, frozen?].freeze
+	end
+
+	freeze
+end

data/lib/literal/version.rb

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

data/lib/literal.rb

@@ -1,33 +1,58 @@
 # frozen_string_literal: true
 
+require "zeitwerk"
+require_relative "literal/version"
+
 module Literal
-	autoload :Array, "literal/array"
-	autoload :Data, "literal/data"
-	autoload :DataProperty, "literal/data_property"
-	autoload :DataStructure, "literal/data_structure"
-	autoload :Enum, "literal/enum"
-	autoload :Flags, "literal/flags"
-	autoload :Flags16, "literal/flags"
-	autoload :Flags32, "literal/flags"
-	autoload :Flags64, "literal/flags"
-	autoload :Flags8, "literal/flags"
-	autoload :Hash, "literal/hash"
-	autoload :Null, "literal/null"
-	autoload :Object, "literal/object"
-	autoload :Properties, "literal/properties"
-	autoload :Property, "literal/property"
-	autoload :Set, "literal/set"
-	autoload :Struct, "literal/struct"
-	autoload :Type, "literal/type"
-	autoload :Types, "literal/types"
-	autoload :Tuple, "literal/tuple"
-
-	# Errors
-	autoload :Error, "literal/errors/error"
-	autoload :TypeError, "literal/errors/type_error"
-	autoload :ArgumentError, "literal/errors/argument_error"
-
-	autoload :TRANSFORMS, "literal/transforms"
+	Loader = Zeitwerk::Loader.for_gem.tap do |loader|
+		loader.ignore("#{__dir__}/literal/rails")
+		loader.ignore("#{__dir__}/literal/railtie.rb")
+
+		loader.inflector.inflect(
+			"json_data_type" => "JSONDataType"
+		)
+
+		loader.collapse("#{__dir__}/literal/flags")
+		loader.collapse("#{__dir__}/literal/errors")
+
+		loader.setup
+	end
+
+	def self.Value(*args, **kwargs, &block)
+		value_class = Class.new(Literal::Value)
+
+		type = Literal::Types._Constraint(*args, **kwargs)
+		value_class.define_method(:__type__) { type }
+
+		if subtype?(type, Integer)
+			value_class.alias_method :to_i, :value
+		elsif subtype?(type, String)
+			value_class.alias_method :to_s, :value
+			value_class.alias_method :to_str, :value
+		elsif subtype?(type, Array)
+			value_class.alias_method :to_a, :value
+			value_class.alias_method :to_ary, :value
+		elsif subtype?(type, Hash)
+			value_class.alias_method :to_h, :value
+		elsif subtype?(type, Float)
+			value_class.alias_method :to_f, :value
+		elsif subtype?(type, Set)
+			value_class.alias_method :to_set, :value
+		end
+
+		value_class.class_eval(&block) if block
+		value_class.freeze
+	end
+
+	def self.Delegator(*args, **kwargs, &block)
+		delegator_class = Class.new(Literal::Delegator)
+
+		type = Literal::Types._Constraint(*args, **kwargs)
+		delegator_class.define_method(:__type__) { type }
+
+		delegator_class.class_eval(&block) if block
+		delegator_class.freeze
+	end
 
 	def self.Enum(type)
 		Class.new(Literal::Enum) do
@@ -51,19 +76,22 @@ module Literal
 		Literal::Tuple::Generic.new(*types)
 	end
 
-	def self.check(actual:, expected:)
-		if expected === actual
+	def self.Brand(...)
+		Literal::Brand.new(...)
+	end
+
+	def self.check(value, type)
+		if type === value
 			true
 		else
-			context = Literal::TypeError::Context.new(expected:, actual:)
-			expected.record_literal_type_errors(context) if expected.respond_to?(:record_literal_type_errors)
+			context = Literal::TypeError::Context.new(expected: type, actual: value)
+			type.record_literal_type_errors(context) if type.respond_to?(:record_literal_type_errors)
 			yield context if block_given?
 			raise Literal::TypeError.new(context:)
 		end
 	end
 
-	def self.subtype?(type, of:)
-		supertype = of
+	def self.subtype?(type, supertype)
 		subtype = type
 
 		subtype = subtype.block.call if Types::DeferredType === subtype
@@ -98,4 +126,4 @@ module Literal
 	end
 end
 
-require_relative "literal/rails" if defined?(Rails)
+require_relative "literal/railtie" if defined?(Rails)

metadata

@@ -1,14 +1,28 @@
 --- !ruby/object:Gem::Specification
 name: literal
 version: !ruby/object:Gem::Version
-  version: 1.6.0
+  version: 1.7.1
 platform: ruby
 authors:
 - Joel Drapper
 bindir: bin
 cert_chain: []
-date: 2025-03-10 00:00:00.000000000 Z
-dependencies: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Enums, properties, generics, structured objects and runtime type checking.
 email:
 - joel@drapper.me
@@ -22,13 +36,17 @@ files:
 - lib/literal/array.rb
 - lib/literal/data.rb
 - lib/literal/data_structure.rb
-- lib/literal/deferred_type.rb
+- lib/literal/delegator.rb
 - lib/literal/enum.rb
 - lib/literal/errors/argument_error.rb
 - lib/literal/errors/error.rb
 - lib/literal/errors/type_error.rb
 - lib/literal/failure.rb
 - lib/literal/flags.rb
+- lib/literal/flags/flags_16.rb
+- lib/literal/flags/flags_32.rb
+- lib/literal/flags/flags_64.rb
+- lib/literal/flags/flags_8.rb
 - lib/literal/hash.rb
 - lib/literal/null.rb
 - lib/literal/object.rb
@@ -36,11 +54,11 @@ files:
 - lib/literal/properties/data_schema.rb
 - lib/literal/properties/schema.rb
 - lib/literal/property.rb
-- lib/literal/rails.rb
+- lib/literal/rails/active_record_relation_patch.rb
 - lib/literal/rails/enum_serializer.rb
 - lib/literal/rails/enum_type.rb
 - lib/literal/rails/flags_type.rb
-- lib/literal/rails/patches/active_record.rb
+- lib/literal/rails/relation_type.rb
 - lib/literal/railtie.rb
 - lib/literal/result.rb
 - lib/literal/set.rb
@@ -55,6 +73,7 @@ files:
 - lib/literal/types/boolean_type.rb
 - lib/literal/types/class_type.rb
 - lib/literal/types/constraint_type.rb
+- lib/literal/types/deferred_type.rb
 - lib/literal/types/descendant_type.rb
 - lib/literal/types/enumerable_type.rb
 - lib/literal/types/falsy_type.rb
@@ -67,12 +86,14 @@ files:
 - lib/literal/types/never_type.rb
 - lib/literal/types/nilable_type.rb
 - lib/literal/types/not_type.rb
+- lib/literal/types/predicate_type.rb
 - lib/literal/types/range_type.rb
 - lib/literal/types/set_type.rb
 - lib/literal/types/truthy_type.rb
 - lib/literal/types/tuple_type.rb
 - lib/literal/types/union_type.rb
 - lib/literal/types/void_type.rb
+- lib/literal/value.rb
 - lib/literal/version.rb
 homepage: https://literal.fun
 licenses:
@@ -97,7 +118,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Enums, properties, generics, structured objects and runtime type checking.
 test_files: []

data/lib/literal/rails/patches/active_record.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveRecord
-	class RelationType
-		def initialize(model_class)
-			unless Class === model_class && model_class < ActiveRecord::Base
-				raise Literal::TypeError.new(
-					context: Literal::TypeError::Context.new(
-						expected: ActiveRecord::Base, actual: model_class
-					)
-				)
-			end
-
-			@model_class = model_class
-		end
-
-		def inspect = "ActiveRecord::Relation(#{@model_class.name})"
-
-		def ===(value)
-			case value
-			when ActiveRecord::Relation, ActiveRecord::Associations::CollectionProxy, ActiveRecord::AssociationRelation
-				@model_class == value.model || value.model < @model_class
-			else
-				false
-			end
-		end
-	end
-
-	def self.Relation(model)
-		RelationType.new(model)
-	end
-end

data/lib/literal/rails.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "railtie"
-require_relative "rails/patches/active_record"
-
-module Literal::Rails
-	autoload :EnumType, "literal/rails/enum_type"
-	autoload :FlagsType, "literal/rails/flags_type"
-	autoload :EnumSerializer, "literal/rails/enum_serializer"
-end