types 0.4.4 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3785361ab678825d8075ef606e44f2e7515df0037e2c18e13f930709e64a3393
-  data.tar.gz: c2ac107637b28611d61a29fca64b7a17b7828b4095501cb9bbd2b638aa57e0ca
+  metadata.gz: 8fd5cdd213682630df6b1438406870ae7856635ba58d543be3327b0d8d2efe68
+  data.tar.gz: f247423d2b76997938605d870fd3b4262bccc71bed5ce53d3bc96e5a97174984
 SHA512:
-  metadata.gz: 641614eeb0a0a270a7f29523f7ca733c2fd7bf6a2df2bae494b61d6e9449785b51d29a6fac0c40496682c19abc33865e94c775b9e08707303f5641c7280ef43d
-  data.tar.gz: faf5130f17a8ec44295157497d20e24df6aa6db5cf7ca193550d53ff0314074e706d2908a79f377e3895ec740a9772abfd7191a151776d4b2278808519c30bc0
+  metadata.gz: 7952d06a5940b10e19ada3bd90654628b02417d66e0c7edacb6b4c6a960231b895c48f51f7cbaf15df44aa254f543371be84ca097d05f609577083f571d3ef98
+  data.tar.gz: 9e2b0c00186b9d627fccf9215efc4d384cd429a6950c0600fc8dc83971ebad1aeaef19451d6107dd3455d8ad34b25a3afb98f587c5d671ab257933b453e7119b

data/context/usage.md

@@ -32,11 +32,11 @@ For more complex types, you can create composite types:
 
 ```ruby
 # Array with specific item type
-array_type = Types::Array(Types::Integer)
+array_type = Types::Array.new(Types::Integer)
 array_type.parse(["1", "2", "3"])  # => [1, 2, 3]
 
 # Hash with key and value types
-hash_type = Types::Hash(Types::String, Types::Integer)
+hash_type = Types::Hash.new(Types::String, Types::Integer)
 hash_type.parse("a:1,b:2")        # => {"a" => 1, "b" => 2}
 
 # Tuple types
@@ -66,8 +66,8 @@ Types.parse("Integer")                   # => Types::Integer
 Types.parse("Float")                     # => Types::Float
 
 # Composite types
-Types.parse("Array(String)")             # => Types::Array(Types::String)
-Types.parse("Hash(String, Integer)")     # => Types::Hash(Types::String, Types::Integer)
+Types.parse("Array(String)")             # => Types::Array.new(Types::String)
+Types.parse("Hash(String, Integer)")     # => Types::Hash.new(Types::String, Types::Integer)
 Types.parse("Tuple(String, Integer)")    # => Types::Tuple(Types::String, Types::Integer)
 
 # Union types
@@ -127,7 +127,7 @@ Types::Boolean.parse("0")         # => false
 Arrays can parse both string representations and actual arrays:
 
 ```ruby
-array_type = Types::Array(Types::Integer)
+array_type = Types::Array.new(Types::Integer)
 
 # Parse string representation
 array_type.parse("1,2,3")         # => [1, 2, 3]
@@ -142,7 +142,7 @@ array_type.parse(["1", "2", "3"]) # => [1, 2, 3]
 Hashes can parse string representations:
 
 ```ruby
-hash_type = Types::Hash(Types::String, Types::Integer)
+hash_type = Types::Hash.new(Types::String, Types::Integer)
 
 # Parse string representation
 hash_type.parse("a:1,b:2,c:3")    # => {"a" => 1, "b" => 2, "c" => 3}
@@ -154,7 +154,7 @@ Parsing methods will raise `ArgumentError` for invalid inputs:
 
 ```ruby
 Types::Integer.parse("not_a_number")  # => ArgumentError
