Get rid of auto-currying, add syntax for currying/partial app.

[stylewarning]

"Auto-currying" is a very cool feature for some very slick and compact code. I love being able to write (* 2) as a doubling function, for example.

However, I find that in general, auto-currying is more trouble than the entry fee it paid:

• A lot of functions aren't useful as curried.
• Many functions are better curried when flipped.
• A typo, like not including an argument when one was intended, can lead to very difficult to debug type errors.
• We work hard to de-curry as much as possible.

As such, I'd propose we break an ML/Haskell tradition and get rid of it as a default, and instead use another syntax. Some ideas follow. In the following ideas, the spirit is what I'm aiming for, i.e., whether it's _ or $ or something else is open to discussion.

Idea #1: Curry syntax

Suppose f : t -> t -> t. The syntax [f x] would represent the curried function t -> t.

Idea #2: Same as #1, but with partial application

Suppose the same f. Then the above could be written [f x _]. The other argument could be [f _ x]. Multiple arguments could be f == [f _1 _2] and flip f == [f _2 _1].

[sabjohnso]

My personal preference would be to keep auto-currying. However, I think a syntax for the abbreviated definition of anonymous functions would be valuable regardless, and I do recognize there is merit to having an alternate syntax for partial application as it would communicate more information to readers of the code.

Below are some related ideas from other languages. In particular, Racket's curly-fn library essentially combines Idea1 and Idea2.

SRFI 26

https://srfi.schemers.org/srfi-26/srfi-26.html
Scheme's SRFI 26 is conceptually similar to the proposed syntax but
also has some striking differences. For partial application the syntax
would be similar to the propopsed syntax:

(cut f x <>)

(fn (y) (f x y)

or for right partial appliction

(cut f <> x)

(fn (y) (f y x))

Note for a ternary function h : :t -> :t -> :t -> :t,

(cut h x <> <>)

would be equivalent to

(fn (y z) (h x y z))

and would have the type :t -> :t -> :t, not :t -> :t. Namely, the first and second
lozenges do not refer to the same argument. Rather, the lozenges just
represents holes that are left open. As a result, cut cannot be used
to reorder the arguments to f. Cut has some additional
limitations/draw backs:

(cut g (f x <>) <>)

would be equivalent to

(fn (y) (g (f x <>) y)

and would likely fail to compile because (f x <>) is read as the
function f applied to the arguments x and <>, where <> would
be undefined. However, there is a more horrifying scenario: <> is
actually define in the lexical environment. In that scenario, g is
partially applied to the full application of f to x and <> as
bound in the lexical environment. Probably not the intent of the code
and definitely confusing to readers.

The cut forms can be nested but my may still be difficult to read

(cut g (cut f x <>) <>)

would be the partial application of g to the partial application of
f to x or

(fn (z) 
  (fn (y)
    (g (f x y) z)))

Finally (cut f x y), where x and y are defined in the lexical
environment, defines a thunk.

Clojure's Anonymous function syntax

https://clojure.org/guides/learn/functions#_anonymous_function_syntax
Clojure has a syntax for the abbreviated definition of of anonymous
functions, which is similar to the proposed syntax.

The partial application of f would be as follows:

  #(f x %)

and swapping the argument in f would be as follows:

 #(f %2 %1)

Unlike cut, Clojure's syntax allows % to be used in compound
subforms, not just in the top of the cut form:

#(g (f %) ) %)

would be equivalent to

(fn (x) (g (fn (y) (f x y)) x)

Clojure does not allow nesting of abbreviated function definitions:

#(g #(f x %) %)

is a syntax error. This limitation means it cannot replace
(g (f x)), fn can always solve that problem.

Racket

https://github.com/lexi-lambda/racket-curly-fn
Racket has a library implementing a metalanguage for abbreviated
definitions of anonymous functions that is similar to Clojure's but
using braces instead of parentheses to avoid a conflict with the
syntax for literal vectors.

The partial application of f would be as follows:

#{f x %}

and swapping the arguments would be

#{f %2 %1}

It also supports the curried version like Idea 1, which Clojure's
syntax is not capable of. Namely #{f x} is equivalent to #{f x %},
and is a suitable replacement for (g (f x)): #{g #{f x}}.

This is essentially the same as Idea1 and Idea2 combined, with
different delimiters to open and close the form.

Mathematica

https://www.wolfram.com/language/elementary-introduction/2nd-ed/26-pure-anonymous-functions.html
Mathematica also has a similar notion where

F[x, #]&

is the partial application of F and

F[#2, #1]&