why doesn't "to_s" DWIM?

[Chris McMahon]

How come to_s doesn't work here?

####################################
require 'test/unit'
class TOY_CASE<Test::Unit::TestCase

def test_toy_test

aoa = [[1,2,3],[4,5,6]]

aoa.each do |arr|
arr.each do |item|
item = item.to_s
end
assert_equal(["1","2","3"],arr)
end


end #def
end #class
##########################################

 

[dblack]

Hi --

How come to_s doesn't work here?

####################################
require 'test/unit'
class TOY_CASE<Test::Unit::TestCase

def test_toy_test

aoa = [[1,2,3],[4,5,6]]

aoa.each do |arr|
arr.each do |item|
item = item.to_s
end
assert_equal(["1","2","3"],arr)
end


end #def
end #class
##########################################

Inside the inner each block, you're just doing a local (re)assignment
to "item". There's no connection to the object that used to be in
item, except that that object happens to be part of the rhs.

You can achieve what you want with this:

aaa.each do |arr|
arr.map! do |item|
item.to_s
end
end

That will go through each inner array and replace the current item
with what's in the block (namely, item.to_s).


David

--
David A. Black ([email protected])
Ruby Power and Light, LLC (http://www.rubypowerandlight.com)

"Ruby for Rails" chapters now available
from Manning Early Access Program! http://www.manning.com/books/black

 

[Farrel Lifson]

You might want to look at Array#map

arr.map do |item|
item.to_s
end

 

[Ross Bamford]

How come to_s doesn't work here?

####################################
require 'test/unit'
class TOY_CASE<Test::Unit::TestCase

def test_toy_test

aoa = [[1,2,3],[4,5,6]]

aoa.each do |arr|
arr.each do |item|
item = item.to_s
end
assert_equal(["1","2","3"],arr)
end


end #def
end #class
##########################################

Each just iterates the items, and the 'items' argument to the block is a
new local variable - changing it has no lasting effect. Try map instead
(here I use map! to change this array, rather than creating a new one):

##########################################
require 'test/unit'
class TOY_CASE<Test::Unit::TestCase

def test_toy_test

aoa = [[1,2,3],[4,5,6]]

aoa.each do |arr|
arr.map! do |item|
item.to_s
end
end

assert_equal [["1","2","3"],["4","5","6"]], aoa
end #def
end #class
##########################################

Notice too I changed the way your assertion works, since it would fail
on the second array if tested against ["1","2","3"].

 

[Peter Hickman]

I'm not really sure what you are expecting to happen here. aoa.each will
product two results, first [1,2,3] and then [4,5,6]. And you expect the
assert_equal to pass both times?

 

[Chris McMahon]

Thanks, I knew it had to be something like that.

 

[benny]

aoa = [[1,2,3],[4,5,6]]

aoa.each do |arr|
arr.each do |item|
item = item.to_s
end
assert_equal(["1","2","3"],arr)
end


end #def
end #class
##########################################

Each just iterates the items, and the 'items' argument to the block is a
new local variable - changing it has no lasting effect.

but remember:

a = ["haha", "hihi", "hoho"]
a.each { |i| i.gsub!("h", "l") }
p a

and even

a = ["2","3", "4"]
a.each { |i| i.replace("#{i} times") }
p a

in fact variables only point to the objects. so you might use them to modify
the object they are currently pointing to. if you got strings, you may
modify them (instead of creating new ones). but unfortunately that won't
work for numbers, since they are no real objects, but - how do we call
them? - first level objects?

benny

Try map instead
(here I use map! to change this array, rather than creating a new one):

##########################################
require 'test/unit'
class TOY_CASE<Test::Unit::TestCase

def test_toy_test

aoa = [[1,2,3],[4,5,6]]

aoa.each do |arr|
arr.map! do |item|
item.to_s
end
end

assert_equal [["1","2","3"],["4","5","6"]], aoa
end #def
end #class
##########################################

Notice too I changed the way your assertion works, since it would fail
on the second array if tested against ["1","2","3"].

 

[benny]

a = ["2","3", "4"]
a.each { |i| i.replace("#{i} times") }
p a

in fact variables only point to the objects. so you might use them to
modify the object they are currently pointing to. if you got strings, you
may modify them (instead of creating new ones). but unfortunately that
won't
work for numbers, since they are no real objects, but - how do we call
them? - first level objects?

so this would work also:

aoa = [[1,2,3],[4,5,6]]

aoa.each do |arr|
arr.each_index do |i|
arr = arr.to_s
end
end

p aoa

 

[Ross Bamford]

aoa = [[1,2,3],[4,5,6]]

aoa.each do |arr|
arr.each do |item|
item = item.to_s
end
assert_equal(["1","2","3"],arr)
end


end #def
end #class
##########################################

Each just iterates the items, and the 'items' argument to the block is a
new local variable - changing it has no lasting effect.

but remember:

a = ["haha", "hihi", "hoho"]
a.each { |i| i.gsub!("h", "l") }
p a

and even

a = ["2","3", "4"]
a.each { |i| i.replace("#{i} times") }
p a

in fact variables only point to the objects. so you might use them to modify
the object they are currently pointing to. if you got strings, you may
modify them (instead of creating new ones). but unfortunately that won't
work for numbers, since they are no real objects, but - how do we call
them? - first level objects?

True, this is why the updated code I and others posted mostly retained
the outer 'each', and used map! on each inner array.

I think the term for Fixnums, nil, true and false is 'immediate values'.