Receive only a specific message.

Instead ofRactor.receive,::receive_if can provide apattern by a block and you can choose the receiving message.

r =Ractor.newdopRactor.receive_if{|msg|msg.match?(/foo/)}#=> "foo3"pRactor.receive_if{|msg|msg.match?(/bar/)}#=> "bar1"pRactor.receive_if{|msg|msg.match?(/baz/)}#=> "baz2"endr<<"bar1"r<<"baz2"r<<"foo3"r.take

This will output:

foo3bar1baz2

If the block returns a truthy value, the message will be removed from theincoming queue and returned. Otherwise, the messsage remains in theincoming queue and the following received messages are checked by the givenblock.

If there are no messages left in the incoming queue, the method will blockuntil new messages arrive.

If the block is escaped by break/return/exception/throw, the message isremoved from the incoming queue as if a truthy value had been returned.

r =Ractor.newdoval =Ractor.receive_if{|msg|msg.is_a?(Array)}puts"Received successfully: #{val}"endr.send(1)r.send('test')waitputs"2 non-matching sent, nothing received"r.send([1,2,3])wait

Prints:

2 non-matching sent, nothing receivedReceived successfully: [1, 2, 3]

Note that you can not call receive/receive_if in the given blockrecursively. It means that you should not do any tasks in the block.

Ractor.current<<trueRactor.receive_if{|msg|Ractor.receive}#=> `receive': can not call receive/receive_if recursively (Ractor::Error)

# File ractor.rb, line 493defself.receive_if&bPrimitive.ractor_receive_ifbend

Returns true if two objects do not match (using the=~ method),otherwise false.

                static VALUErb_obj_not_match(VALUE obj1, VALUE obj2){    VALUE result = rb_funcall(obj1, id_match, 1, obj2);    return RTEST(result) ? Qfalse : Qtrue;}

Returns 0 ifobj andother are the same object orobj == other, otherwise nil.

The #<=> is used by various methods to compare objects, for exampleEnumerable#sort,Enumerable#max etc.

Your implementation of #<=> should return one of the followingvalues: -1, 0, 1 or nil. -1 means self is smaller than other. 0 means selfis equal to other. 1 means self is bigger than other. Nil means the twovalues could not be compared.

When you define #<=>, you can includeComparable to gain the methods #<=, #<,#==, #>=, #> and between?.

                static VALUErb_obj_cmp(VALUE obj1, VALUE obj2){    if (rb_equal(obj1, obj2))        return INT2FIX(0);    return Qnil;}

Case Equality – For classObject, effectively thesame as calling#==, but typically overridden by descendantsto provide meaningful semantics incase statements.

                #define case_equal rb_equal

This method is deprecated.

This is not only useless but also troublesome because it may hide a typeerror.

                static VALUErb_obj_match(VALUE obj1, VALUE obj2){    if (rb_warning_category_enabled_p(RB_WARN_CATEGORY_DEPRECATED)) {        rb_category_warn(RB_WARN_CATEGORY_DEPRECATED, "deprecated Object#=~ is called on %"PRIsVALUE                "; it always returns nil", rb_obj_class(obj1));    }    return Qnil;}

Defines a singleton method in the receiver. Themethod parametercan be aProc, aMethod or anUnboundMethod object. If a block is specified, it is used asthe method body. If a block or a method has parameters, they're used asmethod parameters.

classAclass<<selfdefclass_nameto_sendendendA.define_singleton_method(:who_am_i)do"I am: #{class_name}"endA.who_am_i# ==> "I am: A"guy ="Bob"guy.define_singleton_method(:hello) {"#{self}: Hello there!" }guy.hello#=>  "Bob: Hello there!"chris ="Chris"chris.define_singleton_method(:greet) {|greeting|"#{greeting}, I'm Chris!" }chris.greet("Hi")#=> "Hi, I'm Chris!"

                static VALUErb_obj_define_method(int argc, VALUE *argv, VALUE obj){    VALUE klass = rb_singleton_class(obj);    return rb_mod_define_method(argc, argv, klass);}

Printsobj on the given port (default$>).Equivalent to:

defdisplay(port=$>)port.writeselfnilend

For example:

