literal 1.1.0 → 1.3.0

data/lib/literal/types.rb

@@ -4,47 +4,45 @@ 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"
 
-	NilableBooleanType = NilableType.new(BooleanType)
-	NilableCallableType = NilableType.new(CallableType)
-	NilableJSONDataType = NilableType.new(JSONDataType)
-	NilableLambdaType = NilableType.new(LambdaType)
-	NilableProcableType = NilableType.new(ProcableType)
+	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`.
 	def _Any
-		AnyType
+		AnyType::Instance
 	end
 
 	def _Any?
-		VoidType
+		VoidType::Instance
 	end
 
 	# Matches if the value is an `Array` and all the elements match the given type.
@@ -55,13 +53,13 @@ module Literal::Types
 	# Nilable version of `_Array`
 	def _Array?(...)
 		NilableType.new(
-			ArrayType.new(...),
+			ArrayType.new(...)
 		)
 	end
 
 	# Matches if the value is `true` or `false`.
 	def _Boolean
-		BooleanType
+		BooleanType::Instance
 	end
 
 	# Nilable version of `_Boolean`
@@ -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,26 +127,26 @@ module Literal::Types
 	# Nilable version of `_Enumerable`
 	def _Enumerable?(...)
 		NilableType.new(
-			EnumerableType.new(...),
+			EnumerableType.new(...)
 		)
 	end
 
 	# Matches *"falsy"* values (`nil` and `false`).
 	def _Falsy
-		FalsyType
+		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
 
@@ -166,9 +168,9 @@ module Literal::Types
 	end
 
 	# Nilable version of `_Hash`
-	def _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(...),
+		_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.1.0"
+	VERSION = "1.3.0"
 end

data/lib/literal.rb

@@ -3,33 +3,51 @@
 module Literal
 	TYPE_CHECKS_DISABLED = ENV["LITERAL_TYPE_CHECKS"] == "false"
 
+	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 :Flags, "literal/flags"
-	autoload :Flags8, "literal/flags"
-	autoload :Flags16, "literal/flags"
-	autoload :Flags32, "literal/flags"
-	autoload :Flags64, "literal/flags"
 
 	# Errors
 	autoload :Error, "literal/errors/error"
 	autoload :TypeError, "literal/errors/type_error"
 	autoload :ArgumentError, "literal/errors/argument_error"
 
+	autoload :TRANSFORMS, "literal/transforms"
+
 	def self.Enum(type)
 		Class.new(Literal::Enum) do
 			prop :value, type, :positional
 		end
 	end
 
+	def self.Array(type)
+		Literal::Array::Generic.new(type)
+	end
+
+	def self.Set(type)
+		Literal::Set::Generic.new(type)
+	end
+
+	def self.Hash(key_type, value_type)
+		Literal::Hash::Generic.new(key_type, value_type)
+	end
+
 	def self.check(actual:, expected:)
 		if expected === actual
 			true
@@ -40,6 +58,21 @@ module Literal
 			raise Literal::TypeError.new(context:)
 		end
 	end
+
+	def self.subtype?(type, of:)
+		type = type.block.call if Types::DeferredType === type
+
+		(of == type) || case of
+		when Literal::Type
+			of >= type
+		when Module
+			(Module === type) ? of >= type : false
+		when Range
+			of.cover?(type)
+		else
+			false
+		end
+	end
 end
 
 require_relative "literal/rails" if defined?(Rails)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: literal
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Joel Drapper
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-11-07 00:00:00.000000000 Z
+date: 2024-11-29 00:00:00.000000000 Z
 dependencies: []
 description: A literal Ruby gem.
 email:
@@ -20,14 +20,17 @@ files:
 - LICENSE.txt
 - README.md
 - 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
 - lib/literal/errors/type_error.rb
 - lib/literal/flags.rb
+- lib/literal/hash.rb
 - lib/literal/null.rb
 - lib/literal/object.rb
 - lib/literal/properties.rb
@@ -37,36 +40,33 @@ files:
 - lib/literal/rails.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/railtie.rb
+- lib/literal/set.rb
 - lib/literal/struct.rb
+- lib/literal/transforms.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

data/lib/literal/types/callable_type.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-# @api private
-module Literal::Types::CallableType
-	def self.inspect = "_Callable"
-
-	def self.===(value)
-		value.respond_to?(:call)
-	end
-
-	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