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”
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.)
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.
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”.
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.)
particular interface). Also “to” is shorter to type than “create”.
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!