1.display"cat".display[4,5,6 ].displayputs

produces:

1cat[4, 5, 6]

                static VALUErb_obj_display(int argc, VALUE *argv, VALUE self){    VALUE out;    out = (!rb_check_arity(argc, 0, 1) ? rb_ractor_stdout() : argv[0]);    rb_io_write(out, self);    return Qnil;}

Produces a shallow copy ofobj—the instance variables ofobj are copied, but not the objects they reference.

This method may have class-specific behavior. If so, that behavior will bedocumented under the #initialize_copy method of the class.

on dup vs clone¶↑

In general,clone anddup may have different semantics indescendant classes. Whileclone isused to duplicate an object, including its internal state,dup typically uses the class of thedescendant object to create the new instance.

When usingdup, any modules that theobject has been extended with will not be copied.

classKlassattr_accessor :strendmoduleFoodeffoo;'foo';endends1 =Klass.new#=> #<Klass:0x401b3a38>s1.extend(Foo)#=> #<Klass:0x401b3a38>s1.foo#=> "foo"s2 =s1.clone#=> #<Klass:0x401be280>s2.foo#=> "foo"s3 =s1.dup#=> #<Klass:0x401c1084>s3.foo#=> NoMethodError: undefined method `foo' for #<Klass:0x401c1084>

                VALUErb_obj_dup(VALUE obj){    VALUE dup;    if (special_object_p(obj)) {        return obj;    }    dup = rb_obj_alloc(rb_obj_class(obj));    init_copy(dup, obj);    rb_funcall(dup, id_init_dup, 1, obj);    return dup;}

Creates a newEnumerator which will enumerateby callingmethod onobj, passingargs if any. What wasyielded by method becomesvalues of enumerator.

If a block is given, it will be used to calculate the size of theenumerator without the need to iterate it (seeEnumerator#size).

Examples¶↑

str ="xyz"enum =str.enum_for(:each_byte)enum.each {|b|putsb }# => 120# => 121# => 122# protect an array from being modified by some_methoda = [1,2,3]some_method(a.to_enum)# String#split in block form is more memory-effective:very_large_string.split("|") {|chunk|returnchunkifchunk.include?('DATE') }# This could be rewritten more idiomatically with to_enum:very_large_string.to_enum(:split,"|").lazy.grep(/DATE/).first

It is typical to call#to_enumwhen defining methods for a genericEnumerable, in case no block is passed.

Here is such an example, with parameter passing and a sizing block:

moduleEnumerable# a generic method to repeat the values of any enumerabledefrepeat(n)raiseArgumentError,"#{n} is negative!"ifn<0unlessblock_given?returnto_enum(__method__,n)do# __method__ is :repeat heresz =size# Call size and multiply by n...sz*nifsz# but return nil if size itself is nilendendeachdo|*val|n.times {yield*val }endendend%[helloworld].repeat(2) {|w|putsw }# => Prints 'hello', 'hello', 'world', 'world'enum = (1..14).repeat(3)# => returns an Enumerator when called without a blockenum.first(4)# => [1, 1, 1, 2]enum.size# => 42

                static VALUEobj_to_enum(int argc, VALUE *argv, VALUE obj){    VALUE enumerator, meth = sym_each;    if (argc > 0) {        --argc;        meth = *argv++;    }    enumerator = rb_enumeratorize_with_size(obj, meth, argc, argv, 0);    if (rb_block_given_p()) {        enumerator_ptr(enumerator)->size = rb_block_proc();    }    return enumerator;}

Equality — At theObject level, #== returnstrue only ifobj andother are thesame object. Typically, this method is overridden in descendant classes toprovide class-specific meaning.

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

obj ="a"other =obj.dupobj==other#=> trueobj.equal?other#=> falseobj.equal?obj#=> true

Theeql? method returnstrue ifobj andother refer to thesame hash key. This is used byHash to testmembers for equality. For any pair of objects whereeql? returnstrue, thehash value of both objects must beequal. So any subclass that overrideseql? should also overridehash appropriately.

For objects of classObject,eql? is synonymous with #==. Subclasses normally continue this tradition by aliasingeql? to their overridden #== method,but there are exceptions.Numeric types, forexample, perform type conversion across #==, but not acrosseql?, so:

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

                MJIT_FUNC_EXPORTED VALUErb_obj_equal(VALUE obj1, VALUE obj2){    if (obj1 == obj2) return Qtrue;    return Qfalse;}

Adds toobj the instance methods from each module given as aparameter.

moduleModdefhello"Hello from Mod.\n"endendclassKlassdefhello"Hello from Klass.\n"endendk =Klass.newk.hello#=> "Hello from Klass.\n"k.extend(Mod)#=> #<Klass:0x401b3bc8>k.hello#=> "Hello from Mod.\n"

                static VALUErb_obj_extend(int argc, VALUE *argv, VALUE obj){    int i;    ID id_extend_object, id_extended;    CONST_ID(id_extend_object, "extend_object");    CONST_ID(id_extended, "extended");    rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);    for (i = 0; i < argc; i++)        Check_Type(argv[i], T_MODULE);    while (argc--) {        rb_funcall(argv[argc], id_extend_object, 1, obj);        rb_funcall(argv[argc], id_extended, 1, obj);    }    return obj;}

