From: Joshua Ballanco <jballanc@...>
Date: 2011-04-27T08:33:06+09:00
Subject: [ruby-core:35914] Re: [Ruby 1.9 - Feature #4610] Proc#curry behavior is inconsistent with lambdas containing default argument values

--90e6ba6e83d8c6085c04a1dabe26
Content-Type: text/plain; charset=UTF-8

On Tue, Apr 26, 2011 at 7:57 AM, Yusuke ENDOH <mame@tsg.ne.jp> wrote:

> 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)... ?


I agree rest is a complication, but terminal rest seems to be ok. I would
argue that, in the case you provide, the final proc yielded could have arity
-1.

proc {|x, y, z, *rest| puts "#{x}, #{y}, #{z}, #{rest.join(',')}"
}.curry.(1).(2).(3).(4)
# => "1, 2, 3, 4"
proc {|x, y, z, *rest| puts "#{x}, #{y}, #{z}, #{rest.join(',')}"
}.curry.(1).(2).(3).(4, 5)
# => "1, 2, 3, 4, 5"
proc {|x, y, z, *rest| puts "#{x}, #{y}, #{z}, #{rest.join(',')}"
}.curry.(1).(2).(3).(4).(5)
# => "1, 2, 3, 4"
# => NoMethodError: undefined method `call' for nil:NilClass

The real problem is interstitial rest argument, but even here I would argue
that at the point where the rest argument is encountered, the proc should
have arity -1 (and keeping arity strictness between lambda and proc):

proc {|x, y, *rest, z| puts "#{x}, #{y}, #{z}, #{rest.join(',')}"
}.curry.(1).(2).(3).(4)
# => "1, 2, 4, 3"
lambda {|x, y, *rest, z| puts "#{x}, #{y}, #{z}, #{rest.join(',')}"
}.curry.(1).(2).(3).(4, 5)
# => ArgumentError: wrong number of arguments (2 for 1)
proc {|x, y, *rest, z| puts "#{x}, #{y}, #{z}, #{rest.join(',')}"
}.curry.(1).(2).(3).(4, 5)
# => "1, 2, 4, 3"

Essentially, if you keep to the notion of currying pulling argument lists
apart and creating new methods for each argument, I think this is still
doable in Ruby.

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

This is an interesting approach I hadn't considered. I agree that OCaml's
approach works because of the requirement of naming optional arguments (so,
for example, I can still pass just the second of three). This also makes me
wonder if keyword arguments and currying might not be more related than I
had thought.

Forgive me for speculating, but what if a curried proc could remember the
variable name for its argument? This could provide a mechanism for keyword
arguments. In other words, assuming you could do:

c = lambda {|first, second="bar"| puts "#{first}, #{second}" }.curry
# => #<CurriedProc(lambda)>
c.argument_key
# => "first"
c = c.('foo')
c.argument_key
# => "second"
c.default_value
# => "bar"
c.("baz")
# => "foo, baz"

Then you could conceptually implement keyword arguments like so:

class KeywordProc
  def initialize(curried_proc)
    @curried = curried_proc
  end

  def call(args)
    c = @curried.dup
    while c.kind_of? Proc do
      arg = args[c.argument_key]
      if arg.nil?
        if c.default_value
          c = c.()
        else
          raise ArgumentError
        end
      end
      c = c.(arg)
    end
  end
end

