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/.