types 0.1.3 → 0.3.0

data/lib/types/hash.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2022-2025, by Samuel Williams.
+
+require_relative "generic"
+
+module Types
+	# Represents a hash type with key and value types.
+	#
+	# ```ruby
+	# type = Types::Hash(Types::String, Types::Integer)
+	# type.parse({"foo" => "42"}) # => {"foo" => 42}
+	# ```
+	class Hash
+		include Generic
+		
+		# @parameter key_type [Type] The type of the hash keys.
+		# @parameter value_type [Type] The type of the hash values.
+		def initialize(key_type, value_type)
+			@key_type = key_type
+			@value_type = value_type
+		end
+		
+		# @returns [Boolean] true if this is a composite type.
+		def composite?
+			true
+		end
+		
+		# Parses the input as a hash with the specified key and value types.
+		# @parameter input [Object] The value to parse.
+		# @returns [Hash] The parsed hash.
+		# @raises [ArgumentError] if the input cannot be converted to a hash.
+		def parse(input)
+			case input
+			when ::String
+				return parse_values(parse_string(input))
+			when ::Hash
+				return parse_values(input)
+			else
+				raise ArgumentError, "Cannot coerce #{input.inspect} into Hash!"
+			end
+		end
+		
+		# @returns [String] the string representation of the hash type.
+		def to_s
+			"Hash(#{@key_type}, #{@value_type})"
+		end
+		
+		# @returns [String] the RBS type string, e.g. `{ String => Integer }`.
+		def to_rbs
+			"{ #{@key_type.to_rbs} => #{@value_type.to_rbs} }"
+		end
+		
+		private
+		
+		def parse_string(input)
+			::JSON.parse("{#{input}}")
+		end
+		
+		def parse_values(input)
+			input.map{|key, value| [@key_type.parse(key), @value_type.parse(value)]}.to_h
+		end
+	end
+	
+	# Constructs a {Hash} type from the given key and value 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)
+		Hash.new(key_type, value_type)
+	end
+end

data/lib/types/integer.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2022-2025, by Samuel Williams.
+
+require_relative "generic"
+
+module Types
+	# Represents an integer type.
+	#
+	# ```ruby
+	# type = Types::Integer
+	# type.parse("42") # => 42
+	# ```
+	module Integer
+		extend Generic
+		
+		# Parses the input as an integer.
+		# @parameter input [Object] The value to parse.
+		# @returns [Integer] The parsed integer value.
+		# @raises [ArgumentError] if the input cannot be converted to an integer.
+		def self.parse(input)
+			Integer(input)
+		end
+		
+		# @returns [String] the RBS type string, e.g. `Integer`.
+		def self.to_rbs
+			"Integer"
+		end
+	end
+end

data/lib/types/interface.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# 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.
+	#
+	# ```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
+	# ```
+	class Interface
+		extend Generic
+		
+		# @parameter methods [Array(Symbol)] The required method names.
+		def initialize(methods)
+			@methods = methods
+		end
+		
+		# @returns [Array(Symbol)] The required method names.
+		attr :methods
+		
+		# @returns [Boolean] true if this is a composite type.
+		def composite?
+			true
+		end
+		
+		# @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
+		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)
+			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
+		end
+	end
+	
+	# Constructs an {Interface} type from the given method names.
+	# @parameter methods [Array(Symbol)] The required method names.
+	# @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)
+	end
+end