Prevents further modifications toobj. ARuntimeError will be raised if modification isattempted. There is no way to unfreeze a frozen object. See alsoKernel#frozen?.

This method returns self.

a = ["a","b","c" ]a.freezea<<"z"

produces:

prog.rb:3:in `<<': can't modify frozen Array (FrozenError) from prog.rb:3

Objects of the following classes are always frozen:Integer,Float,Symbol.

                VALUErb_obj_freeze(VALUE obj){    if (!OBJ_FROZEN(obj)) {        OBJ_FREEZE(obj);        if (SPECIAL_CONST_P(obj)) {            rb_bug("special consts should be frozen.");        }    }    return obj;}

Generates anInteger hash value for this object.This function must have the property thata.eql?(b) impliesa.hash == b.hash.

The hash value is used along witheql? by theHash class to determine if two objects reference thesame hash key. Any hash value that exceeds the capacity of anInteger will be truncated before being used.

The hash value for an object may not be identical across invocations orimplementations of Ruby. If you need a stable identifier across Rubyinvocations and implementations you will need to generate one with a custommethod.

Certain core classes such asInteger usebuilt-in hash calculations and do not call thehash method when used as a hash key.

                VALUErb_obj_hash(VALUE obj){    long hnum = any_hash(obj, objid_hash);    return ST2FIX(hnum);}

Returns a string containing a human-readable representation ofobj. The defaultinspect shows the object'sclass name, an encoding of its memory address, and a list of the instancevariables and their values (by callinginspect on each of them). Userdefined classes should override this method to provide a betterrepresentation ofobj. When overriding this method, it shouldreturn a string whose encoding is compatible with the default externalencoding.

[1,2,3..4,'five' ].inspect#=> "[1, 2, 3..4, \"five\"]"Time.new.inspect#=> "2008-03-08 19:43:39 +0900"classFooendFoo.new.inspect#=> "#<Foo:0x0300c868>"classBardefinitialize@bar =1endendBar.new.inspect#=> "#<Bar:0x0300c868 @bar=1>"

                static VALUErb_obj_inspect(VALUE obj){    if (rb_ivar_count(obj) > 0) {        VALUE str;        VALUE c = rb_class_name(CLASS_OF(obj));        str = rb_sprintf("-<%"PRIsVALUE":%p", c, (void*)obj);        return rb_exec_recursive(inspect_obj, obj, str);    }    else {        return rb_any_to_s(obj);    }}

Returnstrue ifobj is an instance of the givenclass. See also#kind_of?.

classA;endclassB<A;endclassC<B;endb =B.newb.instance_of?A#=> falseb.instance_of?B#=> trueb.instance_of?C#=> false

                VALUErb_obj_is_instance_of(VALUE obj, VALUE c){    c = class_or_module_required(c);    if (rb_obj_class(obj) == c) return Qtrue;    return Qfalse;}

Returnstrue if the given instance variable is defined inobj.String arguments are converted tosymbols.

classFreddefinitialize(p1,p2)@a,@b =p1,p2endendfred =Fred.new('cat',99)fred.instance_variable_defined?(:@a)#=> truefred.instance_variable_defined?("@b")#=> truefred.instance_variable_defined?("@c")#=> false

                static VALUErb_obj_ivar_defined(VALUE obj, VALUE iv){    ID id = id_for_var(obj, iv, instance);    if (!id) {        return Qfalse;    }    return rb_ivar_defined(obj, id);}

Returns the value of the given instance variable, or nil if the instancevariable is not set. The@ part of the variable name should beincluded for regular instance variables. Throws aNameError exception if the supplied symbol is notvalid as an instance variable name.Stringarguments are converted to symbols.

classFreddefinitialize(p1,p2)@a,@b =p1,p2endendfred =Fred.new('cat',99)fred.instance_variable_get(:@a)#=> "cat"fred.instance_variable_get("@b")#=> 99

                static VALUErb_obj_ivar_get(VALUE obj, VALUE iv){    ID id = id_for_var(obj, iv, instance);    if (!id) {        return Qnil;    }    return rb_ivar_get(obj, id);}

Sets the instance variable named bysymbol to the given object.This may circumvent the encapsulation intended by the author of the class,so it should be used with care. The variable does not have to exist priorto this call. If the instance variable name is passed as a string, thatstring is converted to a symbol.

classFreddefinitialize(p1,p2)@a,@b =p1,p2endendfred =Fred.new('cat',99)fred.instance_variable_set(:@a,'dog')#=> "dog"fred.instance_variable_set(:@c,'cat')#=> "cat"fred.inspect#=> "#<Fred:0x401b3da8 @a=\"dog\", @b=99, @c=\"cat\">"

                static VALUErb_obj_ivar_set(VALUE obj, VALUE iv, VALUE val){    ID id = id_for_var(obj, iv, instance);    if (!id) id = rb_intern_str(iv);    return rb_ivar_set(obj, id, val);}

Returns an array of instance variable names for the receiver. Note thatsimply defining an accessor does not create the corresponding instancevariable.

classFredattr_accessor :a1definitialize@iv =3endendFred.new.instance_variables#=> [:@iv]

                VALUErb_obj_instance_variables(VALUE obj){    VALUE ary;    ary = rb_ary_new();    rb_ivar_foreach(obj, ivar_i, ary);    return ary;}

Returnstrue ifclass is the class ofobj,or ifclass is one of the superclasses ofobj or modulesincluded inobj.

moduleM;endclassAincludeMendclassB<A;endclassC<B;endb =B.newb.is_a?A#=> trueb.is_a?B#=> trueb.is_a?C#=> falseb.is_a?M#=> trueb.kind_of?A#=> trueb.kind_of?B#=> trueb.kind_of?C#=> falseb.kind_of?M#=> true

                VALUErb_obj_is_kind_of(VALUE obj, VALUE c){    VALUE cl = CLASS_OF(obj);    c = class_or_module_required(c);    return class_search_ancestor(cl, RCLASS_ORIGIN(c)) ? Qtrue : Qfalse;}

Returns the receiver.

string ="my string"string.itself.object_id==string.object_id#=> true

                static VALUErb_obj_itself(VALUE obj){    return obj;}

Returnstrue ifclass is the class ofobj,or ifclass is one of the superclasses ofobj or modulesincluded inobj.

moduleM;endclassAincludeMendclassB<A;endclassC<B;endb =B.newb.is_a?A#=> trueb.is_a?B#=> trueb.is_a?C#=> falseb.is_a?M#=> trueb.kind_of?A#=> trueb.kind_of?B#=> trueb.kind_of?C#=> falseb.kind_of?M#=> true

                VALUErb_obj_is_kind_of(VALUE obj, VALUE c){    VALUE cl = CLASS_OF(obj);    c = class_or_module_required(c);    return class_search_ancestor(cl, RCLASS_ORIGIN(c)) ? Qtrue : Qfalse;}

Looks up the named method as a receiver inobj, returning aMethod object (or raisingNameError). TheMethodobject acts as a closure inobj's object instance, so instancevariables and the value ofself remain available.

classDemodefinitialize(n)@iv =nenddefhello()"Hello, @iv = #{@iv}"endendk =Demo.new(99)m =k.method(:hello)m.call#=> "Hello, @iv = 99"l =Demo.new('Fred')m =l.method("hello")m.call#=> "Hello, @iv = Fred"

Note thatMethod implementsto_procmethod, which means it can be used with iterators.

[1,2,3 ].each(&method(:puts))# => prints 3 lines to stdoutout =File.open('test.txt','w')[1,2,3 ].each(&out.method(:puts))# => prints 3 lines to filerequire'date'%w[2017-03-01 2017-03-02].collect(&Date.method(:parse))#=> [#<Date: 2017-03-01 ((2457814j,0s,0n),+0s,2299161j)>, #<Date: 2017-03-02 ((2457815j,0s,0n),+0s,2299161j)>]

                VALUErb_obj_method(VALUE obj, VALUE vid){    return obj_method(obj, vid, FALSE);}

Returns a list of the names of public and protected methods ofobj. This will include all the methods accessible inobj's ancestors. If the optional parameter isfalse, it returns an array ofobj's public andprotected singleton methods, the array will not include methods in modulesincluded inobj.

classKlassdefklass_method()endendk =Klass.newk.methods[0..9]#=> [:klass_method, :nil?, :===,#    :==~, :!, :eql?#    :hash, :<=>, :class, :singleton_class]k.methods.length#=> 56k.methods(false)#=> []defk.singleton_method;endk.methods(false)#=> [:singleton_method]moduleM123;defm123;endendk.extendM123k.methods(false)#=> [:singleton_method]

                VALUErb_obj_methods(int argc, const VALUE *argv, VALUE obj){    rb_check_arity(argc, 0, 1);    if (argc > 0 && !RTEST(argv[0])) {return rb_obj_singleton_methods(argc, argv, obj);    }    return class_instance_method_list(argc, argv, CLASS_OF(obj), 1, ins_methods_i);}

Only the objectnil respondstrue tonil?.

Object.new.nil?#=> falsenil.nil?#=> true

                MJIT_FUNC_EXPORTED VALUErb_false(VALUE obj){    return Qfalse;}

Returns an integer identifier forobj.

The same number will be returned on all calls toobject_id fora given object, and no two active objects will share an id.

Note: that some objects of builtin classes are reused for optimization.This is the case for immediate values and frozen string literals.

BasicObject implements +__id__+,Kernel implementsobject_id.

Immediate values are not passed by reference but are passed by value:nil,true,false, Fixnums, Symbols,and some Floats.

Object.new.object_id==Object.new.object_id# => false(21*2).object_id== (21*2).object_id# => true"hello".object_id=="hello".object_id# => false"hi".freeze.object_id=="hi".freeze.object_id# => true

                VALUErb_obj_id(VALUE obj){    /*     *                32-bit VALUE space     *          MSB ------------------------ LSB     *  false   00000000000000000000000000000000     *  true    00000000000000000000000000000010     *  nil     00000000000000000000000000000100     *  undef   00000000000000000000000000000110     *  symbol  ssssssssssssssssssssssss00001110     *  object  oooooooooooooooooooooooooooooo00        = 0 (mod sizeof(RVALUE))     *  fixnum  fffffffffffffffffffffffffffffff1     *     *                    object_id space     *                                       LSB     *  false   00000000000000000000000000000000     *  true    00000000000000000000000000000010     *  nil     00000000000000000000000000000100     *  undef   00000000000000000000000000000110     *  symbol   000SSSSSSSSSSSSSSSSSSSSSSSSSSS0        S...S % A = 4 (S...S = s...s * A + 4)     *  object   oooooooooooooooooooooooooooooo0        o...o % A = 0     *  fixnum  fffffffffffffffffffffffffffffff1        bignum if required     *     *  where A = sizeof(RVALUE)/4     *     *  sizeof(RVALUE) is     *  20 if 32-bit, double is 4-byte aligned     *  24 if 32-bit, double is 8-byte aligned     *  40 if 64-bit     */    return rb_find_object_id(obj, cached_object_id);}

Returns the list of private methods accessible toobj. If theall parameter is set tofalse, only those methods inthe receiver will be listed.

                VALUErb_obj_private_methods(int argc, const VALUE *argv, VALUE obj){    return class_instance_method_list(argc, argv, CLASS_OF(obj), 1, ins_methods_priv_i);}

Returns the list of protected methods accessible toobj. If theall parameter is set tofalse, only those methods inthe receiver will be listed.

                VALUErb_obj_protected_methods(int argc, const VALUE *argv, VALUE obj){    return class_instance_method_list(argc, argv, CLASS_OF(obj), 1, ins_methods_prot_i);}

Similar tomethod, searches public method only.

                VALUErb_obj_public_method(VALUE obj, VALUE vid){    return obj_method(obj, vid, TRUE);}

Returns the list of public methods accessible toobj. If theall parameter is set tofalse, only those methods inthe receiver will be listed.

                VALUErb_obj_public_methods(int argc, const VALUE *argv, VALUE obj){    return class_instance_method_list(argc, argv, CLASS_OF(obj), 1, ins_methods_pub_i);}

Invokes the method identified bysymbol, passing it any argumentsspecified. Unlike send,#public_send calls publicmethods only. When the method is identified by a string, the string isconverted to a symbol.

1.public_send(:puts,"hello")# causes NoMethodError

                static VALUErb_f_public_send(int argc, VALUE *argv, VALUE recv){    return send_internal_kw(argc, argv, recv, CALL_PUBLIC);}

Removes the named instance variable fromobj, returning thatvariable's value.String arguments areconverted to symbols.

classDummyattr_reader :vardefinitialize@var =99enddefremoveremove_instance_variable(:@var)endendd =Dummy.newd.var#=> 99d.remove#=> 99d.var#=> nil

                VALUErb_obj_remove_instance_variable(VALUE obj, VALUE name){    VALUE val = Qnil;    const ID id = id_for_var(obj, name, an, instance);    st_data_t n, v;    struct st_table *iv_index_tbl;    uint32_t index;    rb_check_frozen(obj);    if (!id) {goto not_defined;    }    switch (BUILTIN_TYPE(obj)) {      case T_OBJECT:        iv_index_tbl = ROBJECT_IV_INDEX_TBL(obj);        if (iv_index_tbl_lookup(iv_index_tbl, id, &index) &&            index < ROBJECT_NUMIV(obj) &&            (val = ROBJECT_IVPTR(obj)[index]) != Qundef) {            ROBJECT_IVPTR(obj)[index] = Qundef;            return val;        }break;      case T_CLASS:      case T_MODULE:        IVAR_ACCESSOR_SHOULD_BE_MAIN_RACTOR(id);n = id;if (RCLASS_IV_TBL(obj) && st_delete(RCLASS_IV_TBL(obj), &n, &v)) {    return (VALUE)v;}break;      default:if (FL_TEST(obj, FL_EXIVAR)) {    if (generic_ivar_remove(obj, id, &val)) {return val;    }}break;    }  not_defined:    rb_name_err_raise("instance variable %1$s not defined",      obj, name);    UNREACHABLE_RETURN(Qnil);}

Returnstrue ifobj responds to the given method. Private and protected methods are included in the search only if theoptional second parameter evaluates totrue.

If the method is not implemented, asProcess.fork on Windows,File.lchmod on GNU/Linux, etc., falseis returned.

If the method is not defined,respond_to_missing? method iscalled and the result is returned.

When the method name parameter is given as a string, the string isconverted to a symbol.

                static VALUEobj_respond_to(int argc, VALUE *argv, VALUE obj){    VALUE mid, priv;    ID id;    rb_execution_context_t *ec = GET_EC();    rb_scan_args(argc, argv, "11", &mid, &priv);    if (!(id = rb_check_id(&mid))) {        VALUE ret = basic_obj_respond_to_missing(ec, CLASS_OF(obj), obj,                                                 rb_to_symbol(mid), priv);        if (ret == Qundef) ret = Qfalse;        return ret;    }    if (basic_obj_respond_to(ec, CLASS_OF(obj), obj, id, !RTEST(priv)))        return Qtrue;    return Qfalse;}

DO NOT USE THIS DIRECTLY.

Hook method to return whether theobj can respond toidmethod or not.

When the method name parameter is given as a string, the string isconverted to a symbol.

Seerespond_to?, and theexample ofBasicObject.

                static VALUEobj_respond_to_missing(VALUE obj, VALUE mid, VALUE priv){    return Qfalse;}

Invokes the method identified bysymbol, passing it any argumentsspecified. When the method is identified by a string, the string isconverted to a symbol.

BasicObject implements +__send__+,Kernel implementssend.__send__ is safer thansend whenobj hasthe same method name likeSocket. See alsopublic_send.

classKlassdefhello(*args)"Hello "+args.join(' ')endendk =Klass.newk.send :hello,"gentle","readers"#=> "Hello gentle readers"

                VALUErb_f_send(int argc, VALUE *argv, VALUE recv){    return send_internal_kw(argc, argv, recv, CALL_FCALL);}

Returns the singleton class ofobj. This method creates a newsingleton class ifobj does not have one.

Ifobj isnil,true, orfalse, it returnsNilClass,TrueClass, orFalseClass, respectively. Ifobj is anInteger, aFloat or aSymbol, it raises aTypeError.

Object.new.singleton_class#=> #<Class:#<Object:0xb7ce1e24>>String.singleton_class#=> #<Class:String>nil.singleton_class#=> NilClass

                static VALUErb_obj_singleton_class(VALUE obj){    return rb_singleton_class(obj);}

Similar tomethod, searches singleton method only.

classDemodefinitialize(n)@iv =nenddefhello()"Hello, @iv = #{@iv}"endendk =Demo.new(99)defk.hi"Hi, @iv = #{@iv}"endm =k.singleton_method(:hi)m.call#=> "Hi, @iv = 99"m =k.singleton_method(:hello)#=> NameError

                VALUErb_obj_singleton_method(VALUE obj, VALUE vid){    VALUE klass = rb_singleton_class_get(obj);    ID id = rb_check_id(&vid);    if (NIL_P(klass)) {        /* goto undef; */    }    else if (NIL_P(klass = RCLASS_ORIGIN(klass))) {        /* goto undef; */    }    else if (! id) {        VALUE m = mnew_missing_by_name(klass, obj, &vid, FALSE, rb_cMethod);        if (m) return m;        /* else goto undef; */    }    else {        const rb_method_entry_t *me = rb_method_entry_at(klass, id);        vid = ID2SYM(id);        if (UNDEFINED_METHOD_ENTRY_P(me)) {            /* goto undef; */        }        else if (UNDEFINED_REFINED_METHOD_P(me->def)) {            /* goto undef; */        }        else {            return mnew_from_me(me, klass, klass, obj, id, rb_cMethod, FALSE);        }    }  /* undef: */    rb_name_err_raise("undefined singleton method `%1$s' for `%2$s'",                      obj, vid);    UNREACHABLE_RETURN(Qundef);}

