It seems to me that this is a bit like a combination of Proc#curry and a promise/future object. In fact, your second example can exactly be done with Proc#curry:

1.9.3-p194 :001 > s = "foo"
 => "foo" 
1.9.3-p194 :002 > l = s.method(:"+").to_proc.curry
 => #<Proc:0x007ffc83103c40 (lambda)> 
1.9.3-p194 :003 > l["end"]
 => "fooend" 
1.9.3-p194 :004 > s
 => "foo" 




On Monday, July 9, 2012 at 6:05 PM, Robert Klemme wrote:

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