From: Yusuke ENDOH <mame@...>
Date: 2011-04-26T20:57:59+09:00
Subject: [ruby-core:35904] Re: [Ruby 1.9 - Feature #4610] Proc#curry behavior is inconsistent with lambdas containing default argument values

Hello,

2011/4/26 Joshua Ballanco <jballanc@gmail.com>:
> Regarding the consistency argument, as I understand Currying (or at least the way that it is implemented in most other languages), the result of a Proc#curry call should be a chain of Proc's with arity 1 that return Proc's with arity 1 until all arguments have been satisfied. It would be nice if Ruby behaved similarly.

How should Ruby handle *rest parameter?

  proc {|x, y, z, *rest| }.curry.(1).(2).(3).(4).(5)... ?


> For example, in OCaml (which auto-curries functions):

If you quote OCaml, you should note that Ocaml also provides
optional arguments.
Actually, OCaml handles optional arguments as Ruby does.
IOW, OCaml function also fires as soon as all the required
arguments are given:


  # let foo ?(a="ichi") ?(b="ni") ?(c="san") () =
      print_endline (S(String.concat ", " [a; b; c]);;
  val foo : ?a:string -> ?b:string -> ?c:string -> unit -> unit = <fun>
  # foo ();;
  ichi, ni, san
  - : unit = ()
  # foo ~a:"first" ();;
  first, ni, san
  - : unit = ()
  # foo ~a:"first" ~b:"second" ();;
  first, second, san
  - : unit = ()
  # foo ~a:"first" ~b:"second" ~c:"third" ();;
  first, second, third
  - : unit = ()


There are some differences between OCaml and Ruby:

  - OCaml function requires at least one mandatory argument.
    (In this case, () is the only mandatory argument.)

  - Optional arguments always requires labels (= keywords).


I believe your concern (and #4601) will be solved by keyword
arguments.

  def foo(a:"ichi", b:"ni", c:"san")
    puts "#{ a }, #{ b }, #{ c }"
  end

  foo(b:"second")  #=> ichi, second, san

  method(:foo).curry.
    pass_option(a: "first").
    pass_option(b: "second").
    pass_option(c: "third").
    call()  #=> first, second, third

Unfortunately, a new method (Proc#pass_option) is needed
because Proc#call(key: val) passes a hash { key => val } as
a normal argument, unless we accept the incompatibility.


The future of keyword arguments is promised by matz
[ruby-core:32131]:

> Keyword arguments will be available on 2.0.

-- 
Yusuke Endoh <mame@tsg.ne.jp>