[ruby-core:61388] [ruby-trunk - Feature #9548] Module curry

Issue #9548 has been updated by Boris Stitnicky.


Indeed, there is much less use for currying than for chaining in the functional world. (In #9552, I now prefer `#chain` to `#map!`.) Yet there is already `Proc#curry` in Ruby (whose present behavior is horrible, imo), therefore it is fair consider giving the same convenience to the functions employed in modules as methods.

As for the name, in this particular case, I would still argue in favor of `Module#curry`. My list of possibilities would be:

`#curry            ---     5`
`#partial_application ---  1     --- too long`
`#partial_apply    ---     1`
`#partially_apply  ---     0`
`#partial`         ---     2`
`#filter`          ---     0     --- means too many things` 

In my opinion, `curry` is by far the best, and I woul like to pretty please you to give your nod to misuse the word in this way, should it be decided that such feature on `Module` is desirable at all.

As for the usecases, again, there are less of them than for chaining, but let me make up some real-world example which would be of use in my code:

```ruby
  class Simulation
    def initialize( initial_marking: {},
                    marking_clamps: {},
                    method: :pseudo_euler,
                    step: 1.0,
                    target_time: 60.0,
                    sampling: 5.0,
                    guarded: false )
      # object initialization
    end

    # class assets
  end

  class Net
    def initialize *args
      # net initialization
    end

    def Simulation
      # creates a parametrized subclass of Simulation
      @Simulation ||= Simulation.parametrize( net: self )
    end
    
    def simulation **named_args
      Simulation.new **named_args
    end

    curry euler simulation( method: :euler, ** )
    curry pseudo_euler simulation( method: :pseudo_euler, ** )
    curry runge_kutta simulation( method: :runge_kutta, ** )
    curry gillespie simulation( method: :gillespie, step: nil, ** )
    # Gillespie method computes its own step length.
  end

net = Net.new

# And then, instead of
sim = net.simulation( method: :gillespie,
                      initial_marking: { A: 100, B: 200 },
                      # etc.
                    )

# one could just type
sim = net.gillespie( initial_marking: { A: 1, B: 2 },
                     # etc.
                   )
```

----------------------------------------
Feature #9548: Module curry
https://bugs.ruby-lang.org/issues/9548#change-45699

* Author: Boris Stitnicky
* Status: Feedback
* Priority: Normal
* Assignee: 
* Category: 
* Target version: 
----------------------------------------
I would like to beg for either `Module#curry` method with syntax

```ruby
module Foo
  curry( :sym2, :sym1, 0 => 42, 1 => 43, 3 => 44, foo: "bar" )
end
```

or `curry` directive similar to the existing `alias` directive

```ruby
module Foo
  curry sym2 sym1( 42, 43, *, 44, foo: "bar )
end
```

Example usage:

```ruby
module MyMath
  def power a, b
    a ** b
  end

  curry square power( *, 2 )
  curry square_root power( *, 0.5 )
  curry cube( *, 3 )
  curry pow2 power( 2, * )
  curry pow_e power( Math::E, * )
  curry pow10 power( 10, * )
end
```




-- 
http://bugs.ruby-lang.org/