Lambdaification of Method Calls

Hi,

does anybody think this is a good idea to have in stdlib or even core?

class Object
  def to_lambda(method, *a)
    lambda {|*b| send(method, *a, *b)}
  end
end

With that we can do

irb(main):015:0> l = s.to_lambda(:<<, "<X>")
=> #<Proc:0x802c4298@(irb):12 (lambda)>
irb(main):016:0> l.call
=> "foo<X>"
irb(main):017:0> s
=> "foo<X>"
irb(main):018:0> l[]
=> "foo<X><X>"
irb(main):019:0> s
=> "foo<X><X>"

irb(main):038:0> s = "foo"
=> "foo"
irb(main):039:0> l = s.to_lambda '+'
=> #<Proc:0x801e8d60@(irb):22 (lambda)>
irb(main):040:0> l["end"]
=> "fooend"
irb(main):041:0> s
=> "foo"

It would be a convenient way to bundle a method call with arguments
for later execution (e.g. through a thread pool).  You then just do

queue.enq my_object.to_lambda(:calculate, "foo", 123)

and be done.  Another convenient name for the method would be "later".
 So we get

queue.enq my_object.later(:calculate, "foo", 123)

We could drive that even further and do

class Proc # or maybe class Object?
  def in(queue)
    queue << self
  end
end

No we can do

my_object.later(:calculate, "foo", 123).in queue

Thoughts?

Kind regards

robert

-- 
remember.guy do |as, often| as.you_can - without end
http://blog.rubybestpractices.com/