[ruby-talk:04118] Re: What are you using Ruby for?

Clemens Hintze writes:


>> 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.

[...]


>   def f1
>     return proc { |x, y| return <something> }
>   end

>   f1.call(1,2)
>   register_proc "f1", f1, "compute something"

This is a neat trick.

>   g1 = make_g_from_proc f1
>   register_proc "g1", g1, "compute something scaled by scale"

[...]

> But I would try to solve this in a more OO way ... Using closures
> resembling functions! Store them in a certain module/class that
> indicates that these closures are thought to work on certain data for
> computation ...

I tried my hand at defining this in a "proper" way, and I still ended
up with way too many global variables.

I came up with:

# Class of functions mapping from (period x magnetic-field) space to the
# real number line.
class PBtoR
  # default function
  def call(p, b)
    p
  end
end

$p = PBtoR.new
$b = PBtoR.new
def $b.call(p, b)
  b
end

$f = PBtoR.new
def $f.call(p, b)
  return p*b
end

def g_from_f(f)
  proc {|p, b| f(p, b)*p**1.5}
end

$g = g_from_f($f)

...

This seems okay, but it has the "problem" of requiring lots of ugly
$'s everywhere.

If I could wrap this up in a module, so that I could both use
functional-style trickery when defining the objects, like above, and
still be able to call them in a nice way, I'd be perfectly happy, but
I haven't yet figured out how to do that.

Is there any way to wrap what I've written above into a module, so
I could say

  PBFuncs.p(0.1, 1e12)   -> 0.1
  PBFuncs.b(0.1, 1e12)   -> 1e12
  PBFuncs.g(0.1, 1e12)   -> whatever it is

and so on?  I guess I still don't understand the way namespaces
work in Ruby, or the way evaluation while loading works.

-- 
Johann Hibschman                           [e-mail]