[ruby-talk:4903] Trying to grasp possibilities of dynamical Ruby

Hi,

I have a class hierarchy and want to have a general way of combining
objects so that the combination is also in the hierarchy. Simplified
example:

class Func
  def f(x)
    x
  end
end
class SimpleFunc < Func
  def f(x)
    x+1
  end
end
class FancyFunc < Func
  def fancymethod
    # whatever...
  end
  def f(x)
    x**2
  end
end

# I want to be able to transform the f in one Func with the f in another.
# The transformed object should be of the same type as the first Func.
def transform_func(fo1, fo2)
  fo1.instance_eval( "alias _old_f f" )
  fo1.instance_eval( "@tf = fo2" )
  def fo1.f(x)
    @tf.f(_old_f(x))
  end
  fo1
end
my_func1 = transform_func( FancyFunc.new, SimpleFunc.new )
my_func2 = transform_func( SimpleFunc.new, FancyFunc.new )

# so that
p my_func1.f( 2 ) # -> 5 (2**2 + 1) ie.
SimpleFunc.new.f(FancyFunc.new.f(2))
p my_func2.f( 2 ) # -> 9 ((2+1)**2)

#and
p my_func1.type # -> FancyFunc
p my_func2.type # -> SimpleFunc

Well the code above works and it's of course very nice to be able to do
these kinds of things, but I keep feeling a bit uneasy having to eval code
in strings. Thus:

* Are there other/better ways to accomplish the stuff above? Preferred
way?

* Are there performance bottlenecks with the code above? Say if I need to
transform several hundred thousand FancyFunc objects...

Regards,

Robert