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(:<<, “”)
=> #<Proc:0x802c4298@(irb):12 (lambda)>
irb(main):016:0> l.call
=> “foo”
irb(main):017:0> s
=> “foo”
irb(main):018:0> l[]
=> “foo”
irb(main):019:0> s
=> “foo”

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

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”

2012/7/9 Robert K. [email protected]:

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(:<<, “”)

Hi, what is “s” in this code?

2012/7/10 Iñaki Baz C. [email protected]:

Hi, what is “s” in this code?

Ok, sorry, “s” is any object.

The code seems indeed useful. What about a gem “lambdarize”? :slight_smile:

On Monday, July 9, 2012 11:05:22 AM UTC-4, Robert K. wrote:

How would you compare this to lazy,rb?

http://moonbase.rydia.net/software/lazy.rb/

On Jul 10, 2012, at 13:33 , Intransition wrote:

On Monday, July 9, 2012 11:05:22 AM UTC-4, Robert K. wrote:

How would you compare this to lazy,rb?

http://moonbase.rydia.net/software/lazy.rb/

Functors (function objects) vs delay/promise are totally different and
not really comparable.

My only request would be that you rename the method something like
‘create_lambda’ (since you’re not really casting s as such, you’re
using it as a factory) or get_lambda (if you want to make the lambda
seem like a property of s).

Aside from that, I can see it being a rather fun way to blow my feet
off and confuse my colleagues, which are always my primary goals at
work. (Spice of life, and all that.)

On 10 July 2012 01:05, Robert K. [email protected] wrote:

With that we can do
=> “foo”
It would be a convenient way to bundle a method call with arguments

Thoughts?

Kind regards

robert


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


Matthew K., B.Sc (CompSci) (Hons)
http://matthew.kerwin.net.au/
ABN: 59-013-727-651

“You’ll never find a programming language that frees
you from the burden of clarifying your ideas.” - xkcd

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

Correct me if I’m wrong (I’ve had a glass too much), but this looks like
partially applied functions to me. It’s used all over the place in
functional programming, e.g. currying.

On Wed, Jul 11, 2012 at 12:48 AM, Michael S. [email protected]
wrote:

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

Correct me if I’m wrong (I’ve had a glass too much), but this looks like
partially applied functions to me. It’s used all over the place in functional
programming, e.g. currying.

There are some similarities but the underlying object is usually not a
lambda as it would be for currying. I prefer to look at it as a
convenient way to bundle an object with a method call and its
arguments for later use.

Kind regards

robert

On Wed, Jul 11, 2012 at 3:40 AM, Matthew K. [email protected]
wrote:

My only request would be that you rename the method something like
‘create_lambda’ (since you’re not really casting s as such, you’re
using it as a factory) or get_lambda (if you want to make the lambda
seem like a property of s).

It’s not a “get” since we actually create something. I prefer
#to_lambda (or #to_something_else) because it actually converts the
object to something else (btw. #to_enum works similarly, i.e. by
wrapping the instance at hand with something else which provides a
particular interface). Also “to” is shorter to type than “create”.
:slight_smile:

Aside from that, I can see it being a rather fun way to blow my feet
off and confuse my colleagues, which are always my primary goals at
work. (Spice of life, and all that.)

Yeah, that’s the spirit! :slight_smile:

Cheers

robert

On 11 July 2012 16:45, Robert K. [email protected] wrote:

particular interface). Also “to” is shorter to type than “create”.
:slight_smile:

Rather. However I feel that if it’s called #to_lambda it should be a
method of the method, since it’s the method being bound to the
object, rather than the object being bound to the method call. (And
therein was revealed the ultimate depth of the pedantry of the
debate…)

How about something imperative, like #lambdafy :
baz.lambdafy(:foo, zing, ploink)
#=> “baz, lambdafy method :foo, with parameters zing and ploink !”
You could call it #bind_method if you don’t want people to balk. More
typing though.

On the obverse, I’d be perfectly happy if you called it #to_adbmal
since you’re inversely converting the object to a lambda, by binding
it to an instance of a method call. Take that, colleagues!


Matthew K., B.Sc (CompSci) (Hons)
http://matthew.kerwin.net.au/
ABN: 59-013-727-651

“You’ll never find a programming language that frees
you from the burden of clarifying your ideas.” - xkcd