class Module

A Module is a collection of methods and constants. The methods in a module may be instance methods or module methods. Instance methods appear as methods in a class when the module is included, module methods do not. Conversely, module methods may be called without creating an encapsulating object, while instance methods may not. (See Module#module_function.)

In the descriptions that follow, the parameter sym refers to a symbol, which is either a quoted string or a Symbol (such as :name).

module Mod
  include Math
  CONST = 1
  def meth
    #  ...
  end
end
Mod.class              #=> Module
Mod.constants          #=> [:CONST, :PI, :E]
Mod.instance_methods   #=> [:meth]

Public Class Methods

constants

() → ::Array[Integer]

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 43
def self.constants: () -> ::Array[Integer]

In the first form, returns an array of the names of all constants accessible from the point of call. This list includes the names of all modules and classes defined in the global scope.

Module.constants.first(4)
   # => [:ARGF, :ARGV, :ArgumentError, :Array]

Module.constants.include?(:SEEK_SET)   # => false

class IO
  Module.constants.include?(:SEEK_SET) # => true
end

The second form calls the instance method constants.

nesting

() → ::Array[Module]

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 59
def self.nesting: () -> ::Array[Module]

Returns the list of Modules nested at the point of call.

module M1
  module M2
    $a = Module.nesting
  end
end
$a           #=> [M1::M2, M1]
$a[0].name   #=> "M1::M2"

new

() → void
() { (Module arg0) → untyped } → void

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 958
def initialize: () -> void
                | () { (Module arg0) -> untyped } -> void

Creates a new anonymous module. If a block is given, it is passed the module object, and the block is evaluated in the context of this module like

module_eval.

fred = Module.new do
  def meth1
    "hello"
  end
  def meth2
    "bye"
  end
end
a = "my string"
a.extend(fred)   #=> "my string"
a.meth1          #=> "hello"
a.meth2          #=> "bye"

Assign the module to a constant (name starting uppercase) if you want to treat it like a regular module.

used_modules

() → ::Array[Module]

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 86
def self.used_modules: () -> ::Array[Module]

Returns an array of all modules used in the current scope. The ordering of modules in the resulting array is not defined.

module A
  refine Object do
  end
end

module B
  refine Object do
  end
end

using A
using B
p Module.used_modules

produces:

[B, A]

used_refinements

() → Array[Refinement]

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 113
def self.used_refinements: () -> Array[Refinement]

Returns an array of all modules used in the current scope. The ordering of modules in the resulting array is not defined.

module A
  refine Object do
  end
end

module B
  refine Object do
  end
end

using A
using B
p Module.used_refinements

produces:

[#<refinement:Object@B>, #<refinement:Object@A>]

Public Instance Methods

(Module other) → bool?

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 127
def <: (Module other) -> bool?

Returns whether self is a subclass of other, or nil if there is no relationship between the two:

Float < Numeric # => true
Numeric < Float # => false
Float < Float   # => false
Float < Hash    # => nil

(Module other) → bool?

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 137
def <=: (Module other) -> bool?

Returns true if mod is a subclass of other or is the same as other. Returns nil if there’s no relationship between the two. (Think of the relationship in terms of the class definition: “class A < B” implies “A < B”.)

<=>

(untyped other) → Integer?

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 166
def <=>: (untyped other) -> Integer?

Compares self and other.

Returns:

-1, if self includes other, if or self is a subclass of other.
0, if self and other are the same.
1, if other includes self, or if other is a subclass of self.
nil, if none of the above is true.

Examples:

         # Class Array includes module Enumerable.
         Array <=> Enumerable # => -1
    Enumerable <=> Enumerable # =>  0
    Enumerable <=> Array      # =>  1
# Class File is a subclass of class IO.
          File <=> IO         # => -1
          File <=> File       # =>  0
            IO <=> File       # =>  1
# Class File has no relationship to class String.
          File <=> String     # => nil

(untyped other) → bool

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 203
def ==: (untyped other) -> bool

Equality — At the Object level, == returns true only if obj and other are the same object. Typically, this method is overridden in descendant classes to provide class-specific meaning.

Unlike ==, the equal? method should never be overridden by subclasses as it is used to determine object identity (that is, a.equal?(b) if and only if a is the same object as b):

obj = "a"
other = obj.dup

obj == other      #=> true
obj.equal? other  #=> false
obj.equal? obj    #=> true

The eql? method returns true if obj and other refer to the same hash key. This is used by Hash to test members for equality. For any pair of objects where eql? returns true, the hash value of both objects must be equal. So any subclass that overrides eql? should also override hash appropriately.

For objects of class Object, eql? is synonymous with ==. Subclasses normally continue this tradition by aliasing eql? to their overridden == method, but there are exceptions. Numeric types, for example, perform type conversion across ==, but not across eql?, so:

1 == 1.0     #=> true
1.eql? 1.0   #=> false

===

(untyped other) → bool

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 213
def ===: (untyped other) -> bool

Case Equality—Returns true if obj is an instance of mod or an instance of one of mod‘s descendants. Of limited use for modules, but can be used in case statements to classify objects by class.

(Module other) → bool?

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 224
def >: (Module other) -> bool?

Returns true if mod is an ancestor of other. Returns false if mod is the same as other or mod is a descendant of other. Returns nil if there’s no relationship between the two. (Think of the relationship in terms of the class definition: “class A < B” implies “B > A”.)

(Module other) → bool?

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 234
def >=: (Module other) -> bool?

Returns true if mod is an ancestor of other, or the two modules are the same. Returns nil if there’s no relationship between the two. (Think of the relationship in terms of the class definition: “class A < B” implies “B > A”.)

alias_method

(interned new_name, interned old_name) → ::Symbol

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 257
def alias_method: (interned new_name, interned old_name) -> ::Symbol

Makes new_name a new copy of the method old_name. This can be used to retain access to methods that are overridden.

module Mod
  alias_method :orig_exit, :exit #=> :orig_exit
  def exit(code=0)
    puts "Exiting with code #{code}"
    orig_exit(code)
  end
end
include Mod
exit(99)

produces:

Exiting with code 99

ancestors

() → ::Array[Module]

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 276
def ancestors: () -> ::Array[Module]

Returns a list of modules included/prepended in mod (including mod itself).

module Mod
  include Math
  include Comparable
  prepend Enumerable
end

Mod.ancestors        #=> [Enumerable, Mod, Comparable, Math]
Math.ancestors       #=> [Math]
Enumerable.ancestors #=> [Enumerable]

attr

(interned, bool) → Array[Symbol]
(*interned arg0) → Array[Symbol]

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 1840
def attr: %a{deprecated} (interned, bool) -> Array[Symbol]
          | (*interned arg0) -> Array[Symbol]

The first form is equivalent to attr_reader. The second form is equivalent to attr_accessor(name) but deprecated. The last form is equivalent to attr_reader(name) but deprecated. Returns an array of defined method names as symbols.

attr_accessor

(*interned arg0) → Array[Symbol]

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 306
def attr_accessor: (*interned arg0) -> Array[Symbol]

Defines a named attribute for this module, where the name is symbol.id2name, creating an instance variable (@name) and a corresponding access method to read it. Also creates a method called name= to set the attribute. String arguments are converted to symbols. Returns an array of defined method names as symbols.

module Mod
  attr_accessor(:one, :two) #=> [:one, :one=, :two, :two=]
end
Mod.instance_methods.sort   #=> [:one, :one=, :two, :two=]

attr_reader

(*interned arg0) → Array[Symbol]

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 320
def attr_reader: (*interned arg0) -> Array[Symbol]

Creates instance variables and corresponding methods that return the value of each instance variable. Equivalent to calling “attr:name” on each name in turn. String arguments are converted to symbols. Returns an array of defined method names as symbols.

attr_writer

(*interned arg0) → Array[Symbol]

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 331
def attr_writer: (*interned arg0) -> Array[Symbol]

Creates an accessor method to allow assignment to the attribute symbol.id2name. String arguments are converted to symbols. Returns an array of defined method names as symbols.

autoload

(interned _module, String filename) → NilClass

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 352
def autoload: (interned _module, String filename) -> NilClass

Registers filename to be loaded (using Kernel::require) the first time that const (which may be a String or a symbol) is accessed in the namespace of mod.

module A
end
A.autoload(:B, "b")
A::B.doit            # autoloads "b"

If const in mod is defined as autoload, the file name to be loaded is replaced with filename. If const is defined but not as autoload, does nothing.

Files that are currently being loaded must not be registered for autoload.

autoload?

(interned name, ?boolish inherit) → String?

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 378
def autoload?: (interned name, ?boolish inherit) -> String?

Returns filename to be loaded if name is registered as autoload in the namespace of mod or one of its ancestors.

module A
end
A.autoload(:B, "b")
A.autoload?(:B)            #=> "b"

If inherit is false, the lookup only checks the autoloads in the receiver:

class A
  autoload :CONST, "const.rb"
end

class B < A
end

B.autoload?(:CONST)          #=> "const.rb", found in A (ancestor)
B.autoload?(:CONST, false)   #=> nil, not found in B itself

class_eval

(String arg0, ?String filename, ?Integer lineno) → untyped
[U] () { (self m) [self: self] → U } → U

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 400
def class_eval: (String arg0, ?String filename, ?Integer lineno) -> untyped
                | [U] () { (self m) [self: self] -> U } -> U

Evaluates the string or block in the context of mod, except that when a block is given, constant/class variable lookup is not affected. This can be used to add methods to a class. module_eval returns the result of evaluating its argument. The optional filename and lineno parameters set the text for error messages.

class Thing
end
a = %q{def hello() "Hello there!" end}
Thing.module_eval(a)
puts Thing.new.hello()
Thing.module_eval("invalid code", "dummy", 123)

produces:

Hello there!
dummy:123:in `module_eval': undefined local variable
    or method `code' for Thing:Class

class_exec

[U] (*untyped, **untyped) { (?) [self: self] → U } → U

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 420
def class_exec: [U] (*untyped, **untyped) { (?) [self: self] -> U } -> U

Evaluates the given block in the context of the class/module. The method defined in the block will belong to the receiver. Any arguments passed to the method will be passed to the block. This can be used if the block needs to access instance variables.

class Thing
end
Thing.class_exec{
  def hello() "Hello there!" end
}
puts Thing.new.hello()

produces:

Hello there!

class_variable_defined?

(interned arg0) → bool

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 436
def class_variable_defined?: (interned arg0) -> bool

Returns true if the given class variable is defined in obj. String arguments are converted to symbols.

class Fred
  @@foo = 99
end
Fred.class_variable_defined?(:@@foo)    #=> true
Fred.class_variable_defined?(:@@bar)    #=> false

class_variable_get

(interned arg0) → untyped

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 452
def class_variable_get: (interned arg0) -> untyped

Returns the value of the given class variable (or throws a NameError exception). The @@ part of the variable name should be included for regular class variables. String arguments are converted to symbols.

class Fred
  @@foo = 99
end
Fred.class_variable_get(:@@foo)     #=> 99

class_variable_set

(interned arg0, untyped arg1) → untyped

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 471
def class_variable_set: (interned arg0, untyped arg1) -> untyped

Sets the class variable named by symbol to the given object. If the class variable name is passed as a string, that string is converted to a symbol.

class Fred
  @@foo = 99
  def foo
    @@foo
  end
end
Fred.class_variable_set(:@@foo, 101)     #=> 101
Fred.new.foo                             #=> 101

class_variables

(?boolish inherit) → ::Array[Symbol]

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 491
def class_variables: (?boolish inherit) -> ::Array[Symbol]

Returns an array of the names of class variables in mod. This includes the names of class variables in any included modules, unless the inherit parameter is set to false.

class One
  @@var1 = 1
end
class Two < One
  @@var2 = 2
end
One.class_variables          #=> [:@@var1]
Two.class_variables          #=> [:@@var2, :@@var1]
Two.class_variables(false)   #=> [:@@var2]

const_defined?

(interned name, ?boolish inherit) → bool

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 576
def const_defined?: (interned name, ?boolish inherit) -> bool

Says whether mod or its ancestors have a constant with the given name:

Float.const_defined?(:EPSILON)      #=> true, found in Float itself
Float.const_defined?("String")      #=> true, found in Object (ancestor)
BasicObject.const_defined?(:Hash)   #=> false

If mod is a Module, additionally Object and its ancestors are checked:

Math.const_defined?(:String)   #=> true, found in Object

In each of the checked classes or modules, if the constant is not present but there is an autoload for it, true is returned directly without autoloading:

module Admin
  autoload :User, 'admin/user'
end
Admin.const_defined?(:User)   #=> true

If the constant is not found the callback const_missing is not called and the method returns false.

If inherit is false, the lookup only checks the constants in the receiver:

IO.const_defined?(:SYNC)          #=> true, found in File::Constants (ancestor)
IO.const_defined?(:SYNC, false)   #=> false, not found in IO itself

In this case, the same logic for autoloading applies.

If the argument is not a valid constant name a NameError is raised with the message “wrong constant name name”:

Hash.const_defined? 'foobar'   #=> NameError: wrong constant name foobar

const_get

(interned name, ?boolish inherit) → untyped

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 615
def const_get: (interned name, ?boolish inherit) -> untyped

Checks for a constant with the given name in mod. If inherit is set, the lookup will also search the ancestors (and Object if mod is a Module).

The value of the constant is returned if a definition is found, otherwise a NameError is raised.

Math.const_get(:PI)   #=> 3.14159265358979

This method will recursively look up constant names if a namespaced class name is provided. For example:

module Foo; class Bar; end end
Object.const_get 'Foo::Bar'

The inherit flag is respected on each lookup. For example:

module Foo
  class Bar
    VAL = 10
  end

  class Baz < Bar; end
end

Object.const_get 'Foo::Baz::VAL'         # => 10
Object.const_get 'Foo::Baz::VAL', false  # => NameError

If the argument is not a valid constant name a NameError will be raised with a warning “wrong constant name”.

Object.const_get 'foobar' #=> NameError: wrong constant name foobar

const_missing

(Symbol arg0) → untyped

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 655
def const_missing: (Symbol arg0) -> untyped

Invoked when a reference is made to an undefined constant in mod. It is passed a symbol for the undefined constant, and returns a value to be used for that constant. For example, consider:

def Foo.const_missing(name)
  name # return the constant name as Symbol
end

Foo::UNDEFINED_CONST    #=> :UNDEFINED_CONST: symbol returned

As the example above shows, const_missing is not required to create the missing constant in mod, though that is often a side-effect. The caller gets its return value when triggered. If the constant is also defined, further lookups won’t hit const_missing and will return the value stored in the constant as usual. Otherwise, const_missing will be invoked again.

In the next example, when a reference is made to an undefined constant, const_missing attempts to load a file whose path is the lowercase version of the constant name (thus class Fred is assumed to be in file fred.rb). If defined as a side-effect of loading the file, the method returns the value stored in the constant. This implements an autoload feature similar to Kernel#autoload and Module#autoload, though it differs in important ways.

def Object.const_missing(name)
  @looked_for ||= {}
  str_name = name.to_s
  raise "Constant not found: #{name}" if @looked_for[str_name]
  @looked_for[str_name] = 1
  file = str_name.downcase
  require file
  const_get(name, false)
end

const_set

(interned arg0, untyped arg1) → untyped

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 673
def const_set: (interned arg0, untyped arg1) -> untyped

Sets the named constant to the given object, returning that object. Creates a new constant if no constant with the given name previously existed.

Math.const_set("HIGH_SCHOOL_PI", 22.0/7.0)   #=> 3.14285714285714
Math::HIGH_SCHOOL_PI - Math::PI              #=> 0.00126448926734968

If sym or str is not a valid constant name a NameError will be raised with a warning “wrong constant name”.

Object.const_set('foobar', 42) #=> NameError: wrong constant name foobar

const_source_location

(interned name, ?boolish inherit) → ([ String, Integer ] | [ ] | nil)

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 724
def const_source_location: (interned name, ?boolish inherit) -> ([ String, Integer ] | [ ] | nil)

Returns the Ruby source filename and line number containing the definition of the constant specified. If the named constant is not found, nil is returned. If the constant is found, but its source location can not be extracted (constant is defined in C code), empty array is returned.

inherit specifies whether to lookup in mod.ancestors (true by default).

# test.rb:
class A         # line 1
  C1 = 1
  C2 = 2
end

module M        # line 6
  C3 = 3
end

class B < A     # line 10
  include M
  C4 = 4
end

class A # continuation of A definition
  C2 = 8 # constant redefinition; warned yet allowed
end

p B.const_source_location('C4')           # => ["test.rb", 12]
p B.const_source_location('C3')           # => ["test.rb", 7]
p B.const_source_location('C1')           # => ["test.rb", 2]

p B.const_source_location('C3', false)    # => nil  -- don't lookup in ancestors

p A.const_source_location('C2')           # => ["test.rb", 16] -- actual (last) definition place

p Object.const_source_location('B')       # => ["test.rb", 10] -- top-level constant could be looked through Object
p Object.const_source_location('A')       # => ["test.rb", 1] -- class reopening is NOT considered new definition

p B.const_source_location('A')            # => ["test.rb", 1]  -- because Object is in ancestors
p M.const_source_location('A')            # => ["test.rb", 1]  -- Object is not ancestor, but additionally checked for modules

p Object.const_source_location('A::C1')   # => ["test.rb", 2]  -- nesting is supported
p Object.const_source_location('String')  # => []  -- constant is defined in C code

constants

(?boolish inherit) → ::Array[Symbol]

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 742
def constants: (?boolish inherit) -> ::Array[Symbol]

Returns an array of the names of the constants accessible in mod. This includes the names of constants in any included modules (example at start of section), unless the inherit parameter is set to false.

The implementation makes no guarantees about the order in which the constants are yielded.

IO.constants.include?(:SYNC)        #=> true
IO.constants(false).include?(:SYNC) #=> false

Also see Module#const_defined?.

define_method

(interned symbol, ^(?) [self: top] → untyped | Method | UnboundMethod method) → Symbol
(interned symbol) { (?) [self: top] → untyped } → Symbol

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 782
def define_method: (interned symbol, ^(?) [self: top] -> untyped | Method | UnboundMethod method) -> Symbol
                   | (interned symbol) { (?) [self: top] -> untyped } -> Symbol

Defines an instance method in the receiver. The method parameter can be a Proc, a Method or an UnboundMethod object. If a block is specified, it is used as the method body. If a block or the method parameter has parameters, they’re used as method parameters. This block is evaluated using

instance_eval.

class A
  def fred
    puts "In Fred"
  end
  def create_method(name, &block)
    self.class.define_method(name, &block)
  end
  define_method(:wilma) { puts "Charge it!" }
  define_method(:flint) {|name| puts "I'm #{name}!"}
end
class B < A
  define_method(:barney, instance_method(:fred))
end
a = B.new
a.barney
a.wilma
a.flint('Dino')
a.create_method(:betty) { p self }
a.betty

produces:

In Fred
Charge it!
I'm Dino!
#<B:0x401b39e8>

deprecate_constant

(*interned) → self

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 802
def deprecate_constant: (*interned) -> self

Makes a list of existing constants deprecated. Attempt to refer to them will produce a warning.

module HTTP
  NotFound = Exception.new
  NOT_FOUND = NotFound # previous version of the library used this name

  deprecate_constant :NOT_FOUND
end

HTTP::NOT_FOUND
# warning: constant HTTP::NOT_FOUND is deprecated

equal?

(untyped other) → bool

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 804
def equal?: (untyped other) -> bool

freeze

() → self

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 860
def freeze: () -> self

Prevents further modifications to mod.

This method returns self.

include

(Module, *Module arg0) → self

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 868
def include: (Module, *Module arg0) -> self

Invokes Module.append_features on each parameter in reverse order.

include?

(Module arg0) → bool

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 888
def include?: (Module arg0) -> bool

Returns true if module is included or prepended in mod or one of mod‘s ancestors.

module A
end
class B
  include A
end
class C < B
end
B.include?(A)   #=> true
C.include?(A)   #=> true
A.include?(A)   #=> false

included_modules

() → ::Array[Module]

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 931
def included_modules: () -> ::Array[Module]

Returns the list of modules included or prepended in mod or one of mod‘s ancestors.

module Sub
end

module Mixin
  prepend Sub
end

module Outer
  include Mixin
end

Mixin.included_modules   #=> [Sub]
Outer.included_modules   #=> [Sub, Mixin]

inspect

() → String

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 1827
def inspect: () -> String

Returns a string representing this module or class. For basic classes and modules, this is the name. For singletons, we show information on the thing we’re attached to as well.

instance_method

(interned arg0) → UnboundMethod

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 990
def instance_method: (interned arg0) -> UnboundMethod

Returns an UnboundMethod representing the given instance method in mod.

class Interpreter
  def do_a() print "there, "; end
  def do_d() print "Hello ";  end
  def do_e() print "!\n";     end
  def do_v() print "Dave";    end
  Dispatcher = {
    "a" => instance_method(:do_a),
    "d" => instance_method(:do_d),
    "e" => instance_method(:do_e),
    "v" => instance_method(:do_v)
  }
  def interpret(string)
    string.each_char {|b| Dispatcher[b].bind(self).call }
  end
end

interpreter = Interpreter.new
interpreter.interpret('dave')

produces:

Hello there, Dave!

instance_methods

(?boolish include_super) → ::Array[Symbol]

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 1027
def instance_methods: (?boolish include_super) -> ::Array[Symbol]

Returns an array containing the names of the public and protected instance methods in the receiver. For a module, these are the public and protected methods; for a class, they are the instance (not singleton) methods. If the optional parameter is false, the methods of any ancestors are not included.

module A
  def method1()  end
end
class B
  include A
  def method2()  end
end
class C < B
  def method3()  end
end

A.instance_methods(false)                   #=> [:method1]
B.instance_methods(false)                   #=> [:method2]
B.instance_methods(true).include?(:method1) #=> true
C.instance_methods(false)                   #=> [:method3]
C.instance_methods.include?(:method2)       #=> true

Note that method visibility changes in the current class, as well as aliases, are considered as methods of the current class by this method:

class C < B
  alias method4 method2
  protected :method2
end
C.instance_methods(false).sort               #=> [:method2, :method3, :method4]

method_defined?

(interned name, ?boolish inherit) → bool

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 1083
def method_defined?: (interned name, ?boolish inherit) -> bool

Returns true if the named method is defined by mod. If inherit is set, the lookup will also search mod‘s ancestors. Public and protected methods are matched. String arguments are converted to symbols.

module A
  def method1()  end
  def protected_method1()  end
  protected :protected_method1
end
class B
  def method2()  end
  def private_method2()  end
  private :private_method2
end
class C < B
  include A
  def method3()  end
end

A.method_defined? :method1              #=> true
C.method_defined? "method1"             #=> true
C.method_defined? "method2"             #=> true
C.method_defined? "method2", true       #=> true
C.method_defined? "method2", false      #=> false
C.method_defined? "method3"             #=> true
C.method_defined? "protected_method1"   #=> true
C.method_defined? "method4"             #=> false
C.method_defined? "private_method2"     #=> false

module_eval

(String arg0, ?String filename, ?Integer lineno) → untyped
[U] () { (self m) [self: self] → U } → U

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 1161
def module_eval: (String arg0, ?String filename, ?Integer lineno) -> untyped
                 | [U] () { (self m) [self: self] -> U } -> U

class Thing
end
a = %q{def hello() "Hello there!" end}
Thing.module_eval(a)
puts Thing.new.hello()
Thing.module_eval("invalid code", "dummy", 123)

produces:

Hello there!
dummy:123:in `module_eval': undefined local variable
    or method `code' for Thing:Class

module_exec

[U] (*untyped, **untyped) { (?) [self: self] → U } → U

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 1185
def module_exec: [U] (*untyped, **untyped) { (?) [self: self] -> U } -> U

class Thing
end
Thing.class_exec{
  def hello() "Hello there!" end
}
puts Thing.new.hello()

produces:

Hello there!

name

() → String

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 1238
def name: %a{implicitly-returns-nil} () -> String

Returns the name of the module mod. Returns nil for anonymous modules.

prepend

(Module, *Module arg0) → self

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 1246
def prepend: (Module, *Module arg0) -> self

Invokes Module.prepend_features on each parameter in reverse order.

private_class_method

(*interned arg0) → self
(Array[interned] arg0) → self

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 1330
def private_class_method: (*interned arg0) -> self
                          | (Array[interned] arg0) -> self

Makes existing class methods private. Often used to hide the default constructor new.

String arguments are converted to symbols. An Array of Symbols and/or Strings is also accepted.

class SimpleSingleton  # Not thread safe
  private_class_method :new
  def SimpleSingleton.create(*args, &block)
    @me = new(*args, &block) if ! @me
    @me
  end
end

private_constant

(*interned arg0) → self

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 1339
def private_constant: (*interned arg0) -> self

Makes a list of existing constants private.

private_instance_methods

(?boolish include_super) → ::Array[Symbol]

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 1356
def private_instance_methods: (?boolish include_super) -> ::Array[Symbol]

Returns a list of the private instance methods defined in mod. If the optional parameter is false, the methods of any ancestors are not included.

module Mod
  def method1()  end
  private :method1
  def method2()  end
end
Mod.instance_methods           #=> [:method2]
Mod.private_instance_methods   #=> [:method1]

private_method_defined?

(interned name, ?boolish inherit) → bool

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 1386
def private_method_defined?: (interned name, ?boolish inherit) -> bool

Returns true if the named private method is defined by mod. If inherit is set, the lookup will also search mod‘s ancestors. String arguments are converted to symbols.

module A
  def method1()  end
end
class B
  private
  def method2()  end
end
class C < B
  include A
  def method3()  end
end

A.method_defined? :method1                   #=> true
C.private_method_defined? "method1"          #=> false
C.private_method_defined? "method2"          #=> true
C.private_method_defined? "method2", true    #=> true
C.private_method_defined? "method2", false   #=> false
C.method_defined? "method2"                  #=> false

protected_instance_methods

(?boolish include_super) → ::Array[Symbol]

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 1458
def protected_instance_methods: (?boolish include_super) -> ::Array[Symbol]

Returns a list of the protected instance methods defined in mod. If the optional parameter is false, the methods of any ancestors are not included.

protected_method_defined?

(interned name, ?boolish inherit) → bool

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 1488
def protected_method_defined?: (interned name, ?boolish inherit) -> bool

Returns true if the named protected method is defined mod. If inherit is set, the lookup will also search mod‘s ancestors. String arguments are converted to symbols.

module A
  def method1()  end
end
class B
  protected
  def method2()  end
end
class C < B
  include A
  def method3()  end
end

A.method_defined? :method1                    #=> true
C.protected_method_defined? "method1"         #=> false
C.protected_method_defined? "method2"         #=> true
C.protected_method_defined? "method2", true   #=> true
C.protected_method_defined? "method2", false  #=> false
C.method_defined? "method2"                   #=> true

public_class_method

(*interned arg0) → self
(Array[interned] arg0) → self

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 1522
def public_class_method: (*interned arg0) -> self
                         | (Array[interned] arg0) -> self

Makes a list of existing class methods public.

String arguments are converted to symbols. An Array of Symbols and/or Strings is also accepted.

public_constant

(*interned arg0) → self

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 1531
def public_constant: (*interned arg0) -> self

Makes a list of existing constants public.

public_instance_method

(interned arg0) → UnboundMethod

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 1539
def public_instance_method: (interned arg0) -> UnboundMethod

Similar to instance_method, searches public method only.

public_instance_methods

(?boolish include_super) → ::Array[Symbol]

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 1548
def public_instance_methods: (?boolish include_super) -> ::Array[Symbol]

Returns a list of the public instance methods defined in mod. If the optional parameter is false, the methods of any ancestors are not included.

public_method_defined?

(interned name, ?boolish inherit) → bool

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 1578
def public_method_defined?: (interned name, ?boolish inherit) -> bool

Returns true if the named public method is defined by mod. If inherit is set, the lookup will also search mod‘s ancestors. String arguments are converted to symbols.

module A
  def method1()  end
end
class B
  protected
  def method2()  end
end
class C < B
  include A
  def method3()  end
end

A.method_defined? :method1                 #=> true
C.public_method_defined? "method1"         #=> true
C.public_method_defined? "method1", true   #=> true
C.public_method_defined? "method1", false  #=> true
C.public_method_defined? "method2"         #=> false
C.method_defined? "method2"                #=> true

refinements

() → Array[Refinement]

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 1610
def refinements: () -> Array[Refinement]

Returns an array of Refinement defined within the receiver.

module A
  refine Integer do
  end

  refine String do
  end
end

p A.refinements

produces:

[#<refinement:Integer@A>, #<refinement:String@A>]

remove_class_variable

(interned arg0) → untyped

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 1630
def remove_class_variable: (interned arg0) -> untyped

Removes the named class variable from the receiver, returning that variable’s value.

class Example
  @@var = 99
  puts remove_class_variable(:@@var)
  p(defined? @@var)
end

produces:

99
nil

remove_method

(*interned arg0) → self

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 1650
def remove_method: (*interned arg0) -> self

Removes the method identified by symbol from the current class. For an example, see Module#undef_method. String arguments are converted to symbols.

set_temporary_name

(string?) → self

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 1736
def set_temporary_name: (string?) -> self

Sets the temporary name of the module. This name is reflected in introspection of the module and the values that are related to it, such as instances, constants, and methods.

The name should be nil or a non-empty string that is not a valid constant path (to avoid confusing between permanent and temporary names).

The method can be useful to distinguish dynamically generated classes and modules without assigning them to constants.

If the module is given a permanent name by assigning it to a constant, the temporary name is discarded. A temporary name can’t be assigned to modules that have a permanent name.

If the given name is nil, the module becomes anonymous again.

Example:

m = Module.new # => #<Module:0x0000000102c68f38>
m.name #=> nil

m.set_temporary_name("fake_name") # => fake_name
m.name #=> "fake_name"

m.set_temporary_name(nil) # => #<Module:0x0000000102c68f38>
m.name #=> nil

c = Class.new
c.set_temporary_name("MyClass(with description)") # => MyClass(with description)

c.new # => #<MyClass(with description):0x0....>

c::M = m
c::M.name #=> "MyClass(with description)::M"

# Assigning to a constant replaces the name with a permanent one
C = c

C.name #=> "C"
C::M.name #=> "C::M"
c.new # => #<C:0x0....>

singleton_class?

() → bool

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 1750
def singleton_class?: () -> bool

Returns true if mod is a singleton class or false if it is an ordinary class or module.

class C
end
C.singleton_class?                  #=> false
C.singleton_class.singleton_class?  #=> true

to_s

() → String

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 1760
def to_s: () -> String

Returns a string representing this module or class. For basic classes and modules, this is the name. For singletons, we show information on the thing we’re attached to as well.

undef_method

(*interned arg0) → self

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 1802
def undef_method: (*interned arg0) -> self

Prevents the current class from responding to calls to the named method. Contrast this with remove_method, which deletes the method from the particular class; Ruby will still search superclasses and mixed-in modules for a possible receiver. String arguments are converted to symbols.

class Parent
  def hello
    puts "In parent"
  end
end
class Child < Parent
  def hello
    puts "In child"
  end
end

c = Child.new
c.hello

class Child
  remove_method :hello  # remove from child, still in parent
end
c.hello

class Child
  undef_method :hello   # prevent any calls to 'hello'
end
c.hello

produces:

In child
In parent
prog.rb:23: undefined method 'hello' for #<Child:0x401b3bb4> (NoMethodError)

undefined_instance_methods

() → Array[Symbol]

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/core/module.rbs, line 1811
def undefined_instance_methods: () -> Array[Symbol]

Returns a list of the undefined instance methods defined in mod. The undefined methods of any ancestors are not included.