-Types::Array(Types::Integer).parse("invalid")  # => ArgumentError
+Types::Array.new(Types::Integer).parse("invalid")  # => ArgumentError
 ```
 
 ### Practical Example: Command Line Arguments
@@ -167,7 +167,7 @@ def parse_arguments(arguments)
     port: Types::Integer.parse(arguments[:port] || "8080"),
     host: Types::String.parse(arguments[:host] || "localhost"),
     debug: Types::Boolean.parse(arguments[:debug] || "false"),
-    tags: Types::Array(Types::String).parse(arguments[:tags] || "")
+    tags: Types::Array.new(Types::String).parse(arguments[:tags] || "")
   }
   
   config

data/lib/types/any.rb

@@ -3,6 +3,8 @@
 # Released under the MIT License.
 # Copyright, 2022-2025, by Samuel Williams.
 
+require_relative "parser"
+
 module Types
 	# Represents a union of multiple types. The first type to match the input is used. If no types are specified, this matches any type or value.
 	#
@@ -79,7 +81,7 @@ module Types
 	# Constructs an {Any} type from the given types.
 	# @parameter types [Array(Type)] The types to include in the union.
 	# @returns [Any] a new {Any} type.
-	def self.Any(*types)
+	def PARSER.Any(*types)
 		Any.new(types)
 	end
 end

data/lib/types/array.rb

@@ -4,12 +4,13 @@
 # Copyright, 2022-2025, by Samuel Williams.
 
 require_relative "generic"
+require_relative "parser"
 
 module Types
 	# Represents an array type with a specific item type.
 	#
 	# ```ruby
-	# type = Types::Array(Types::Integer)
+	# type = Types::Array.new(Types::Integer)
 	# type.parse(["1", "2"]) # => [1, 2]
 	# ```
 	class Array
@@ -77,7 +78,7 @@ module Types
 	# Constructs an {Array} type from the given item type.
 	# @parameter item_type [Type] The type of the array elements.
 	# @returns [Array] a new {Array} type.
-	def self.Array(item_type = Any)
+	def PARSER.Array(item_type = Any)
 		Array.new(item_type)
 	end
 end

data/lib/types/block.rb

@@ -4,6 +4,7 @@
 # Copyright, 2022-2025, by Samuel Williams.
 
 require_relative "method"
+require_relative "parser"
 
 module Types
 	# Represents a block (Proc) type with argument and return types.
@@ -55,7 +56,7 @@ module Types
 	# @parameter argument_types [Array(Type)] The types of the block arguments.
 	# @parameter returns [Type | Nil] The return type of the block.
 	# @returns [Block] a new {Block} type.
-	def self.Block(*argument_types, returns: nil)
+	def PARSER.Block(*argument_types, returns: nil)
 		Block.new(argument_types, returns)
 	end
 end

data/lib/types/class.rb

@@ -4,6 +4,7 @@
 # Copyright, 2022-2025, by Samuel Williams.
 
 require_relative "generic"
+require_relative "parser"
 
 module Types
 	# Represents a class type, optionally constrained to a base class.
@@ -86,7 +87,7 @@ module Types
 	# Constructs a {Class} type with an optional base class constraint.
 	# @parameter base [Class] The base class constraint.
 	# @returns [Class] a new {Class} type.
-	def self.Class(base = Object)
+	def PARSER.Class(base = Object)
 		Class.new(base)
 	end
 end

data/lib/types/enumerator.rb

@@ -4,6 +4,7 @@
 # Copyright, 2022-2025, by Samuel Williams.
 
 require_relative "generic"
+require_relative "parser"
 
 module Types
 	# Represents an enumerator type with a specific item type.
@@ -67,7 +68,7 @@ module Types
 	# Constructs an {Enumerator} type from the given item type.
 	# @parameter item_type [Type] The type of the enumerator elements.
 	# @returns [Enumerator] a new {Enumerator} type.
-	def self.Enumerator(item_type = Any)
+	def PARSER.Enumerator(item_type = Any)
 		Enumerator.new(item_type)
 	end
 end 

data/lib/types/hash.rb

@@ -4,12 +4,13 @@
 # Copyright, 2022-2025, by Samuel Williams.
 
 require_relative "generic"
