在 Ruby 中， coerce() 是如何工作的？

Question

据说当我们有一个类Point并且知道如何执行point * 3如下：

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

输出：

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

但是，

3 * point

不明白：

Point 不能被强制转换成Fixnum (TypeError)

所以我们需要进一步定义一个实例方法coerce：

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

p 3 * point

输出：

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

所以说3 * point和3.*(point)是一样的。也就是说，实例方法* 接受一个参数point 并在对象3 上调用。

现在，由于*这个方法不知道如何乘以一个点，所以

point.coerce(3)

将被调用，并取回一个数组：

[point, 3]

然后* 再次应用于它，是这样吗？

现在，这已被理解，我们现在有了一个新的Point 对象，由Point 类的实例方法* 执行。

问题是：

1. 谁调用了point.coerce(3)？是自动使用Ruby，还是通过捕获异常在Fixnum 的* 方法中的一些代码？还是通过case 声明，当它不知道其中一种已知类型时，调用coerce？

2. coerce 是否总是需要返回一个包含 2 个元素的数组？可以没有数组吗？还是可以是3个元素的数组？

3. 那么规则是，原始运算符（或方法）* 将在元素 0 上被调用，并带有元素 1 的参数？ （元素 0 和元素 1 是 coerce 返回的该数组中的两个元素。）谁做的？它是由 Ruby 完成的，还是由 Fixnum 中的代码完成的？如果是通过Fixnum中的代码来做的话，那么就是大家在做强制时都遵循的“约定”？

   那么可能是Fixnum 的* 中的代码做这样的事情：

   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. 那么在Fixnum的实例方法coerce上加点东西真的很难吗？它已经有很多代码，我们不能只添加几行来增强它（但我们会想要吗？）

5. Point 类中的coerce 非常通用，它可以与* 或+ 一起使用，因为它们是可传递的。如果它不具有传递性，比如我们将 Point 减去 Fixnum 定义为：

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

Answer 1

我发现自己在处理可交换性时经常按照这种模式编写代码：

class Foo
  def initiate(some_state)
     #...
  end
  def /(n)
   # code that handles Foo/n
  end

  def *(n)
    # code that handles Foo * n 
  end

  def coerce(n)
      [ReverseFoo.new(some_state),n]
  end

end

class ReverseFoo < Foo
  def /(n)
    # code that handles n/Foo
  end
  # * commutes, and can be inherited from Foo
end

Answer 2

简答：查看how Matrix is doing it。

这个想法是coerce 返回[equivalent_something, equivalent_self]，其中equivalent_something 是一个基本上等同于something 的对象，但它知道如何对Point 类进行操作。在Matrix 库中，我们从任何Numeric 对象构造一个Matrix::Scalar，并且该类知道如何对Matrix 和Vector 执行操作。

解决您的问题：

1. 是的，它直接是 Ruby（检查对 rb_num_coerce_bin in the source 的调用），尽管如果您希望您的代码可以被其他人扩展，您自己的类型也应该这样做。例如，如果您的Point#* 被传递了一个它无法识别的参数，您可以通过调用arg.coerce(self) 来将该参数传递给coerce 本身到Point。

2. 是的，它必须是一个包含 2 个元素的数组，例如 b_equiv, a_equiv = a.coerce(b)

3. 是的。 Ruby 对内置类型执行此操作，如果您想要可扩展，您也应该使用自己的自定义类型：

   def *(arg)
     if (arg is not recognized)
       self_equiv, arg_equiv = arg.coerce(self)
       self_equiv * arg_equiv
     end
   end
   

4. 这个想法是你不应该修改Fixnum#*。如果它不知道该怎么做，例如因为参数是 Point，那么它会通过调用 Point#coerce 来询问您。

5. 传递性（或实际上可交换性）不是必需的，因为始终以正确的顺序调用运算符。只有对coerce 的调用会暂时恢复接收到的参数。没有内置机制可以确保 +、== 等运算符的交换性......

如果有人能提出简洁、准确和清晰的描述来改进官方文档，请发表评论！