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 do something like this:
if (something.typeof? ...)
else if ... # other type
else if ... # other type
else
# if it is not a type I know
array = something.coerce(self)
return array[0].*(array[1])
end
