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
