It looks like my previous reply to this may have been lost, so I'm
re-posting it.

Regards


Dave


Johann Hibschman <johann / physics.berkeley.edu> writes:

> As an example of what I do in python, I have a program which
> implements several functions over a dataset, then lets the user pick
> which functions to plot from the command line.  There are also
> multiple forms of each function, which are (in general) variable
> transformations.
>... 
> As I understand Ruby, I would have to make all of these functions into
> global Proc objects and use $-names to reference them, if I want f1
> and g1 to be callable using the same conventions.  That seems like it
> would get very ugly very fast.
> 
> Is this a correct impression?

Yes and no ;-)

For your particular problem, you have a couple of solutions. Firstly,
there's no need for a global to reference the proc. You could just
write

  register_function("g1", proc {|x,y| f1(x,y)}, "compute something")


You _could_ do it that way, but...

One of the things about functions is that referencing one in a pure OO 
language requires that you at some point bind it to an object. A
function on its own means nothing. Take the humble '+' operator, for
instance. Send it to a number, and you get addition; send it to a
string, concatenation.

So, lets create a calculation class to hold all our functions:

  class Calculator
     def f1(x, y)
       #...
     end
     def g1(x, y)
       #...
     end
  end

Then the code might look something like:

  calc = Calculator.new

  register_function("f1", calc.method(:f1), "computer it")
  register_function("g1", calc.method(:g1), "computer other")


There are definite benefits here. Say your calculations had related
information they shared (methods, constants and the like). These are
now all neatly encapsulated within class Calculator. Then say you
wanted to have sets of related functions with different versions of
these constants.

  
  calc1 = Calculator.new(1.2)

  register_function("f1", calc.method(:f1), "computer it")
  register_function("g1", calc.method(:g1), "computer other")

  calc2 = Calculator.new(1.4)

  register_function("f2", calc2.method(:f2), "computer it")
  register_function("g2", calc2.method(:g2), "computer other")


So I'd say what you might initially perceive to be a disadvantage
actually is a strength!


Regards


Dave