Hi Joe,

> Sorry, please bear with me... the Lisp I had in mind was
> more like:
>
>   (setf a #'length)
>   (funcall a "foo")
>
> (Hard to make an exact parallel because Ruby has methods
> not functions, and Lisp AFAIK has functions not
> methods...?)

Ruby has both methods and functions, but methods are more
primitive than functions.  In particular, functions are
objects and thus have methods.  Methods, on the other hand,
are not objects (and they are not functions).  So functions
are implemented using methods, not the other way around.

As for the example code, the closest Ruby equivalent would
have to be something like the following:

   a = :length
   "foo".send(a)

This is because in Ruby, polymorphism is implemented by
having different ¡Ælength¡Ç methods for different objects,
whereas in Lisp, there is just one function ¡Ælength¡Ç that
handles all types of objects.  (Of course, CLOS simplifies
the task of adding new clauses by way of defmethod, but a
generic function is still just one function.)

> Setting a variable to the function itself seems pretty
> different than wrapping a call to the function in a lambda,

Again, there is not just a single ¡Ælength¡Ç method in Ruby,
so you can't ¡Èset a variable to the function itself.¡É  The
closest analogy to the ¡Èfunction itself¡É is the method name.

> but honestly, now I can't think of what the actual
> implications would be... other than a little bit of
> additional terseness in calls like
>
> (reduce #'+ '(1 2 3))
> vs.
> [1, 2, 3].inject {|a,b|a+b}

You could actually define the equivalent of Lisp's ¡Æ+¡Ç
function in Ruby, by doing this:

   module Kernel
     def +(a, b) a + b end
   end

Then the example with inject could be written like this:

   [1,2,3].inject &method(:+)

But this will fail when someone overrides the ¡Æ+¡Ç operator,
in which case you need to do something like this:

   [1,2,3].inject &Object.new.method(:+)

Much cleaner would be to define the function in a separate
namespace so that name clashes are avoided:
   
   Function = Object.new
   class << Function
     alias [] method
     def +(*terms) terms.inject(0) { |a, b| a + b } end
   end

Now the example looks like this:

   [1,2,3].inject &Function[:+]

You could go one step further:

   class Symbol
     def to_proc
       Function[self].to_proc
     end
   end

Note that if you take the Kernel#+ approach, the above
implementation needs to be much hairier:

   class Symbol
     def to_proc
       Binding.of_caller do |boc|
         eval(%{method(:#{self})}, boc).to_proc
       end
     end
   end

Now you can reduce the original example (no pun intended)
to the following,

   [1,2,3].inject &:+

which is actually *shorter* than the equivalent Lisp code.

By the way, a more popular definition of Symbol#to_proc is
to have ¡Æfoo.each &:bar¡Ç equal ¡Æfoo.each { |x| x.bar }¡Ç.
This won't work in the above example because we cannot use
the Fixnum#+ method to fold an array of integers (since it
only takes one argument!).

(If you want both variants of Symbol#to_proc, I guess you
could use a unary plus or minus operator to disambiguate.
However, ¡Æ[1,2,3].inject &-:+¡Ç is starting to look rather
much like line noise.)

-- 
Daniel Brockman <daniel / brockman.se>

    So really, we all have to ask ourselves:
    Am I waiting for RMS to do this?   --TTN.