>l = lambda{|a,b,c| puts "a=#{a}, b=#{b}, c=#{c}"}
>
>puts l.arity	#=>3
>
>l.bind(2, 'b')
>
>puts l.arity	#=>2
>
>l.call('a', 'c')  #a=a, b=b, c=c

>Two questions:
>1. Does somebody think it is useful?
>2. Does somebody already done this in some library?

1. Binding parameters is useful sometimes.
2. Do you really need this, considering how simple it is to create a new
proc:

adder = proc { |a,b| a+b }
add_3 = proc { |a| adder.call(a,3) }  # adder bound with b=3

Or, if you insist to keep with adder (bad idea IMHO):

_adder = adder.dup
adder = proc { |a| _adder.call(a,5) }

That said, there are situations a library based approach is useful.
I'd prefer solutions that create new proc objects without the bound
parameters, much like I did above manù¦lly:

add_7 = bind_2nd(adder, 7)
add_7.call(1) ==> 8

add_11 = bind_nth(adder, 1, 11)
add_11.call(1) ==> 12

You will need to implement bind_* somewhere. If you do it in Proc, this
will look almost like your sketch:

add_13 = adder.bind_1st(13)
add_13.call(1) ==> 14
adder.call(10,7) ==> 17 # still works!

Creating a new proc should perform better than processing your bound[]
array every time #call is executed, and references to your proc in
other places don't stop working because of unexpected arity changes.
A rock hard implementation probably needs some eval-trickery, and should
allow assignment back to self:

adder = adder.bind_2nd(-1)  # really a decrementer now ...

Jgen

-- 
 The box said it requires Windows 95 or better so I installed Linux