literal 1.2.0 → 1.4.0

data/lib/literal/types.rb

@@ -4,36 +4,34 @@ module Literal::Types
 	autoload :AnyType, "literal/types/any_type"
 	autoload :ArrayType, "literal/types/array_type"
 	autoload :BooleanType, "literal/types/boolean_type"
-	autoload :CallableType, "literal/types/callable_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 :FloatType, "literal/types/float_type"
 	autoload :FrozenType, "literal/types/frozen_type"
 	autoload :HashType, "literal/types/hash_type"
-	autoload :IntegerType, "literal/types/integer_type"
 	autoload :InterfaceType, "literal/types/interface_type"
 	autoload :IntersectionType, "literal/types/intersection_type"
 	autoload :JSONDataType, "literal/types/json_data_type"
-	autoload :LambdaType, "literal/types/lambda_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 :ProcableType, "literal/types/procable_type"
 	autoload :RangeType, "literal/types/range_type"
 	autoload :SetType, "literal/types/set_type"
-	autoload :StringType, "literal/types/string_type"
-	autoload :SymbolType, "literal/types/symbol_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::Instance).freeze
+	NilableCallableType = NilableType.new(CallableType).freeze
 	NilableJSONDataType = NilableType.new(JSONDataType).freeze
 	NilableLambdaType = NilableType.new(LambdaType).freeze
 	NilableProcableType = NilableType.new(ProcableType).freeze
@@ -44,7 +42,7 @@ module Literal::Types
 	end
 
 	def _Any?
-		VoidType
+		VoidType::Instance
 	end
 
 	# Matches if the value is an `Array` and all the elements match the given type.
@@ -55,7 +53,7 @@ module Literal::Types
 	# Nilable version of `_Array`
 	def _Array?(...)
 		NilableType.new(
-			ArrayType.new(...),
+			ArrayType.new(...)
 		)
 	end
 
@@ -71,7 +69,7 @@ module Literal::Types
 
 	# Matches if the value responds to `#call`.
 	def _Callable
-		CallableType::Instance
+		CallableType
 	end
 
 	# Nilabl version of `_Callable`
@@ -87,7 +85,7 @@ module Literal::Types
 	# Nilable version of `_Class`
 	def _Class?(...)
 		NilableType.new(
-			ClassType.new(...),
+			ClassType.new(...)
 		)
 	end
 
@@ -101,10 +99,14 @@ module Literal::Types
 	# Nilable version of `_Constraint`
 	def _Constraint?(...)
 		NilableType.new(
-			ConstraintType.new(...),
+			ConstraintType.new(...)
 		)
 	end
 
+	def _Deferred(...)
+		DeferredType.new(...)
+	end
+
 	# Matches if the value is a descendant of the given class.
 	def _Descendant(...)
 		DescendantType.new(...)
@@ -113,7 +115,7 @@ module Literal::Types
 	# Nilable version of `_Descendant`
 	def _Descendant?(...)
 		NilableType.new(
-			DescendantType.new(...),
+			DescendantType.new(...)
 		)
 	end
 
@@ -125,7 +127,7 @@ module Literal::Types
 	# Nilable version of `_Enumerable`
 	def _Enumerable?(...)
 		NilableType.new(
-			EnumerableType.new(...),
+			EnumerableType.new(...)
 		)
 	end
 
@@ -134,17 +136,17 @@ module Literal::Types
 		FalsyType::Instance
 	end
 
-	# Matches if the value is a `Float` and matches the given constraint.
+	# 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`.
 	def _Float(...)
-		FloatType.new(...)
+		_Constraint(Float, ...)
 	end
 
 	# Nilable version of `_Float`
 	def _Float?(...)