Returns an array of the names of singleton methods forobj. If theoptionalall parameter is true, the list will include methods inmodules included inobj. Only public and protected singletonmethods are returned.

moduleOtherdefthree()endendclassSingledefSingle.four()endenda =Single.newdefa.one()endclass<<aincludeOtherdeftwo()endendSingle.singleton_methods#=> [:four]a.singleton_methods(false)#=> [:two, :one]a.singleton_methods#=> [:two, :one, :three]

                VALUErb_obj_singleton_methods(int argc, const VALUE *argv, VALUE obj){    VALUE ary, klass, origin;    struct method_entry_arg me_arg;    struct rb_id_table *mtbl;    int recur = TRUE;    if (rb_check_arity(argc, 0, 1)) recur = RTEST(argv[0]);    if (RB_TYPE_P(obj, T_CLASS) && FL_TEST(obj, FL_SINGLETON)) {        rb_singleton_class(obj);    }    klass = CLASS_OF(obj);    origin = RCLASS_ORIGIN(klass);    me_arg.list = st_init_numtable();    me_arg.recur = recur;    if (klass && FL_TEST(klass, FL_SINGLETON)) {if ((mtbl = RCLASS_M_TBL(origin)) != 0) rb_id_table_foreach(mtbl, method_entry_i, &me_arg);klass = RCLASS_SUPER(klass);    }    if (recur) {while (klass && (FL_TEST(klass, FL_SINGLETON) || RB_TYPE_P(klass, T_ICLASS))) {    if (klass != origin && (mtbl = RCLASS_M_TBL(klass)) != 0) rb_id_table_foreach(mtbl, method_entry_i, &me_arg);    klass = RCLASS_SUPER(klass);}    }    ary = rb_ary_new2(me_arg.list->num_entries);    st_foreach(me_arg.list, ins_methods_i, ary);    st_free_table(me_arg.list);    return ary;}

