Some things are unclear to me about Method#to_proc. I understand the
following:
plus = 12.method("+")
p plus.call(13) # prints 25
newplus = plus.unbind.bind(20)
p newplus.call(13) # prints 33
Although the usefulness of this eludes me
However, this:
plus_proc = plus.to_proc
p plus_proc.call(10) # prints 10
Is unclearā¦
How does it work ?
What does it mean for a Proc to be bound to an object ?
Can someone provide an example where it is useful ?
Have the ābindā and āunbindā methods of Method / UnboundMethod
anything in common with Proc#binding or the Binding class ?
Have Proc#binding and the Binding class anything in common ? How
about Kernel#binding ?
Additionally, the following, IMHO demostrates a very surprising and
unnatural behavior of to_proc:
def foo(arr)
puts āGot an array with #{arr.length} elementsā
end
works correctly
foo([4, 5, 6])
foo_proc = method(:foo).to_proc
throws an ArgumentError: 3 for 1
foo_proc.call([4, 5, 6])
works correctly
foo_proc.call([[4, 5, 6]])
The Proc created by to_proc is obviously different from the original
method, since it āfoldsā its arguments into an array. I guess there
will be even more problems when the method receives more than one array
as an argument.
How should this be handled correctly ?
In message āRe: understanding the behavior of Method#to_procā
on Thu, 20 Apr 2006 02:19:41 +0900, Eli B. [email protected]
writes:
|Still, I donāt quite understand what does it mean for a Proc to be bound
|to an object ? Does it have some access to the objectās internals, like
|the method did ? When is this useful ?
Still I donāt quite understand what you expect for a Proc not to be
bound to an object in this case. It was only reasonable design for
me.
In message āRe: understanding the behavior of Method#to_procā
on Thu, 20 Apr 2006 02:19:41 +0900, Eli B. [email protected]
writes:
|Still, I donāt quite understand what does it mean for a Proc to be bound
|to an object ? Does it have some access to the objectās internals, like
|the method did ? When is this useful ?
Still I donāt quite understand what you expect for a Proc not to be
bound to an object in this case. It was only reasonable design for
me.
matz.
Matz,
Iām not questioning your design at all - I ask out of sheer curiosity
what this language construct (Proc bound to an object) does, because it
isnāt documented anywhere (please correct me if Iām mistaken). Moreover,
Iāll be happy to see an example of when this can be useful in Ruby
coding.
In message āRe: understanding the behavior of Method#to_procā
on Wed, 19 Apr 2006 23:25:34 +0900, Eli B. [email protected]
writes:
|plus = 12.method(ā+ā)
|p plus.call(13) # prints 25
|plus_proc = plus.to_proc
|p plus_proc.call(10) # prints 10
Which version of Ruby are you using? My 1.8.4 gives me 22.
matz.
You are right, I made a mistake. It prints 22 for me too.
Still, I donāt quite understand what does it mean for a Proc to be bound
to an object ? Does it have some access to the objectās internals, like
the method did ? When is this useful ?
E> Iām not questioning your design at all - I ask out of sheer curiosity
E> what this language construct (Proc bound to an object) does, because
it
E> isnāt documented anywhere (please correct me if Iām mistaken).
Moreover,
E> Iāll be happy to see an example of when this can be useful in Ruby
E> coding.
Well, Iāve not understood but if you want to know why Method#to_proc
exist
this is perhaps to give you this possibility