＃{}总是等同于to_s吗？

Question

In " What does it mean to use the name of a class for string interpolation? ", Candide suggested that #{} inside a string implicitly calls to_s . So, for instance:

my_array = [1, 2, 3, 4]
p my_array.to_s # => "[1, 2, 3, 4]"
p "#{my_array}" # => "[1, 2, 3, 4]"

However, if to_s for Array is redefined as shown below, I would get different results:

class Array
  def to_s
    self.map { |elem| elem.to_s }
  end
end

p my_array.to_s # => ["1", "2", "3", "4"]
p "#{my_array}" # => "#<Array:0x007f74924c2bc0>"

I suppose this happens any time and anyhow to_s is overridden.

What am I supposed to do to keep the equality between to_s and the expression #{} in a string, if possible?

I came across this issue in a RubyMonk lesson : what according to the lesson # {ogres} should return, according to my experience is something different.

Answer 1

Please take a look at the documentation for Object#to_s . It says that to_s should return a String . When you override a method, you should always honor its contract. Take a look at the documentatio for Array#to_s As you can see, it also returns a String . [Note that this is true for all the to_X and the to_XYZ methods: they must always return an object of the corresponding class and they must not raise an Exception or otherwise fail.]

Your implementation of to_s , however, does not return a String . It returns an Array , thus violating to_s 's contract. Once you violate a method's contract, all bets are off. Personally, I think it would be more appropriate to raise a TypeError exception here, but Ruby is trying to be nice and returns some String instead, which (in this case) prints the class name and some unique identifier.

Here is the commit to the RubySpec project which (implicitly) states that no Exception is raise d and explicitly states that an implementation-defined but otherwise unspecified String is returned: The spec for interpolation when Object#to_s did not return a String was confusing the default representation of an arbitrary object and Object#inspect .

The latest version of the spec, before the project was closed looks like this language/string_spec.rb#L197-L208 :

 it "uses an internal representation when #to_s doesn't return a String" do obj = mock('to_s') obj.stub!(:to_s).and_return(42) # See rubyspec commit 787c132d by yugui. There is value in # ensuring that this behavior works. So rather than removing # this spec completely, the only thing that can be asserted # is that if you interpolate an object that fails to return # a String, you will still get a String and not raise an # exception. "#{obj}".should be_an_instance_of(String) end 

As you can see, all that is guaranteed in this case, is that you won't get an Exception , and that you will get a String , however, it says nothing about what that String looks like.

Answer 2

Look at what Ruby is telling you:

"#{my_array}" # => "#<Array:0x007f74924c2bc0>"

That means Ruby is seeing an array returned by your to_s method, not a string as Ruby expects and like it'd see if you hadn't overridden the original Array.to_s .

Instead use something like:

'[%s]' % self.map { |elem| elem.to_s }.join(', ')

Change your code to return a String and you'll be okay.

Consider this:

[].class # => Array
[].to_s.class # => String

class Array
  def to_s
    self.map { |elem| elem.to_s }
  end
end

[].to_s.class # => Array

class Array
  def to_s
    '[%s]' % self.map { |elem| elem.to_s }.join(', ')
  end
end

[].to_s.class # => String

my_array = [1, 2, 3, 4]
"#{my_array}" # => "[1, 2, 3, 4]"

In general practice, I'd recommend being cautious overriding core and STD-Lib classes' to_s as they're doing what they should. For custom classes it's a good idea to implement to_s mimicking the same output as the core classes. Occasionally we'll have to get fancy and offer more detailed views into what an instance of an object looks like, but that's when we override inspect .

Answer 3

Your definition of Array#to_s returns an array, on which to_s would need to be further applied. This would result in infinite recursion. I suspect Ruby has internal implementation to cut off such infinite recursion in case of "#{my_array}" . For p my_array.to_s , my_array.to_s is an array, and p applies Array#inspect , which does not result in infinite recursion.