+require_relative "parser"
 
 module Types
 	# Represents a hash type with key and value types.
 	#
 	# ```ruby
-	# type = Types::Hash(Types::String, Types::Integer)
+	# type = Types::Hash.new(Types::String, Types::Integer)
 	# type.parse({"foo" => "42"}) # => {"foo" => 42}
 	# ```
 	class Hash
@@ -73,7 +74,7 @@ module Types
 	# @parameter key_type [Type] The type of the hash keys.
 	# @parameter value_type [Type] The type of the hash values.
 	# @returns [Hash] a new {Hash} type.
-	def self.Hash(key_type, value_type)
+	def PARSER.Hash(key_type, value_type)
 		Hash.new(key_type, value_type)
 	end
 end

data/lib/types/interface.rb

@@ -4,29 +4,25 @@
 # Copyright, 2024-2025, by Samuel Williams.
 
 require_relative "generic"
-require_relative "method"
-require_relative "any"
 
 module Types
-	# Represents an interface type, defined by required method names.
+	# Represents an RBS interface type.
 	#
 	# ```ruby
-	# type = Types::Interface(
-	# 	foo: Method.new(Any, returns: Any),
-	# 	bar: Method.new(Any, returns: Any)
-	# )
-	# type.valid?(obj) # => true if obj responds to :foo and :bar
+	# type = Types::Interface.new("MyInterface")
+	# type.to_rbs # => "_MyInterface"
+	# type.to_s   # => "Interface(MyInterface)"
 	# ```
 	class Interface
 		include Generic
 		
-		# @parameter methods [Array(Symbol)] The required method names.
-		def initialize(methods)
-			@methods = methods
+		# @parameter name [String] The interface name.
+		def initialize(name)
+			@name = name
 		end
 		
-		# @returns [Array(Symbol)] The required method names.
-		attr :methods
+		# @returns [String] The interface name.
+		attr :name
 		
 		# @returns [Boolean] true if this is a composite type.
 		def composite?
@@ -35,66 +31,37 @@ module Types
 		
 		# @returns [String] the string representation of the interface type.
 		def to_s
-			buffer = ::String.new
-			
-			buffer << "Interface("
-			
-			if @methods&.any?
-				first = true
-				@methods.each do |name, method|
-					if first
-						first = false
-					else
-						buffer << ", "
-					end
-					
-					buffer << "#{name}: #{method}"
-				end
-			end
-			
-			buffer << ")"
-			
-			return buffer
+			"Interface(#{@name})"
 		end
 		
-		# Checks if the given instance responds to all required methods.
-		# @parameter instance [Object] The object to check.
-		# @returns [Boolean] true if the instance responds to all methods.
-		def valid?(instance)
-			@methods.all? do |name, method|
-				instance.respond_to?(name)
+		# @returns [String] the RBS interface representation with underscore prefix on the last component.
+		def to_rbs
+			if @name.include?("::")
+				# For nested interfaces like "MyLibrary::MyInterface", return "MyLibrary::_MyInterface"
+				parts = @name.split("::")
+				parts[-1] = "_#{parts[-1]}"
+				parts.join("::")
+			else
+				# For simple interfaces like "MyInterface", return "_MyInterface"
+				"_#{@name}"
 			end
 		end
 		
-		# Parses the input as an object and checks if it matches the interface.
-		# @parameter input [Object] The value to parse.
-		# @returns [Object] the input if it matches the interface.
-		# @raises [ArgumentError] if the input does not match the interface.
-		def parse(input)
-			case input
-			when ::String
-				instance = eval(input)
-			else
-				instance = input
-			end
-			
-			if valid?(instance)
-				return instance
-			else
-				raise ArgumentError, "Cannot coerce #{input.inspect} into #{self}!"
-			end
+		# @returns [Boolean] true if other is an Interface with the same name.
+		def == other
+			other.is_a?(Interface) && @name == other.name
+		end
+		
+		# @returns [Integer] hash code based on the name.
+		def hash
+			@name.hash
 		end
 	end
 	