data/lib/types/lambda.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2022-2025, by Samuel Williams.
+
+require_relative "generic"
+
+module Types
+	# Represents a lambda (function) type with argument and return types.
+	#
+	# ```ruby
+	# type = Types::Lambda(Types::String, Types::Integer, returns: Types::String)
+	# type.to_s # => "Lambda(String, Integer, returns: String)"
+	# ```
+	class Lambda
+		include Generic
+		
+		# @parameter argument_types [Array(Type)] The types of the lambda arguments.
+		# @parameter return_type [Type | Nil] The return type of the lambda.
+		def initialize(argument_types, return_type)
+			@argument_types = argument_types
+			@return_type = return_type
+		end
+		
+		# @returns [Array(Type)] The types of the lambda arguments.
+		attr :argument_types
+		# @returns [Type | Nil] The return type of the lambda.
+		attr :return_type
+		
+		# @returns [Boolean] true if this is a composite type.
+		def composite?
+			true
+		end
+		
+		# @returns [String] the string representation of the lambda type.
+		def to_s
+			if @return_type
+				"Lambda(#{@argument_types.join(', ')}, returns: #{@return_type})"
+			else
+				"Lambda(#{@argument_types.join(', ')})"
+			end
+		end
+		
+		# Parses the input as a lambda/proc.
+		# @parameter input [Object] The value to parse.
+		# @returns [Proc] the parsed lambda/proc.
+		# @raises [ArgumentError] if the input cannot be converted to a lambda.
+		def parse(input)
+			case input
+			when ::String
+				eval("lambda{#{input}}", TOPLEVEL_BINDING)
+			when ::Proc
+				input
+			else
+				raise ArgumentError, "Cannot coerce #{input.inpsect} into Lambda!"
+			end
+		end
+	end
+	
+	# Constructs a {Lambda} type from the given argument and return 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)
+		Lambda.new(argument_types, returns)
+	end
+end

data/lib/types/method.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2022-2025, by Samuel Williams.
+
+require_relative "generic"
+
+module Types
+	# Represents a method type attached to a receiver type.
+	#
+	# ```ruby
+	# type = Types::Method(Types::String, Types::Integer, returns: Types::String)
+	# type.to_s # => "Method(String, Integer, returns: String)"
+	# ```
+	class Method
+		include Generic
+		
+		# @parameter receiver_type [Type] The type of the receiver.
+		# @parameter argument_types [Array(Type)] The types of the method arguments.
+		# @parameter return_type [Type | Nil] The return type of the method.
+		def initialize(receiver_type, argument_types, return_type)
+			@receiver_type = receiver_type
+			@argument_types = argument_types
+			@return_type = return_type
+		end
+		
+		# @returns [Type] The type of the receiver.
+		attr :receiver_type
+		# @returns [Array(Type)] The types of the method arguments.
+		attr :argument_types
+		# @returns [Type | Nil] The return type of the method.
+		attr :return_type
+		
+		# @returns [Boolean] true if this is a composite type.
+		def composite?
+			true
+		end
+		
+		# @returns [String] the string representation of the method type.
+		def to_s
+			buffer = ::String.new
+			
+			if @argument_types&.any?
+				buffer << "Method(#{@receiver_type}, #{@argument_types.join(', ')}"
+			else
+				buffer << "Method(#{@receiver_type}, "
+			end
+			
+			if @return_type
+				buffer << "returns: #{@return_type})"
+			else
+				buffer << ")"
+			end
+			
+			return buffer
+		end
+		
+		# @returns [String] the RBS type string, e.g. `Method[Receiver, (Args) -> Return]`.
+		def to_rbs
+			argument_types = @argument_types.map {|t| t.to_rbs}.join(", ")
+			return_type = @return_type ? @return_type.to_rbs : "void"
+			
+			return "Method[#{@receiver_type}, (#{argument_types}) -> #{return_type}]"
+		end
+		
+		# Parses the input as a method or proc.
+		# @parameter input [Object] The value to parse.
+		# @returns [UnboundMethod, Proc] the parsed method or proc.
+		# @raises [ArgumentError] if the input cannot be converted to a method.
+		def parse(input)
+			case input
+			when ::String
+				receiver_type.instance_method(input)
+			when ::Proc
+				input
+			else
+				raise ArgumentError, "Cannot coerce #{input.inpsect} into Method!"
+			end
+		end
+	end
+	
+	# Constructs a {Method} type from the given receiver, argument, and return types.
+	# @parameter receiver_type [Type] The type of the receiver.
+	# @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)
+		Method.new(receiver_type, argument_types, returns)
+	end
+end

data/lib/types/nil.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2022-2025, by Samuel Williams.
+
+require_relative "generic"
+
+module Types
+	# Represents the nil type.
+	#
+	# ```ruby
+	# type = Types::Nil
+	# type.parse("nil") # => nil
+	# ```
+	module Nil
+		extend Generic
+		
+		# Parses the input as nil if it matches.
+		# @parameter input [Object] The value to parse.
+		# @returns [NilClass] nil if the input matches.
+		# @raises [ArgumentError] if the input cannot be converted to nil.
+		def self.parse(input)
+			if input =~ /nil|null/i
+				return nil
+			else
+				raise ArgumentError, "Cannot coerce #{input.inspect} into Nil!"
+			end
+		end
+		
+		# @returns [String] the RBS type string, e.g. `nil`.
+		def self.to_rbs
+			"nil"
+		end
+	end
+end

