Ruby 'pass by value' clarification

Question

Okay, so Ruby is 'pass by value'. But how do you exactly define 'pass by reference' and 'pass by value' in Ruby? I've used this answer What's the difference between passing by reference vs. passing by value? and according to it, Ruby seems to be, well, a hybrid...

Technically, Ruby seems to be 'pass by value' with the difference that the value doesn't get COPIED when you pass it to a method. If we define "value" = the object, and "reference" = the reference variable that points to that object, will "pass by reference" makes sense if it's equivalent to "pass the reference variable that points to a specific object"? And then, once the "reference" is passed, the method doesn't make a COPY of the object, but actually has the ORIGINAL object itself (referenced by the variable) which can manipulate directly. Correct me if I'm wrong.

EDIT: I am AWARE of this question Is Ruby pass by reference or by value? but different people seem to have different definitions of pass by reference/value there.

Answer 1

Ruby is pass-by-value, just like C, Java, Python, Smalltalk, ECMAScript and many others. C++ and C# are also pass-by-value by default, you have to use special annotations (& in C++, ref in C#), to use pass-by-reference.

The distinction is actually rather simple: if the the reference is passed, then the callee can modify it, otherwise it can't. In Ruby, the callee cannot modify the reference, ergo it is pass-by-value:

def is_ruby_pass_by_value?(foo)
  foo = 'No, Ruby is pass-by-reference.'
  return nil
end

bar = 'Yes, of course, Ruby *is* pass-by-value!'

is_ruby_pass_by_value?(bar)

p bar
# 'Yes, of course, Ruby *is* pass-by-value!'

As you can see, within the method is_ruby_pass_by_value?, the reference bar/foo is not being passed, otherwise the modification would be visible afterwards. bar is being passed by-value, i.e. the content of bar (the value contained in it) is being passed and not the reference itself.

Now, what is the value that is being passed? It is not the String object. Rather it is a pointer to that String object. More precisely: a copy of that pointer.

Now, there are two pointers to that String object. And that String object is mutable! So, if I follow one pointer (foo) and tell that String object to change itself, and then I follow the other pointer (bar) and ask it about its contents, then I will obviously see the changed contents. That's just the nature of shared mutable state, Ruby is not a purely functional, referentially transparent language:

def is_ruby_pass_by_value?(foo)
  foo.replace('More precisely, it is call-by-object-sharing!')
  foo = 'No, Ruby is pass-by-reference.'
  return nil
end

bar = 'Yes, of course, Ruby *is* pass-by-value!'

is_ruby_pass_by_value?(bar)

p bar
# 'More precisely, it is call-by-object-sharing!'

In fact, in Ruby, the value being held by variables and being passed as arguments is always a pointer. That's how almost all object-oriented languages work. Barbara Liskov called this special case of pass-by-value "call-by-object-sharing", it is also sometimes called "call-by-sharing" or "call-by-object".

Note, however, that the fact that the value being passed is a pointer, is completely irrelevant. Pass-by-value vs. pass-by-reference is about how arguments are being passed, not what the argument is. C is always pass-by-value, regardless of whether you are passing an int or a pointer. Pointers are still being passed by value. Likewise in Ruby, pointers are being passed by value. The differences between Ruby and C are a) that you can only pass pointers in Ruby, and b) that there is no special syntax indicating that you are passing a pointer.

[Note: most Ruby implementations will actually have optimizations in place for passing objects which are smaller than a pointer directly instead of passing a pointer to that object. However, they only do that for objects which are guaranteed by the language specification to be deeply immutable, so that it is impossible to observe the difference between passing a pointer to the value and passing the value directly. This is done, for example, for Fixnums, Symbols, Floats, nil, true and false.]

Here is an example in C#, that demonstrates the difference between pass-by-value (even if that value is a reference) and pass-by-reference:

class Program
{
    static void IsCSharpPassByValue(string[] foo, ref string baz)
    {
        foo[0] = "More precisely, for reference types it is call-by-object-sharing, which is a special case of pass-by-value.";
        foo = new string[] { "C# is not pass-by-reference." };

        baz = "It also supports pass-by-reference if explicitly requested.";
    }

    static void Main(string[] args)
    {
        var quux = new string[] { "Yes, of course, C# *is* pass-by-value!" };

        var grault = "This string will vanish because of pass-by-reference.";

        IsCSharpPassByValue(quux, ref grault);

        Console.WriteLine(quux[0]);
        // More precisely, for reference types it is call-by-object-sharing, which is a special case of pass-by-value.

        Console.WriteLine(grault);
        // It also supports pass-by-reference if explicitly requested.
    }
}

Answer 2

You can go purist on this and say ruby is a special case of "pass by the value of the reference" but it misses the point. Just think of everything in ruby being an object

foo(14) passes a reference to an integer object with a value of 14. There's some stuff that goes on under the covers, so you don't end up with 100's of 14 objects, but from an intent point of view most of the time you can just forget the concept.

Answer 3

Ruby is "pass by reference". The difference is as follows: If you pass by reference, you can do bad things to the original object:

x = [ "virgin" ]

def do_bad_things_to( arg )
  arg.clear << "bad things"
end

do_bad_things_to( x )

If you pass by value, you get the value of the original object and can work with it, but you cannot do bad things to the original object. You consume more memory, as the copy of the the original object's value also takes memory:

def pass_by_value( arg )
  arg.dup
end

y = [ "virgin" ]

do_bad_things_to( pass_by_value( y ) )

p x #=> [ "bad things" ]
p y #=> [ "virgin" ]

To immutable objects (numbers, symbols, true, false, nil...), one cannot do bad things by the virtue of their immutability. It is oft said, that in Ruby, they are passed by value, but in fact, the distinction makes little sense for them, just as it makes little sense to keep many copies of their internals in the memory.

UPDATE: There seems to be terminological contention as to what 'reference' means. In Ruby, Jörg Mittag's "pass by reference" is explicitly achieved by closures that close over local variables:

baz = "Jörg"
define_method :pass_by_Jorgs_reference_to_baz do baz = "Boris" end
pass_by_Jorgs_reference_to_baz
baz #=> "Boris"