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
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.
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 Klemme <shortcutter@googlemail.com> 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
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 12:48 AM, Michael Sokol <mikaa123@gmail.com> 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.
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".
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!
Cheers
robert
···
On Wed, Jul 11, 2012 at 3:40 AM, Matthew Kerwin <matthew@kerwin.net.au> wrote:
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!
···
On 11 July 2012 16:45, Robert Klemme <shortcutter@googlemail.com> wrote:
On Wed, Jul 11, 2012 at 3:40 AM, Matthew Kerwin <matthew@kerwin.net.au> 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".