data/lib/types/numeric.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2022-2025, by Samuel Williams.
+
+require_relative "generic"
+
+module Types
+	# Represents a numeric type (integer or float).
+	#
+	# ```ruby
+	# type = Types::Numeric
+	# type.parse("42")   # => 42
+	# type.parse("3.14") # => 3.14
+	# ```
+	module Numeric
+		extend Generic
+		
+		# Parses the input as a numeric value (integer or float).
+		# @parameter input [Object] The value to parse.
+		# @returns [Numeric] The parsed numeric value.
+		def self.parse(input)
+			case input
+			when Numeric then input
+			when /\./ then Float(input)
+			else Integer(input)
+			end
+		end
+	end
+end

data/lib/types/string.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2022-2025, by Samuel Williams.
+
+require_relative "generic"
+
+module Types
+	# Represents a string type.
+	#
+	# ```ruby
+	# type = Types::String
+	# type.parse(42) # => "42"
+	# ```
+	module String
+		extend Generic
+		
+		# Parses the input as a string.
+		# @parameter input [Object] The value to parse.
+		# @returns [String] The parsed string value.
+		def self.parse(input)
+			input.to_s
+		end
+		
+		# @returns [String] the RBS type string, e.g. `String`.
+		def self.to_rbs
+			"String"
+		end
+	end
+end

data/lib/types/symbol.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2022-2025, by Samuel Williams.
+
+require_relative "generic"
+
+module Types
+	# Represents a symbol type.
+	#
+	# ```ruby
+	# type = Types::Symbol
+	# type.parse("foo") # => :foo
+	# ```
+	module Symbol
+		extend Generic
+		
+		# Parses the input as a symbol.
+		# @parameter input [Object] The value to parse.
+		# @returns [Symbol] The parsed symbol value.
+		def self.parse(input)
+			input.to_sym
+		end
+		
+		# @returns [String] the RBS type string, e.g. `Symbol`.
+		def self.to_rbs
+			"Symbol"
+		end
+	end
+end

data/lib/types/tuple.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2022-2025, by Samuel Williams.
+
+require_relative "generic"
+require "json"
+
+module Types
+	# Represents a tuple type with specific item types.
+	#
+	# ```ruby
+	# type = Types::Tuple(Types::String, Types::Integer)
+	# type.parse(["foo", "42"]) # => ["foo", 42]
+	# ```
+	class Tuple
+		include Generic
+		
+		# @parameter item_types [Array(Type)] The types of the tuple elements.
+		def initialize(item_types)
+			@item_types = item_types
+		end
+		
+		# @returns [Array(Type)] The types of the tuple elements.
+		attr :item_types
+		
+		# @returns [Boolean] true if this is a composite type.
+		def composite?
+			true
+		end
+		
+		# Parses the input as a tuple with the specified item types.
+		# @parameter input [Object] The value to parse.
+		# @returns [Array] The parsed tuple.
+		# @raises [ArgumentError] if the input cannot be converted to a tuple.
+		def parse(input)
+			case input
+			when ::String
+				return parse_values(parse_string(input))
+			when ::Array
+				return parse_values(input)
+			else
+				raise ArgumentError, "Cannot coerce #{input.inspect} into tuple!"
+			end
+		end
+		
+		# @returns [String] the string representation of the tuple type.
+		def to_s
+			"Tuple(#{@item_types.join(', ')})"
+		end
+		
+		# @returns [String] the RBS type string, e.g. `[String, Integer]`.
+		def to_rbs
+			"[#{@item_types.map {|t| t.to_rbs}.join(', ')}]"
+		end
+		
+		private
+		
+		def parse_string(input)
+			::JSON.parse("[#{input}]")
+		end
+		
+		def parse_values(input)
+			input.map.with_index{|value, index| @item_types[index].parse(value)}
+		end
+	end
+	
+	# 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)
+		Tuple.new(item_types)
+	end
+end

data/lib/types/version.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2022-2024, by Samuel Williams.
+
+module Types
+	VERSION = "0.3.0"
+end