-		NilableType.new(
-			FloatType.new(...),
+		_Nilable(
+			_Float(...)
 		)
 	end
 
@@ -156,7 +158,7 @@ module Literal::Types
 	# Nilable version of `_Frozen`
 	def _Frozen?(...)
 		NilableType.new(
-			FrozenType.new(...),
+			FrozenType.new(...)
 		)
 	end
 
@@ -168,7 +170,7 @@ module Literal::Types
 	# Nilable version of `_Hash`
 	def _Hash?(...)
 		NilableType.new(
-			HashType.new(...),
+			HashType.new(...)
 		)
 	end
 
@@ -178,13 +180,13 @@ module Literal::Types
 	# @example
 	# 	attribute :age, _Integer(18..127)
 	def _Integer(...)
-		IntegerType.new(...)
+		_Constraint(Integer, ...)
 	end
 
 	# Nilable version of `_Integer`
 	def _Integer?(...)
-		NilableType.new(
-			IntegerType.new(...),
+		_Nilable(
+			_Integer(...)
 		)
 	end
 
@@ -196,7 +198,7 @@ module Literal::Types
 	# Nilable version of `_Interface`
 	def _Interface?(...)
 		NilableType.new(
-			InterfaceType.new(...),
+			InterfaceType.new(...)
 		)
 	end
 
@@ -208,13 +210,13 @@ module Literal::Types
 	# Nilable version of `_Intersection`
 	def _Intersection?(...)
 		NilableType.new(
-			IntersectionType.new(...),
+			IntersectionType.new(...)
 		)
 	end
 
 	# Ensures the value is valid JSON data (i.e. it came from JSON.parse).
 	def _JSONData
-		JSONDataType
+		JSONDataType::Instance
 	end
 
 	# Nilable version of `_JSONData`
@@ -239,13 +241,13 @@ module Literal::Types
 	# Nilable version of `_Map`
 	def _Map?(...)
 		NilableType.new(
-			MapType.new(...),
+			MapType.new(...)
 		)
 	end
 
 	# Never matches any value.
 	def _Never
-		NeverType
+		NeverType::Instance
 	end
 
 	# Matches if the value is either `nil` or the given type.
@@ -254,8 +256,13 @@ module Literal::Types
 	end
 
 	# Matches if the given type is *not* matched.
-	def _Not(...)
-		NotType.new(...)
+	def _Not(type)
+		case type
+		when NotType
+			type.type
+		else
+			NotType.new(type)
+		end
 	end
 
 	# Matches if the value is a `Proc` or responds to `#to_proc`.
@@ -276,7 +283,7 @@ module Literal::Types
 	# Nilable version of `_Range`
 	def _Range?(...)
 		NilableType.new(
-			RangeType.new(...),
+			RangeType.new(...)
 		)
 	end
 
@@ -288,38 +295,38 @@ module Literal::Types
 	# Nilable version of `_Set`
 	def _Set?(...)
 		NilableType.new(
-			SetType.new(...),
+			SetType.new(...)
 		)
 	end
 
 	# Matches if the value is a `String` and matches the given constraints.
 	# If you don't need any constraints, use `String` instead of `_String`.
 	def _String(...)
-		StringType.new(...)
+		_Constraint(String, ...)
 	end
 
 	# Nilable version of `_String`
 	def _String?(...)
-		NilableType.new(
-			StringType.new(...),
+		_Nilable(
+			_String(...)
 		)
 	end
 
-	# Matches if the value is a `Symbol` and matches the given constraint.
+	# Matches if the value is a `Symbol` and matches the given constraints.
 	def _Symbol(...)
-		SymbolType.new(...)
+		_Constraint(Symbol, ...)
 	end
 
 	# Nilable version of `_Symbol`
 	def _Symbol?(...)
-		NilableType.new(
-			SymbolType.new(...),
+		_Nilable(
+			_Symbol(...)
 		)
 	end
 
 	# Matches *"truthy"* values (anything except `nil` and `false`).
 	def _Truthy
-		TruthyType
+		TruthyType::Instance
 	end
 
 	# Matches if the value is an `Array` and each element matches the given types in order.
@@ -330,7 +337,7 @@ module Literal::Types
 	# Nilable version of `_Typle`
 	def _Tuple?(...)
 		NilableType.new(
-			TupleType.new(...),
+			TupleType.new(...)
 		)
 	end
 
@@ -342,11 +349,11 @@ module Literal::Types
 	# Nilable version of `_Union`
 	def _Union?(...)
 		NilableType.new(
-			UnionType.new(...),
+			UnionType.new(...)
 		)
 	end
 
 	def _Void
-		VoidType
+		VoidType::Instance
 	end
 end

data/lib/literal/version.rb

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

data/lib/literal.rb

@@ -22,76 +22,14 @@ module Literal
 	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"
 
-	TRANSFORMS = {
-		Integer => {
-			abs: Integer,
-			ceil: Integer,
-			chr: String,
-			denominator: Integer,
-			even?: Types::BooleanType::Instance,
-			floor: Integer,
-			hash: Integer,
-			inspect: String,
-			integer?: true,
-			magnitude: Integer,
-			negative?: Types::BooleanType::Instance,
-			next: Integer,
-			nonzero?: Types::BooleanType::Instance,
-			numerator: Integer,
-			odd?: Types::BooleanType::Instance,
-			ord: Integer,
-			positive?: Types::BooleanType::Instance,
-			pred: Integer,
-			round: Integer,
-			size: Integer,
-			succ: Integer,
-			to_f: Float,
-			to_i: Integer,
-			to_int: Integer,
-			to_r: Rational,
-			to_s: String,
-			truncate: Integer,
-			zero?: Types::BooleanType::Instance,
-		},
-		String => {
-			ascii_only?: Types::BooleanType::Instance,
-			bytesize: Integer,
-			capitalize: String,
-			chomp: String,
-			chop: String,
-			downcase: String,
-			dump: String,
-			empty?: Types::BooleanType::Instance,
-			hash: Integer,
-			inspect: String,
-			length: Integer,
-			lstrip: String,
-			ord: Integer,
-			reverse: String,
-			rstrip: String,
-			scrub: String,
-			size: Integer,
-			strip: String,
-			swapcase: String,
-			to_str: String,
-			upcase: String,
-			valid_encoding?: Types::BooleanType::Instance,
-		},
-		Array => {
-			size: Integer,
-			length: Integer,
-			empty?: Types::BooleanType::Instance,
-			sort: Array,
-			to_a: Array,
-			to_ary: Array,
-		},
-	}.transform_values! { |it| it.transform_keys(&:to_proc) }.freeze
+	autoload :TRANSFORMS, "literal/transforms"
 
 	def self.Enum(type)
 		Class.new(Literal::Enum) do
@@ -111,6 +49,10 @@ module Literal
 		Literal::Hash::Generic.new(key_type, value_type)
 	end
 
+	def self.Tuple(*types)
+		Literal::Tuple::Generic.new(*types)
+	end
+
 	def self.check(actual:, expected:)
 		if expected === actual
 			true
@@ -123,9 +65,13 @@ module Literal
 	end
 
 	def self.subtype?(type, of:)
+		type = type.block.call if Types::DeferredType === type
+
 		(of == type) || case of
-		when Literal::Type, Module
+		when Literal::Type
 			of >= type
+		when Module
+			(Module === type) ? of >= type : false
 		when Range
 			of.cover?(type)
 		else

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: literal
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.4.0
 platform: ruby
 authors:
 - Joel Drapper
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-11-22 00:00:00.000000000 Z
+date: 2024-12-10 00:00:00.000000000 Z
 dependencies: []
-description: A literal Ruby gem.
+description: Enums, properties, generics, structured objects and runtime type checking.
 email:
 - joel@drapper.me
 executables: []
@@ -22,8 +22,8 @@ files:
 - lib/literal.rb
 - lib/literal/array.rb
 - lib/literal/data.rb
-- lib/literal/data_property.rb
 - lib/literal/data_structure.rb
+- lib/literal/deferred_type.rb
 - lib/literal/enum.rb
 - lib/literal/errors/argument_error.rb
 - lib/literal/errors/error.rb
@@ -44,34 +44,29 @@ files:
 - lib/literal/railtie.rb
 - lib/literal/set.rb
 - lib/literal/struct.rb
+- lib/literal/transforms.rb
+- lib/literal/tuple.rb
 - lib/literal/type.rb
 - lib/literal/types.rb
 - lib/literal/types/any_type.rb
 - lib/literal/types/array_type.rb
 - lib/literal/types/boolean_type.rb
-- lib/literal/types/callable_type.rb
 - lib/literal/types/class_type.rb
 - lib/literal/types/constraint_type.rb
 - lib/literal/types/descendant_type.rb
 - lib/literal/types/enumerable_type.rb
 - lib/literal/types/falsy_type.rb
-- lib/literal/types/float_type.rb
 - lib/literal/types/frozen_type.rb
 - lib/literal/types/hash_type.rb
-- lib/literal/types/integer_type.rb
 - lib/literal/types/interface_type.rb
 - lib/literal/types/intersection_type.rb
 - lib/literal/types/json_data_type.rb
-- lib/literal/types/lambda_type.rb
 - lib/literal/types/map_type.rb
 - lib/literal/types/never_type.rb
 - lib/literal/types/nilable_type.rb
 - lib/literal/types/not_type.rb
-- lib/literal/types/procable_type.rb
 - lib/literal/types/range_type.rb
 - lib/literal/types/set_type.rb
-- lib/literal/types/string_type.rb
-- lib/literal/types/symbol_type.rb
 - lib/literal/types/truthy_type.rb
 - lib/literal/types/tuple_type.rb
 - lib/literal/types/union_type.rb
@@ -83,7 +78,7 @@ licenses:
 metadata:
   homepage_uri: https://literal.fun
   source_code_uri: https://github.com/joeldrapper/literal
-  changelog_uri: https://github.com/joeldrapper/literal/blob/main/CHANGELOG.md
+  changelog_uri: https://github.com/joeldrapper/literal/releases
   funding_uri: https://github.com/sponsors/joeldrapper
   rubygems_mfa_required: 'true'
 post_install_message:

data/lib/literal/data_property.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-class Literal::DataProperty < Literal::Property
-	def generate_initializer_assign_value(buffer = +"")
-		buffer <<
-			"@" <<
-			@name.name <<
-			" = " <<
-			escaped_name <<
-			".frozen? ? " <<
-			escaped_name <<
-			" : " <<
-			escaped_name <<
-			".dup.freeze\n"
-	end
-end

data/lib/literal/types/callable_type.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-# @api private
-class Literal::Types::CallableType
-	include Literal::Type
-
-	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/float_type.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-# @api private
-class Literal::Types::FloatType < Literal::Types::ConstraintType
-	def inspect = "_Float(#{inspect_constraints})"
-
-	def ===(value)
-		Float === value && super
-	end
-end

data/lib/literal/types/integer_type.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-# @api private
-class Literal::Types::IntegerType < Literal::Types::ConstraintType
-	def inspect = "_Integer(#{inspect_constraints})"
-
-	def ===(value)
-		Integer === value && super
-	end
-end

data/lib/literal/types/lambda_type.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-# @api private
-module Literal::Types::LambdaType
-	def self.inspect = "_Lambda"
-
-	def self.===(value)
-		Proc === value && value.lambda?
-	end
-
-	freeze
-end

data/lib/literal/types/procable_type.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-# @api private
-module Literal::Types::ProcableType
-	def self.inspect = "_Procable"
-
-	def self.===(value)
-		Proc === value || value.respond_to?(:to_proc)
-	end
-
-	freeze
-end

data/lib/literal/types/string_type.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-# @api private
-class Literal::Types::StringType < Literal::Types::ConstraintType
-	def inspect = "_String(#{inspect_constraints})"
-
-	def ===(value)
-		String === value && super
-	end
-end

data/lib/literal/types/symbol_type.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-# @api private
-class Literal::Types::SymbolType < Literal::Types::ConstraintType
-	def inspect = "_Symbol(#{inspect_constraints})"
-
-	def ===(value)
-		Symbol === value && super
-	end
-end