In Ruby, how does coerce() actually work?

[winterheat]

It is said that when we have a class Point and knows how to perform
point * 3 like the following:

class Point

  def initialize(x,y)
    @x, @y = x, y
  end

  def *(c)
    Point.new(@x * c, @y * c)
  end

end

point = Point.new(1,2)
p point
p point * 3

Output:

#<Point:0x336094 @x=1, @y=2>
#<Point:0x335fa4 @x=3, @y=6>

but then,

3 * point

is not understood:

Point can't be coerced into Fixnum (TypeError)

So we need to further define an instance method coerce:

class Point
  def coerce(something)
    [self, something]
  end
end

p 3 * point

Output:

#<Point:0x3c45a88 @x=3, @y=6>

So it is said that

3 * point

is the same as

3.*(point)

that is, the instance method * takes an argument point and invoke on
the object 3.

Now, since this method * doesn’t know how to multiply a point, so

point.coerce(3)

will be called, and get back an array:

[point, 3]

and then * is once again applied to it, is that true?

point * 3

which is the same as

point.*(3)

and now, this is understood and we now have a new Point object, as
performed by the instance method * of the Point class.

The question is:

1. who invokes point.coerce(3) ? Is it Ruby automatically, or is it
   some code inside of * method of Fixnum by catching an exception? Or
   is it by case statement that when it doesn’t know one of the known
   types, then call coerce?

2. Does coerce always need to return an array of 2 elements? Can it be
   no array? Or can it be an array of 3 elements?

3. And is the rule that, the original operator (or method) * will then
   be invoked on element 0, with the argument of element 1? (element 0 and
   element 1 are the two elements in that array returned by coerce) Who
   does it? Is it done by Ruby or is it done by code in Fixnum? If it is
   done by code in Fixnum, then it is a “convention” that everybody follows
   when doing a coerce?

So could it be the code in * of Fixnum doing something like this:

class Fixnum

  def *(something)
  if (something.is_a? ...)
  else if ...  # other type / class
  else if ...  # other type / class
  else
  # it is not a type / class I know
    array = something.coerce(self)
    return array[0].*(array[1])   # or just return array[0] *

array[1]
end
end

end

4. So it is really hard to add something to Fixnum’s instance method
   coerce? It already has a lot of code in it and we can’t just add a
   few lines to enhance it (but will we ever want to?)

5. The coerce() in the Point class is quite generic and it works with
   * or + because they are transitive. What if it is not transitive,
   such as if we define Point minus Fixnum to be:

   point = Point.new(100,100)
   point - 20 # ==> to give (80,80)
   80 - point # ==> to give (-80,-80)

[winterheat]

2010/5/10 Jian L. [email protected]:

   Point.new(@x * c, @y * c)

#<Point:0x336094 @x=1, @y=2>
So we need to further define an instance method coerce:

class Point
def coerce(something)
[self, something]
end
end

There is no type checking and conversion. Normally you would also
return the argument first but in this case exchanging the order seems
OK since the multiplication is not really symmetric.

The std lib does it like this:

irb(main):001:0> 1.2.coerce 3
=> [3.0, 1.2]
irb(main):002:0>

Please see my blog post for a complete example:
http://blog.rubybestpractices.com/posts/rklemme/019-Complete_Numeric_Class.html

The question is:

1. who invokes point.coerce(3) ? Is it Ruby automatically, or is it
   some code inside of * method of Fixnum by catching an exception? Or
   is it by case statement that when it doesn’t know one of the known
   types, then call coerce?

The latter.

2. Does coerce always need to return an array of 2 elements? Can it be
   no array? Or can it be an array of 3 elements?

It always needs to return an array of two elements - that’s the
contract.

3. And is the rule that, the original operator (or method) * will then
   be invoked on element 0, with the argument of element 1? (element 0 and
   element 1 are the two elements in that array returned by coerce)

Exactly.

Who does it? Is it done by Ruby or is it done by code in Fixnum?

The latter.

If it is
done by code in Fixnum, then it is a “convention” that everybody follows
when doing a coerce?

I’d rather say it’s the contract of #coerce but you can call it a
“convention” as well.

4. So it is really hard to add something to Fixnum’s instance method
   coerce? It already has a lot of code in it and we can’t just add a
   few lines to enhance it (but will we ever want to?)

You do not need to add to Fixnum’s coerce. Rather you add to your
operator implementation.

5. The coerce() in the Point class is quite generic and it works with
   * or + because they are transitive. What if it is not transitive,
   such as if we define Point minus Fixnum to be:

   point = Point.new(100,100)
   point - 20 # ==> to give (80,80)
   80 - point # ==> to give (-80,-80)

I think you confused “transitive” and “commutative”.

Commutative property

Transitive relation

Commutativity is the exact reason for having #coerce. Please see the
blog post.

Kind regards

robert