Forum: Ruby-core [ruby-trunk - Feature #6817][Open] Partial application

Issue #6817 has been reported by citizen428 (Michael Kohl).

----------------------------------------
Feature #6817: Partial application
https://bugs.ruby-lang.org/issues/6817

Author: citizen428 (Michael Kohl)
Status: Open
Priority: Normal
Assignee:
Category: core
Target version: 2.0.0


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

<pre><code class="ruby">
(1..3).map { |i| i + 2 }
</code></pre>

or the somewhat unwieldy

<pre><code class="ruby">
(1..3).map(&2.method(:+))
</code></pre>

 one could just write

<pre><code class="ruby">
(1..3).map(&2.+)
</code></pre>

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 
(http://citizen428.net/blog/2012/07/30/ruby-left-se...), 
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.

Issue #6817 has been updated by shyouhei (Shyouhei Urabe).

Description updated

=begin
=end

----------------------------------------
Feature #6817: Partial application
https://bugs.ruby-lang.org/issues/6817#change-28567

Author: citizen428 (Michael Kohl)
Status: Open
Priority: Normal
Assignee:
Category: core
Target version: 2.0.0


=begin

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 
(((<URL:http://citizen428.net/blog/2012/07/30/ruby-left-se...))), 
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.
=end

Issue #6817 has been updated by yhara (Yutaka HARA).

Target version changed from 2.0.0 to next minor


----------------------------------------
Feature #6817: Partial application
https://bugs.ruby-lang.org/issues/6817#change-31532

Author: citizen428 (Michael Kohl)
Status: Open
Priority: Normal
Assignee:
Category: core
Target version: next minor


=begin

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 
(((<URL:http://citizen428.net/blog/2012/07/30/ruby-left-se...))), 
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.
=end

Issue #6817 has been updated by ko1 (Koichi Sasada).

Assignee set to matz (Yukihiro Matsumoto)

This ticket is related to [ruby-core:52797] [ruby-trunk - Feature 
#7939]?
(definitely no?)

Basically, I like this proposal.
But I'm not sure this notation can be acceptable.


FYI: Scheme has similar, but more flexible proposal:
http://srfi.schemers.org/srfi-26/srfi-26.html

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

----------------------------------------
Feature #6817: Partial application
https://bugs.ruby-lang.org/issues/6817#change-37077

Author: citizen428 (Michael Kohl)
Status: Open
Priority: Normal
Assignee: matz (Yukihiro Matsumoto)
Category: core
Target version: next minor


=begin

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 
(((<URL:http://citizen428.net/blog/2012/07/30/ruby-left-se...))), 
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.
=end