You wrote:
> I find myself wanting to pass a method as the block to another
> method on a fairly regular basis, and I don't really like how the
> code turns out.  Currently it looks like this:
> 
>   result.addFaultListener(self, &(method(:addFault).to_proc))

Hmmm ... let me see if I understand you correctly. You have an
instance of a certain class referred by variable 'result', yes?

You want to add a reference to a method to be called if a fault
happened, yes? Like Java, right?

You have first to know, that there are *two* kind of code you could
use here. 

1. blocks (the 'often used' Ruby idiom for callbacks) or 
2. methods, as you already mentioned.

You seem to mix them both. First you extract a method object and try
to convert it to an Proc instance which you convert to an block
afterwards to pass it to your 'result' referred instance.

But this is not necessary, IMHO. You can use a method object directly
without wrapping/converting it first. You have only to know, that you
are not able to get a mere reference to a method in Ruby. You can only
get a reference to a method that is already bound to a certain
instance. Like this:

  m = 2.method(:+)
  p m.call(3)      # => 5
  p m.call(4)      # => 6

You see, that the method referred by variable 'm' is already bound to
instance '2'. But this should normally no problem, as in Ruby *every*
method is bound normally. If not explicitely, then implicitely to
current environment (as private method of class Object).

So you could simply write:

  class Foo
    def initialize
      @faultListener = Array.new
    end
    def addFaultListener(method)
      @faultListener << method
    end
    def fire(n)
      @faultListener.each { |listener| listener.call(n) }
    end
  end

  class Bar
    def initialize(n)
      @name = n
    end
    def listener(n)
      print "Listener of #@name called with #{n} as argument\n"
    end
  end

  def anonListener(n)
    print "Anonymous listener called with #{n} as argument\n"
  end

  foo = Foo.new
  bar1 = Bar.new("Bar1")
  foo.addFaultListener(bar1.method(:listener))
  foo.addFaultListener(method(:anonListener))

  foo.fire(12)

(...)

> through all the arguments). Is there a better way to do this? Does

'Better' is a matter of taste here, IMO. For instance I believe that
somebody else will direct you to observer pattern or delegate usage. 
That is the joy of Ruby: use what seems apropiate to you for the 
current task.

(...)

> of a nuby, so I'll also ask, is it bad (Ruby) design to pass a
> method as the block to a method?

Yes, IMO! Pass a block or pass a method instance. But do not try to
convert a method instance to a block, that is not necessary!

> Thanks,
> 
> 
> Nathaniel

HTH,
\cle