Creating and adding new methods in runtime

[konryd]

Hello, I need to add in runtime several methods to my class. How can I
accomplish this in ruby?
More precisely: I need my class to overload arithmetic operators with
fixnums in both ways (4+MyClass, MyClass+4). All the necessary info is
stored in a hash, so I created a method to do all the stuff. It looks
like do_operation(operator, other)
But still I have to add every single operator overloader:
class Fixnum

def doo_operation(operator, other)
#...nevermind...
end

def +(other)
do_operation+, other)
end
def -(other)
do_operation-, other)
end
end

can I automate it somehow?

 

[Marcin Mielżyński]

Hello, I need to add in runtime several methods to my class. How can I
accomplish this in ruby?
More precisely: I need my class to overload arithmetic operators with
fixnums in both ways (4+MyClass, MyClass+4). All the necessary info is
stored in a hash, so I created a method to do all the stuff. It looks
like do_operation(operator, other)
But still I have to add every single operator overloader:
class Fixnum

def doo_operation(operator, other)
#...nevermind...
end

def +(other)
do_operation+, other)
end
def -(other)
do_operation-, other)
end
end

can I automate it somehow?

the simplest case someone might come up with is:

module Operators

def operation operator, other
puts "operator #{operator} with argument #{other} called"
end

OPERATORS = [:+,:-,:/,:*]

def self.included mod
mod.instance_eval do
OPERATORS.each do |op|
begin
instance_method(op)
alias_method"_#{op}", op)
rescue
# swallow NameError here
end

define_method op do |other|
# here you might want to check for 'other' class to
preserve Numeric/Enumerable behaviour
operation op, other
end
end
end
end

end

class Fixnum
include Operators
end

1 + 2
1.send :"_+" ,2 # original

class A
include Operators
end

A.new + A.new


lopex

 

[Ken Bloom]

Hello, I need to add in runtime several methods to my class. How can I
accomplish this in ruby?
More precisely: I need my class to overload arithmetic operators with
fixnums in both ways (4+MyClass, MyClass+4). All the necessary info is
stored in a hash, so I created a method to do all the stuff. It looks
like do_operation(operator, other)
But still I have to add every single operator overloader: class Fixnum

def doo_operation(operator, other)
#...nevermind...
end

def +(other)
do_operation+, other)
end
def -(other)
do_operation-, other)
end
end

can I automate it somehow?

Just overrode MyClass#coerce, and the numeric operators on other classes
will call coerce if they can't identify the class you're trying to
perform arithmetic. Make sure there are +,-, etc... operators on MyClass,
and make sure that they
(a) handle built-in numeric types
(b) handle MyClass+MyClass
(c) call coerce if they don't recognize the class on the right-hand side

There's more discussion of #coerce in PickAxe.

--Ken