sobrecarga de un operador a través de una mixin

Question

¿Hay alguna manera de anular el operador de una clase, creando un nuevo método de operador dentro de un módulo, y luego mezclando ese módulo en la clase?

por ejemplo, esto anula operador + de Fixnum:

class Fixnum 
    def +(x) 
    product = x 
    product = product * self 
    return product 
    end 
end 

p 3 + 3 

# => 9 

Esto no anula operador + de Fixnum:

module NewOperators 
    def +(x) 
    product = x 
    product = product * self 
    return product 
    end 
end 

class Fixnum 
    include NewOperators 
end 

p 3 + 3 

# => 6 

Answer 1

Su pregunta me llevó a este interesante artículo que describe el problema:

Fixing Ruby’s Inheritance Model with Metamorph

Este es el problema final con el modelo de herencia de Ruby, en mi opinión. Debido a que las mixinas siempre tienen menor prioridad que los métodos definidos directamente en un cuerpo de clase, A # foo no puede ser anulado por la inclusión de mixin. Por otra parte, debido a mixins tienen menor prioridad que los métodos, A # foo está violando la encapsulación [...]

Y su solución es definir de forma transparente todos los nuevos métodos en el interior de un módulo interna anónima:

class Object 
    def self.method_added(name) 
    return if name == :initialize 
    const_set(:InstanceMethods, Module.new) unless defined?(self::InstanceMethods) 
    meth = instance_method(name) 
    self::InstanceMethods.send(:define_method, name) {|*args, &block| meth.bind(self).call(*args, &block) } 
    remove_method(name) 
    include self::InstanceMethods 
    end 
end 

Esto también está convenientemente empaquetado en una biblioteca llamada metamorph, que le permite tener métodos mixin que reemplazan los métodos de clase simplemente solicitándolo.

Answer 2

No, porque en una búsqueda de método no tiene la oportunidad de extraer los métodos que se definieron en mixins o clases principales hasta que realmente haya mirado la clase actual.

Dicho esto, puede crear un método que, cuando se llame a una clase, cree métodos en esa clase. Esto puede darle una forma de inyectar operadores en las clases fácilmente.

Tenga en cuenta que hacerlo es una buena receta para la sorpresa. Esto es doblemente cierto cuando se cambian los módulos estándar cuyo comportamiento confían otros. Ver http://avdi.org/devblog/2008/02/23/why-monkeypatching-is-destroying-ruby/ para el contexto.