-	# Constructs an {Interface} type from the given method names.
-	# @parameter methods [Array(Symbol)] The required method names.
+	# Constructs an {Interface} type from the given name.
+	# @parameter name [String, Symbol] The interface name.
 	# @returns [Interface] a new {Interface} type.
-	def self.Interface(*names, **methods)
-		# This is a deprecated way to create an interfaces with names only. Ideally, we actually need to know the methods.
-		names.each do |name|
-			methods[name.to_sym] = Method.new(Any(), [], Any())
-		end
-		
-		Interface.new(methods)
+	def PARSER.Interface(name)
+		Interface.new(name.to_s)
 	end
 end

data/lib/types/lambda.rb

@@ -61,7 +61,7 @@ module Types
 	# @parameter argument_types [Array(Type)] The types of the lambda arguments.
 	# @parameter returns [Type | Nil] The return type of the lambda.
 	# @returns [Lambda] a new {Lambda} type.
-	def self.Lambda(*argument_types, returns: nil)
+	def PARSER.Lambda(*argument_types, returns: nil)
 		Lambda.new(argument_types, returns)
 	end
 end

data/lib/types/method.rb

@@ -4,6 +4,7 @@
 # Copyright, 2022-2025, by Samuel Williams.
 
 require_relative "generic"
+require_relative "parser"
 
 module Types
 	# Represents a method type attached to a receiver type.
@@ -67,11 +68,11 @@ module Types
 		def parse(input)
 			case input
 			when ::String
-				receiver_type.instance_method(input)
+				receiver_type.resolve.instance_method(input)
 			when ::Proc
 				input
 			else
-				raise ArgumentError, "Cannot coerce #{input.inpsect} into Method!"
+				raise ArgumentError, "Cannot coerce #{input.inspect} into Method!"
 			end
 		end
 	end
@@ -81,7 +82,7 @@ module Types
 	# @parameter argument_types [Array(Type)] The types of the method arguments.
 	# @parameter returns [Type | Nil] The return type of the method.
 	# @returns [Method] a new {Method} type.
-	def self.Method(receiver_type, *argument_types, returns: nil)
+	def PARSER.Method(receiver_type, *argument_types, returns: nil)
 		Method.new(receiver_type, argument_types, returns)
 	end
 end

data/lib/types/named.rb

@@ -53,12 +53,24 @@ module Types
 		
 		# Resolves the named type to the actual Ruby type if it exists.
 		# @returns [Class | Module | Nil] The resolved Ruby type or nil if not found.
-		def resolve
-			Object.const_get(@name)
+		def resolve(relative_to: Object)
+			relative_to.const_get(@name)
 		rescue NameError
 			nil
 		end
 		
+		def to_type
+			resolve(relative_to: Types)
+		end
+		
+		def parse(value)
+			if type = self.to_type
+				type.parse(value)
+			else
+				raise ArgumentError, "Cannot parse value #{value.inspect} with unknown type #{@name}!"
+			end
+		end
+		
 		# @returns [String] the RBS type string using the name.
 		def to_rbs
 			@name
@@ -100,7 +112,7 @@ module Types
 	# Constructs a {Named} type with the given name.
 	# @parameter name [String] The name of the type.
 	# @returns [Named] a new {Named} type.
-	def self.Named(name)
+	def PARSER.Named(name)
 		Named.new(name)
 	end
 end

data/lib/types/parser.rb

