literal 1.0.0 → 1.2.0

data/lib/literal/types/nilable_type.rb

@@ -11,4 +11,10 @@ class Literal::Types::NilableType
 	def ===(value)
 		nil === value || @type === value
 	end
+
+	def record_literal_type_errors(ctx)
+		@type.record_literal_type_errors(ctx) if @type.respond_to?(:record_literal_type_errors)
+	end
+
+	freeze
 end

data/lib/literal/types/set_type.rb

@@ -17,4 +17,14 @@ class Literal::Types::SetType
 
 		true
 	end
+
+	def record_literal_type_errors(context)
+		return unless Set === context.actual
+
+		context.actual.each do |actual|
+			unless @type === actual
+				context.add_child(label: "[]", expected: @type, actual:)
+			end
+		end
+	end
 end

data/lib/literal/types/tuple_type.rb

@@ -23,4 +23,20 @@ class Literal::Types::TupleType
 
 		true
 	end
+
+	def record_literal_type_errors(context)
+		return unless Array === context.actual
+
+		len = [@types.size, context.actual.size].max
+		i = 0
+		while i < len
+			actual = context.actual[i]
+			if !(expected = @types[i])
+				context.add_child(label: "[#{i}]", expected: Literal::Types::NeverType, actual:)
+			elsif !(expected === actual)
+				context.add_child(label: "[#{i}]", expected:, actual:)
+			end
+			i += 1
+		end
+	end
 end

data/lib/literal/types/union_type.rb

@@ -39,6 +39,13 @@ class Literal::Types::UnionType
 		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? }
+	end
+
 	protected
 
 	attr_reader :types

data/lib/literal/types.rb

@@ -32,15 +32,15 @@ module Literal::Types
 	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)
+	NilableBooleanType = NilableType.new(BooleanType::Instance).freeze
+	NilableCallableType = NilableType.new(CallableType::Instance).freeze
+	NilableJSONDataType = NilableType.new(JSONDataType).freeze
+	NilableLambdaType = NilableType.new(LambdaType).freeze
+	NilableProcableType = NilableType.new(ProcableType).freeze
 
-	# Matches any value except `nil`. Use `_Any?` or `_Unit` to match any value including `nil`.
+	# Matches any value except `nil`. Use `_Any?` or `_Void` to match any value including `nil`.
 	def _Any
-		AnyType
+		AnyType::Instance
 	end
 
 	def _Any?
@@ -61,7 +61,7 @@ module Literal::Types
 
 	# Matches if the value is `true` or `false`.
 	def _Boolean
-		BooleanType
+		BooleanType::Instance
 	end
 
 	# Nilable version of `_Boolean`
@@ -71,7 +71,7 @@ module Literal::Types
 
 	# Matches if the value responds to `#call`.
 	def _Callable
-		CallableType
+		CallableType::Instance
 	end
 
 	# Nilabl version of `_Callable`
@@ -131,7 +131,7 @@ module Literal::Types
 
 	# Matches *"falsy"* values (`nil` and `false`).
 	def _Falsy
-		FalsyType
+		FalsyType::Instance
 	end
 
 	# Matches if the value is a `Float` and matches the given constraint.
@@ -166,9 +166,9 @@ module Literal::Types
 	end
 
 	# Nilable version of `_Hash`
-	def _Hash?
+	def _Hash?(...)
 		NilableType.new(
-			HashType.new,
+			HashType.new(...),
 		)
 	end
 
@@ -184,7 +184,7 @@ module Literal::Types
 	# Nilable version of `_Integer`
 	def _Integer?(...)
 		NilableType.new(
-			IntegerType(...),
+			IntegerType.new(...),
 		)
 	end
 

data/lib/literal/version.rb

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

data/lib/literal.rb

@@ -3,15 +3,24 @@
 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"
 
 	# Errors
@@ -19,12 +28,89 @@ module Literal
 	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
+
 	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
@@ -35,6 +121,17 @@ module Literal
 			raise Literal::TypeError.new(context:)
 		end
 	end
+
+	def self.subtype?(type, of:)
+		(of == type) || case of
+		when Literal::Type, Module
+			of >= type
+		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.0.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Joel Drapper
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-11-01 00:00:00.000000000 Z
+date: 2024-11-22 00:00:00.000000000 Z
 dependencies: []
 description: A literal Ruby gem.
 email:
@@ -20,6 +20,7 @@ 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
@@ -27,6 +28,8 @@ files:
 - 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
@@ -36,9 +39,12 @@ 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/type.rb
 - lib/literal/types.rb
 - lib/literal/types/any_type.rb
 - lib/literal/types/array_type.rb