I know that what I propose here is a significant change to Ruby, but it's part of my ongoing quest to get some more functional programming features into Ruby (see also #4539 and #6373).
I was wondering if it would make sense to maybe introduce partial application to Ruby? So that instead of
(1..3).map{|i|i+2}
or the somewhat unwieldy
(1..3).map(&2.method(:+))
one could just write
(1..3).map(&2.+)
which I think has a quite rubyish feel to it. I have a POC implementation in Ruby (I tried it with various Fixnum methods) over at my blog, but that was just a quick hack and obviously I don't want to monkey-patch every method with arity 1, but it was a nice way of exploring possible syntax.
(cut cons (+ a 1) <>) is the same as (lambda (x2) (cons (+ a 1) x2))
(cut list 1 <> 3 <> 5) is the same as (lambda (x2 x4) (list 1 x2 3 x4 5))
(cut list) is the same as (lambda () (list))
(cut list 1 <> 3 <...>) is the same as (lambda (x2 . xs) (apply list 1 x2 3 xs))
(cut <> a b) is the same as (lambda (f) (f a b))
Of course, it is not ruby's way. This is only sample of the other language.
Basically, I like this proposal.
But I'm not sure this notation can be acceptable.
In that case, how about making Symbol#to_proc accept additional arguments?
(1..3).map(:+,2)
The syntax would be very straightforward, but it doesn't go well with the current implementation of Symbol#to_proc's proc cache. Also this does go away a bit from the original point of partial application, though tbh this sort of scenario is what I mostly had in mind anyway.
Updated by 
Updated by 
Updated by 
Updated by 
Updated by 
Updated by 
Updated by 
Updated by