Returns object. This method is deprecated and will be removed in Ruby 3.2.

                VALUErb_obj_taint(VALUE obj){    rb_warn_deprecated_to_remove("Object#taint", "3.2");    return obj;}

Returns false. This method is deprecated and will be removed in Ruby 3.2.

                VALUErb_obj_tainted(VALUE obj){    rb_warn_deprecated_to_remove("Object#tainted?", "3.2");    return Qfalse;}

Creates a newEnumerator which will enumerateby callingmethod onobj, passingargs if any. What wasyielded by method becomesvalues of enumerator.

If a block is given, it will be used to calculate the size of theenumerator without the need to iterate it (seeEnumerator#size).

Examples¶↑

str ="xyz"enum =str.enum_for(:each_byte)enum.each {|b|putsb }# => 120# => 121# => 122# protect an array from being modified by some_methoda = [1,2,3]some_method(a.to_enum)# String#split in block form is more memory-effective:very_large_string.split("|") {|chunk|returnchunkifchunk.include?('DATE') }# This could be rewritten more idiomatically with to_enum:very_large_string.to_enum(:split,"|").lazy.grep(/DATE/).first

It is typical to call#to_enumwhen defining methods for a genericEnumerable, in case no block is passed.

Here is such an example, with parameter passing and a sizing block:

moduleEnumerable# a generic method to repeat the values of any enumerabledefrepeat(n)raiseArgumentError,"#{n} is negative!"ifn<0unlessblock_given?returnto_enum(__method__,n)do# __method__ is :repeat heresz =size# Call size and multiply by n...sz*nifsz# but return nil if size itself is nilendendeachdo|*val|n.times {yield*val }endendend%[helloworld].repeat(2) {|w|putsw }# => Prints 'hello', 'hello', 'world', 'world'enum = (1..14).repeat(3)# => returns an Enumerator when called without a blockenum.first(4)# => [1, 1, 1, 2]enum.size# => 42

                static VALUEobj_to_enum(int argc, VALUE *argv, VALUE obj){    VALUE enumerator, meth = sym_each;    if (argc > 0) {        --argc;        meth = *argv++;    }    enumerator = rb_enumeratorize_with_size(obj, meth, argc, argv, 0);    if (rb_block_given_p()) {        enumerator_ptr(enumerator)->size = rb_block_proc();    }    return enumerator;}

Returns a string representingobj. The defaultto_s prints the object's class andan encoding of the object id. As a special case, the top-level object thatis the initial execution context of Ruby programs returns “main''.

                VALUErb_any_to_s(VALUE obj){    VALUE str;    VALUE cname = rb_class_name(CLASS_OF(obj));    str = rb_sprintf("#<%"PRIsVALUE":%p>", cname, (void*)obj);    return str;}

Returns object. This method is deprecated and will be removed in Ruby 3.2.

                VALUErb_obj_trust(VALUE obj){    rb_warn_deprecated_to_remove("Object#trust", "3.2");    return obj;}

Returns object. This method is deprecated and will be removed in Ruby 3.2.

                VALUErb_obj_untaint(VALUE obj){    rb_warn_deprecated_to_remove("Object#untaint", "3.2");    return obj;}

Returns object. This method is deprecated and will be removed in Ruby 3.2.

                VALUErb_obj_untrust(VALUE obj){    rb_warn_deprecated_to_remove("Object#untrust", "3.2");    return obj;}

Returns false. This method is deprecated and will be removed in Ruby 3.2.

                VALUErb_obj_untrusted(VALUE obj){    rb_warn_deprecated_to_remove("Object#untrusted?", "3.2");    return Qfalse;}