l = lambda { |first, second="san", third="three"| puts "#{first}, #{second},
#{third}" }
k = KeywordProc.new(l.curry)
k.call(second: "dos", first: "bir")
# => "bir, dos, three"


> The future of keyword arguments is promised by matz
> [ruby-core:32131]:
>
> > Keyword arguments will be available on 2.0.


I look more and more forward to 2.0 every day, now!

Cheers,

Josh

--90e6ba6e83d8c6085c04a1dabe26
Content-Type: text/html; charset=UTF-8
Content-Transfer-Encoding: quoted-printable

<meta charset=3D"utf-8">On Tue, Apr 26, 2011 at 7:57 AM, Yusuke ENDOH=C2=A0=
<span dir=3D"ltr">&lt;<a href=3D"mailto:mame@tsg.ne.jp">mame@tsg.ne.jp</a>&=
gt;</span>=C2=A0wrote:<br><blockquote class=3D"gmail_quote" style=3D"margin=
-top: 0px; margin-right: 0px; margin-bottom: 0px; margin-left: 0.8ex; borde=
r-left-width: 1px; border-left-color: rgb(204, 204, 204); border-left-style=
: solid; padding-left: 1ex; ">
Hello,<br><br>2011/4/26 Joshua Ballanco &lt;<a href=3D"mailto:jballanc@gmai=
l.com">jballanc@gmail.com</a>&gt;:<br><div class=3D"im">&gt; 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 s=
hould be a chain of Proc&#39;s with arity 1 that return Proc&#39;s with ari=
ty 1 until all arguments have been satisfied. It would be nice if Ruby beha=
ved similarly.<br>
<br></div>How should Ruby handle *rest parameter?<br><br>=C2=A0proc {|x, y,=
 z, *rest| }.curry.(1).(2).(3).(4).(5)... ?</blockquote><div><br></div><div=
>I agree rest is a complication, but terminal rest seems to be ok. I would =
argue that, in the case you provide, the final proc yielded could have arit=
y -1.</div>
<div><br></div><div>proc {|x, y, z, *rest| puts &quot;#{x}, #{y}, #{z}, #{r=
est.join(&#39;,&#39;)}&quot; }.curry.(1).(2).(3).(4)</div><div># =3D&gt; &q=
uot;1, 2, 3, 4&quot;</div><div><div>proc {|x, y, z, *rest| puts &quot;#{x},=
 #{y}, #{z}, #{rest.join(&#39;,&#39;)}&quot; }.curry.(1).(2).(3).(4, 5)</di=
v>
</div><div># =3D&gt; &quot;1, 2, 3, 4, 5&quot;</div><div><div>proc {|x, y, =
z, *rest| puts &quot;#{x}, #{y}, #{z}, #{rest.join(&#39;,&#39;)}&quot; }.cu=
rry.(1).(2).(3).(4).(5)</div></div><div># =3D&gt; &quot;1, 2, 3, 4&quot;</d=
iv>
<div># =3D&gt;=C2=A0NoMethodError: undefined method `call&#39; for nil:NilC=
lass</div><div><br></div><div>The real problem is interstitial rest argumen=
t, but even here I would argue that at the point where the rest argument is=
 encountered, the proc should have arity -1 (and keeping arity strictness b=
etween lambda and proc):</div>
<div><br></div><div>proc {|x, y, *rest, z| puts &quot;#{x}, #{y}, #{z}, #{r=
est.join(&#39;,&#39;)}&quot; }.curry.(1).(2).(3).(4)</div><div># =3D&gt; &q=
uot;1, 2, 4, 3&quot;</div><div><div>lambda {|x, y, *rest, z| puts &quot;#{x=
}, #{y}, #{z}, #{rest.join(&#39;,&#39;)}&quot; }.curry.(1).(2).(3).(4, 5)</=
div>
</div><div># =3D&gt;=C2=A0ArgumentError: wrong number of arguments (2 for 1=
)</div><div><div><div>proc {|x, y, *rest, z| puts &quot;#{x}, #{y}, #{z}, #=
{rest.join(&#39;,&#39;)}&quot; }.curry.(1).(2).(3).(4, 5)</div></div></div>=
<div>
# =3D&gt; &quot;1, 2, 4, 3&quot;</div><div><br></div><div>Essentially, if y=
ou keep to the notion of currying pulling argument lists apart and creating=
 new methods for each argument, I think this is still doable in Ruby.</div>
<div><br></div><blockquote class=3D"gmail_quote" style=3D"margin-top: 0px; =
margin-right: 0px; margin-bottom: 0px; margin-left: 0.8ex; border-left-widt=
h: 1px; border-left-color: rgb(204, 204, 204); border-left-style: solid; pa=
dding-left: 1ex; ">
<div class=3D"im">&gt; For example, in OCaml (which auto-curries functions)=
:<br><br></div>If you quote OCaml, you should note that Ocaml also provides=
<br>optional arguments.<br>Actually, OCaml handles optional arguments as Ru=
by does.<br>
IOW, OCaml function also fires as soon as all the required<br>arguments are=
 given:<br><br><br>=C2=A0# let foo ?(a=3D&quot;ichi&quot;) ?(b=3D&quot;ni&q=
uot;) ?(c=3D&quot;san&quot;) () =3D<br>=C2=A0 =C2=A0 =C2=A0print_endline (S=
(String.concat &quot;, &quot; [a; b; c]);;<br>
=C2=A0val foo : ?a:string -&gt; ?b:string -&gt; ?c:string -&gt; unit -&gt; =
unit =3D &lt;fun&gt;<br>=C2=A0# foo ();;<br>=C2=A0ichi, ni, san<br>=C2=A0- =
: unit =3D ()<br>=C2=A0# foo ~a:&quot;first&quot; ();;<br>=C2=A0first, ni, =
san<br>=C2=A0- : unit =3D ()<br>=C2=A0# foo ~a:&quot;first&quot; ~b:&quot;s=
econd&quot; ();;<br>
=C2=A0first, second, san<br>=C2=A0- : unit =3D ()<br>=C2=A0# foo ~a:&quot;f=
irst&quot; ~b:&quot;second&quot; ~c:&quot;third&quot; ();;<br>=C2=A0first, =
second, third<br>=C2=A0- : unit =3D ()<br><br><br>There are some difference=
s between OCaml and Ruby:<br>
<br>=C2=A0- OCaml function requires at least one mandatory argument.<br>=C2=
=A0 =C2=A0(In this case, () is the only mandatory argument.)<br><br>=C2=A0-=
 Optional arguments always requires labels (=3D keywords).<br><br><br>I bel=
ieve your concern (and #4601) will be solved by keyword<br>
arguments.<br><br>=C2=A0def foo(a:&quot;ichi&quot;, b:&quot;ni&quot;, c:&qu=
ot;san&quot;)<br>=C2=A0 =C2=A0puts &quot;#{ a }, #{ b }, #{ c }&quot;<br>=
=C2=A0end<br><br>=C2=A0foo(b:&quot;second&quot;) =C2=A0#=3D&gt; ichi, secon=
d, san<br><br>=C2=A0method(:foo).curry.<br>
=C2=A0 =C2=A0pass_option(a: &quot;first&quot;).<br>=C2=A0 =C2=A0pass_option=
(b: &quot;second&quot;).<br>=C2=A0 =C2=A0pass_option(c: &quot;third&quot;).=
<br>=C2=A0 =C2=A0call() =C2=A0#=3D&gt; first, second, third<br><br>Unfortun=
ately, a new method (Proc#pass_option) is needed<br>
because Proc#call(key: val) passes a hash { key =3D&gt; val } as<br>a norma=
l argument, unless we accept the incompatibility.<br></blockquote><div><br>=
</div><div>This is an interesting approach I hadn&#39;t considered. I agree=
 that OCaml&#39;s approach works because of the requirement of naming optio=
nal arguments (so, for example, I can still pass just the second of three).=
 This also makes me wonder if keyword arguments and currying might not be m=
ore related than I had thought.</div>
<div><br></div><div>Forgive me for speculating, but what if a curried proc =
could remember the variable name for its argument? This could provide a mec=
hanism for keyword arguments. In other words, assuming you could do:</div>
<div><br></div><div>c =3D lambda {|first, second=3D&quot;bar&quot;| puts &q=
uot;#{first}, #{second}&quot; }.curry</div><div># =3D&gt; #&lt;CurriedProc(=
lambda)&gt;</div><div>c.argument_key</div><div># =3D&gt; &quot;first&quot;<=
/div>
<div>c =3D c.(&#39;foo&#39;)</div><div>c.argument_key</div><div># =3D&gt; &=
quot;second&quot;</div><div>c.default_value</div><div># =3D&gt; &quot;bar&q=
uot;</div><div>c.(&quot;baz&quot;)</div><div># =3D&gt; &quot;foo, baz&quot;=
</div>
<div><br></div><div>Then you could conceptually implement keyword arguments=
 like so:</div><div><br></div><div>class KeywordProc</div><div>=C2=A0 def i=
nitialize(curried_proc)</div><div>=C2=A0 =C2=A0 @curried =3D curried_proc</=
div><div>=C2=A0 end</div>
<div><br></div><div>=C2=A0 def call(args)</div><div>=C2=A0 =C2=A0 c =3D @cu=
rried.dup</div><div>=C2=A0 =C2=A0 while c.kind_of? Proc do</div><div>=C2=A0=
 =C2=A0 =C2=A0 arg =3D args[c.argument_key]</div><div>=C2=A0 =C2=A0 =C2=A0 =
if arg.nil?</div><div>=C2=A0 =C2=A0 =C2=A0 =C2=A0 if c.default_value</div><=
div>
=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 c =3D c.()</div><div>=C2=A0 =C2=A0 =C2=
=A0 =C2=A0 else</div><div>=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 raise Argument=
Error</div><div>=C2=A0 =C2=A0 =C2=A0 =C2=A0 end</div><div>=C2=A0 =C2=A0 =C2=
=A0 end</div><div>=C2=A0 =C2=A0 =C2=A0 c =3D c.(arg)</div><div>=C2=A0 =C2=
=A0 end</div><div>=C2=A0 end=C2=A0=C2=A0</div><div>end</div><div><br></div>
<div>l =3D lambda { |first, second=3D&quot;san&quot;, third=3D&quot;three&q=
uot;| puts &quot;#{first}, #{second}, #{third}&quot; }</div><div>k =3D Keyw=
ordProc.new(l.curry)</div><div>k.call(second: &quot;dos&quot;, first: &quot=
;bir&quot;)</div>
<div># =3D&gt; &quot;bir, dos, three&quot;</div><div>=C2=A0</div><blockquot=
e class=3D"gmail_quote" style=3D"margin-top: 0px; margin-right: 0px; margin=
-bottom: 0px; margin-left: 0.8ex; border-left-width: 1px; border-left-color=
: rgb(204, 204, 204); border-left-style: solid; padding-left: 1ex; ">
The future of keyword arguments is promised by matz<br>[ruby-core:32131]:<b=
r><br>&gt; Keyword arguments will be available on 2.0.</blockquote><div><br=
></div><div>I look more and more forward to 2.0 every day, now!</div><div>
<br></div><div>Cheers,</div><div><br></div><div>Josh=C2=A0</div>

--90e6ba6e83d8c6085c04a1dabe26--