If everything is an object, why can't I swap two variables?

Question

I have this simple test:

def swap(a, b)
   c = a
   a = b
   b = c
end

a = 3
b = 4
swap(a, b)
print a # 3. not change value

I know this example will not work on some languages such as Java or C# because those variables are primitives. But in Ruby, if everything is an object, I think the above example should work. Please explain this to me.

---

I think the problem is because FixNum is immutable. I have proof-of-concept code using Java to make an integer class that is not immutable:

static class CustomInteger {
        Integer value;
        public CustomInteger(int i) {
            this.value = i;
        }

        public void changeValue(int i) {
            this.value = i;
        }

        public int getValue() {
            return value;
        }

        public CustomInteger setValueImmutable(int i) {
           return new CustomInteger(i);
        }
    }

    public static void swap(CustomInteger a, CustomInteger b) {
        int c = a.getValue();
        a.changeValue(b.getValue());
        b.changeValue(c);
    }

    public static void main(String[] args) {
        CustomInteger i1 = new CustomInteger(3);
        CustomInteger i2 = new CustomInteger(4);
        swap(i1, i2);
        System.out.println(i1.getValue());
    }

---

public static void notWorkSwap(Integer a, Integer b) {
        int temp_a = a;
        int temp_b = b;
        a = temp_b;
        b = temp_a;
    }

Answer 1

Your swap method only swaps variables that are local to the method.

Inside the method, a and b are swapped. This doesn't affect anything outside the method, though. c isn't defined outside swap for example.

Note that to swap a and b, you don't need any other variable : a, b = b, a is a valid Ruby syntax.

Finally, variables aren't objects. They merely reference objects.

Here's a way to achieve what you wanted to do. UPDATE: It's basically the equivalent of your Java code :

class MyObject
  attr_accessor :x
  def initialize(x)
    @x = x
  end
end

def swap(f,g)
  f.x, g.x = g.x, f.x
end

a = MyObject.new(1)
b = MyObject.new(2)

swap(a, b)

puts a.x
#=> 2
puts b.x
#=> 1

Note that the objects a and b haven't been swapped. Their x values have been swapped, though.

Another possibility would be to use instance variables :

def swap
  @a, @b = @b, @a
end

@a = 1
@b = 2

swap

p @a
#=> 2
p @b
#=> 1

Answer 2

The reason this doesn't work is that method parameters are passed by value, not by reference. Only a small number of languages use pass-by-reference semantics by default. The behavior is the same in Java and in Ruby.

However, it's just tricky enough that plenty of people misuse the terminology. See this question, for example. Is Java "pass-by-reference" or "pass-by-value"?

In many languages, such as C#, pass-by-reference is possible with a special keyword (ref in the case of C#, or the & marker after a type in C++). You can simulate the behavior in languages like C by passing indirect pointers (though that gives you a bit more power, thanks to less strict type checking).

I haven't written C# code in a couple years, but what you are trying to achieve would be approximately:

static void SwapStrings(ref string s1, ref string s2)
        {
            string temp = s1;
            s1 = s2;
            s2 = temp;
        } 

It would be invoked SwapStrings(ref str1, ref str2);

This code is an abbreviated version of what's here: https://msdn.microsoft.com/en-us/library/s6938f28.aspx