Ruby Reference & Value pass by - ruby

Question

I know a lot of similar questions have been asked. I've read them, and still don't understand WHY my code does what it does. It s only for training, and I've implement a simple LinkedList (single link) and I wanted to implement the merge of two such sorted list. Here is the code
#!/usr/bin/ruby
#
module LinkedList
class Node
attr_accessor :next,:data
def to_s
s = #data.to_s + " -> "
s += #next.to_s if #next
s
end
end
end
def append tail, node
tail.next = node
tail = node
node = node.next
end
def merge_lists2 list1, list2
tail = LinkedList::Node.new
while(list1 && list2)
list1.data <= list2.data ? list1 = append(tail,list1) : list2 = append(tail,list2)
puts list1
puts list2
puts tail
puts "#######################################################"
STDIN.gets
end
if list1
tail.next = list1
elsif list2
tail.next = list2
end
tail.next
end
def generateList times = 3,factor = 1
list = LinkedList::Node.new
list.data = 0
curr = list
(1..times).each do |i|
curr.next = LinkedList::Node.new
curr = curr.next
curr.data = i*factor
end
list
end
def main
l1 = generateList 4,2
l2 = generateList 5,1.5
puts l1
puts l2
l3 = merge_lists2 l1,l2
puts l3
end
The code following is my "older" version :
def append tail, node
tail.next = node
tail = node
node = node.next
end
def merge_lists2 list1, list2
tail = LinkedList::Node.new
while(list1 && list2)
list1.data <= list2.data ? append(tail,list1) : append(tail,list2)
In the older version, it was running in a infinite loop because list1 and list2 were never updated, thus the while loop was always going on. They were never updated because of the list1 & list2 variable were assigned to different object in the append function, thus when returning from the function, list1 and list2 were "taking back" on their original reference.
But the "tail" reference is updated !! You can see it by running the code, you will see that tail is always the "tail" of the new merged list, and not the "head" of the new list. I dont understand why because tail is ALSO referenced to a new object in append, so when returning from the function, "tail" should still be the "head" (lol that's crazy )
Thank you ...

Answer 1

The problem with Ruby is it hides a lot of things from you. Objects are passed in as what appear to be references, but are actually pointers in a clever disguise. When you "de-reference" a pointer you get to manipulate the original data, not unlike a reference. Unlike C++ where this is made explicit, Ruby doesn't go out of its way to remind you this is the case.
So what this means is arguments to methods are simply variables that behave like pointers to objects. Changing them to other values does not affect the original. Calling methods on them or changing properties does affect the original, they've been de-referenced.
There's a lot of problems with your implementation here. For one, methods like append should be part of the Node class:
class Node
def append(list)
node = #data
while (node)
if (node.next)
node = node.next
else
node.next = list
return self
end
end
end
end
So long as you don't have a circular list, that should work. Notice that the list value is never modified, it's simply integrated.
Note that this append method works for both individual nodes (one element lists) and longer lists composed of multiple nodes. Generally in programming you try to avoid having exceptional cases to handle, so this minimizes the code you need to write and get working properly.