@@ -0,0 +1,42 @@
+
+# Parses type signatures, must be defined at the top level for the purpose of name resolution.
+class Types::Parser < BasicObject
+	# Handles absolute type paths by creating absolute Named types for unknown types.
+	module TOP
+		def self.const_missing(name)
+			::Types::Named.new("::#{name}")
+		end
+	end
+	
+	# Handles missing constants by creating Named types for unknown types.
+	# This allows parsing of type signatures with unknown types.
+	# @parameter name [Symbol] The name of the missing constant.
+	# @returns [Named] A Named type representing the unknown type.
+	def self.const_missing(name)
+		::Types::Named.new(name.to_s)
+	end
+	
+	def parse(signature)
+		# Validate the signature format:
+		unless signature.match?(/\A[a-zA-Z0-9\(\):,_|\s]+\z/)
+			::Kernel.raise ::ArgumentError, "Invalid type signature: #{signature.inspect}!"
+		end
+		
+		# Replace leading :: with TOP:: to handle absolute type paths
+		normalized_signature = signature.gsub(/(?<=\A|\W)::/, "TOP::")
+		
+		binding = ::Kernel.binding
+		
+		return ::Kernel.eval(normalized_signature, binding)
+	end
+end
+
+module Types
+	PARSER = Parser.new
+	
+	self.define_singleton_method(:parse) do |signature|
+		PARSER.parse(signature)
+	end
+	
+	remove_const :Parser
+end

data/lib/types/tuple.rb

@@ -74,7 +74,7 @@ module Types
 	# Constructs a {Tuple} type from the given item types.
 	# @parameter item_types [Array(Type)] The types of the tuple elements.
 	# @returns [Tuple] a new {Tuple} type.
-	def self.Tuple(*item_types)
+	def PARSER.Tuple(*item_types)
 		Tuple.new(item_types)
 	end
 end

data/lib/types/version.rb

@@ -4,5 +4,5 @@
 # Copyright, 2022-2025, by Samuel Williams.
 
 module Types
-	VERSION = "0.4.4"
+	VERSION = "0.5.0"
 end

data/lib/types.rb

@@ -5,6 +5,8 @@
 
 require_relative "types/version"
 
+require_relative "types/parser"
+
 require_relative "types/any"
 require_relative "types/array"
 require_relative "types/block"
@@ -27,44 +29,4 @@ require_relative "types/tuple"
 
 # @namespace
 module Types
-	# The main module for the types library.
-	#
-	# Provides parsing and construction of type signatures.
-	#
-	# ```ruby
-	# Types.parse("Array(String)") # => Types::Array(Types::String)
-	# ```
-	VALID_SIGNATURE = /\A[a-zA-Z0-9\(\):,_|\s]+\z/
-	
-	# Parses a type signature string and returns the corresponding type instance.
-	# @parameter signature [String] The type signature to parse.
-	# @returns [Object] The type instance.
-	# @raises [ArgumentError] if the signature is invalid.
-	def self.parse(signature)
-		if signature =~ VALID_SIGNATURE
-			# Replace leading :: with Top:: to handle absolute type paths
-			normalized_signature = signature.gsub(/(?<=\A|\W)::/, "TOP::")
-			eval(normalized_signature, binding)
-		else
-			raise ArgumentError, "Invalid type signature: #{signature.inspect}!"
-		end
-	end
-	
-	# Handles absolute type paths by creating absolute Named types for unknown types.
-	module TOP
-		def self.const_missing(name)
-			Named.new("::#{name}")
-		end
-	end
-	
-	# Handles missing constants by creating Named types for unknown types.
-	# This allows parsing of type signatures with unknown types.
-	# @parameter name [Symbol] The name of the missing constant.
-	# @returns [Named] A Named type representing the unknown type.
-	def self.const_missing(name)
-		Named(name.to_s)
-	end
-	
-	# Bare classes and modules should be convertable to RBS strings.
-	Module.alias_method(:to_rbs, :to_s)
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: types
 version: !ruby/object:Gem::Version
-  version: 0.4.4
+  version: 0.5.0
 platform: ruby
 authors:
 - Samuel Williams
@@ -62,6 +62,7 @@ files:
 - lib/types/named.rb
 - lib/types/nil.rb
 - lib/types/numeric.rb
+- lib/types/parser.rb
 - lib/types/string.rb
 - lib/types/symbol.rb
 - lib/types/tuple.rb