how does collect and struct work in ruby?

Question

Im currently going through a book and there is a pice of code that I don't quite understand:

class RevealingReferences
  attr_reader :wheels

  def initialize(data)
    @wheels = wheelify(data)
    puts data
  end

  def diameters
    wheels.collect do |wheel|
      puts "test"
      wheel.rim + (wheel.tire*2)
    end
  end

  Wheel = Struct.new(:rim, :tire)

  def wheelify(data)
    data.collect{|cell|
      Wheel.new(cell[0], cell[1])}
    end
  end
end

puts RevealingReferences.new([3,2,5,8]).diameters

and I get the following output:

3
2
5
8
test
test
test
test
3
2
1
0

1) Now the 3,2,5,8 I understand, but why does not display in array format [3,2,5,8] rather its being displayed one int at a time.

2) Also, in the wheels.collect block, the output prints "test" twice before putting in the output, should it not be "test" value "test" value

3) Also, the answer 3,2,1,0 don't make any sense, when I set @wheels should wheels not be a collection of an array of 2 elements rather then 4?

Answer 1

1) puts will output each argument on a new line, or if the argument is an array, each element of an array on a new line

2) puts "test" is running in the wheels.collect block, there are four Wheel objects created so it outputs four tests while creating the diameters array.

3) The real problem is what seems like a typo either in your book or the transfer of the code to your test environment. I think that last line was meant to read

puts RevealingReferences.new([[3,2],[5,8]]).diameters

Otherwise, the Wheel.new line

 Wheel.new(cell[0], cell[1])}

is calling FixNum#[] giving you the n-th bit of the integer. This was a bit of surprise to me too - it seems like a lot could go subtly wrong when accidentally supplying an integer instead of an Array.

With the original code, cell[0] and cell[1] evaluates as 3[0] and 3[1] for the first element of data. With the correction you have the array [3,2][0] => 3, and [3,2][1] => 2 which makes much more understandable code as a "collect" example.

Answer 2

1- collect is a iterator method that accepts a block of code.The collect iterator returns all the elements of a collection.

2- u haven't specified the value to be displayed. do "puts wheel.rim + (wheel.tire*2)".

3- if u print the 'wheel' in the collect block of diameters method, its

"#<struct RevealingReferences::Wheel rim=1, tire=1>"
"#<struct RevealingReferences::Wheel rim=0, tire=1>"
"#<struct RevealingReferences::Wheel rim=1, tire=0>"
"#<struct RevealingReferences::Wheel rim=0, tire=0>"

When the "wheel.rim + (wheel.tire*2)" statement is executed, the result is 3,2,1,0 and each result is returned. if the statement "puts wheel" is added in the collect block for diameter and the prog executed, u wont see the values (3,2,1,0) in the output.

Answer 3

1) Now the 3,2,5,8 I understand, but why does not display in array format [3,2,5,8] rather its being displayed one int at a time.

This is due to how puts works. When it sees an array, it prints the #to_s of each element

puts [1,2,3]
# >> 1
# >> 2
# >> 3

If you want it to look like an array, you should inspect it before printing it

puts [1,2,3].inspect
# >> [1, 2, 3]

There's also a shorthand for this, the method p

p [1,2,3]
# >> [1, 2, 3]

---

2) Also, in the wheels.collect block, the output prints "test" twice before putting in the output, should it not be "test" value "test" value

The only thing printing the values is the puts statement on the return value of diameters, so they won't print until after they have been collected. If you wanted to print it after each test, you should probably do something like

def diameters
  wheels.collect do |wheel|
    puts "test"
    p wheel.rim + (wheel.tire*2)
  end
end

Which would print:

test
3
test
2
test
1
test
0

---

3) Also, the answer 3,2,1,0 don't make any sense, when I set @wheels should wheels not be a collection of an array of 2 elements rather then 4?

Based on what you're saying here, I assume your data is not in the format you intended. You're passing in [3,2,5,8], but this implies that you meant to pass in [[3,2],[5,8]], or to map across every pair of values:

def wheelify(data)
  data.each_slice(2).collect do |cell|
    Wheel.new(cell[0], cell[1])
  end
end

The reason it isn't doing what you think is because without doing one of these, the cell variable is actually just a number. Since numbers have the brackets method defined on them, they wind up working in this case. But the brackets method just returns 1 or 0, depending on the bit (base 2) at that position:

five = 5
five.to_s(2) # => "101"
five[2] # => 1
five[1] # => 0
five[0] # => 1

So in the case of 3, wheel.rim + (wheel.tire*2) becomes

cell = 3
cell.to_s(2)   # => "11"
rim = cell[0]  # => 1
tire = cell[1] # => 1
rim + tire * 2 # => 3

And in the case of 2:

cell = 2
cell.to_s(2)   # => "10"
rim = cell[0]  # => 0
tire = cell[1] # => 1
rim + tire * 2 # => 2

And 5:

cell = 5
cell.to_s(2)   # => "101"
rim = cell[0]  # => 1
tire = cell[1] # => 0
rim + tire * 2 # => 1

And 8:

cell = 8
cell.to_s(2)   # => "1000"
rim = cell[0]  # => 0
tire = cell[1] # => 0
rim + tire * 2 # => 0

Which is why diameters returns [3, 2, 1, 0], explaining the last four digits you see.