Hello all,
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...
1) How does it work ?
2) What does it mean for a Proc to be bound to an object ?
3) Can someone provide an example where it is useful ?
4) Have the 'bind' and 'unbind' methods of Method / UnboundMethod
anything in common with Proc#binding or the Binding class ?
5) 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 ?
Thanks in advance
路路路
--
Posted via http://www.ruby-forum.com/.