macros for ergonomic curried functions

[Forthoney]

I'm trying to implement a convenient way to define curried functions. I'd like it to expand like so:

curry (a) (b) (c):
   a + b + c

fun (a):
  fun (b):
    fun (c):
      a + b + c

I can't quite figure out how to get this working. I tried something like

#lang rhombus
import:
  rhombus/meta open

defn.macro 'curry ($a) ...: $body':
  'fun ($a):
     ...:
       $body'

but it tells me the ellipses in the template is misplaced.

[usaoc]

Repetitions only work in a “flat” manner, not in a “nested” manner as in your example. Similar to Racket, the way to achieve nesting is through recursion, so there are a couple of approaches here:

1. Explicit recursion with recur, like

expr.macro 'curry ($arg, ...) ... ~nonempty: $body':
  recur loop(argss = ['($arg, ...)', ...]):
    match argss
    | [args, more, ...]:
        'fun $args: $(loop([more, ...]))'
    | []:
        body

2. Expand to self, like

expr.macro 'curry ($arg, ...) ... ~nonempty: $body':
  match ['($arg, ...)', ...]
  | [args]:
      'fun $args: $body'
  | [args, more, ...]:
      'fun $args: curry $more ...: $body'

3. Something like Racket for/foldr, which is currently lacking.

I also adjusted a few things: the argument template is changed to ($arg, ...) to support multiple arguments (but you may have meant single arguments only), and ... is annotated ~nonempty to invalidate “no argument” case. Moreover, your curry form should be an expression form, not a definition form. It isn’t difficult to extend it to support definitions, though:

meta fun make_curry(argss, body):
  recur loop(argss = argss):
    match argss
    | [args, more, ...]:
        'fun $args: $(loop([more, ...]))'
    | []:
        body

expr.macro 'curry ($arg, ...) ... ~nonempty: $body':
  make_curry(['($arg, ...)', ...], body)

defn.macro
| 'curry $(name :: Name) ($arg, ...) ... ~nonempty: $body':
    'def $name:
       $(make_curry(['($arg, ...)', ...], body))'
| 'curry ($arg, ...) ... ~nonempty: $body':
    make_curry(['($arg, ...)', ...], body)

The definition form needs to fall back to the expression case in block contexts, so the actual work is lifted to a meta-time function.

More things to consider for a full-fledged form:

• support for result annotations?
• more precise arity infos? ((curry (a)(b)(c): a + b + c)(1)(2, 3) should be a static error, for example)

(Actually, has anyone considered extending fun to support curried definitions?)

[Forthoney]

Thank you for the in-depth reply! It would be helpful to have a subsection in Syntax Objects and Macros about recursive macros: how to use them, when to use them, code examples, etc. I completely forgot about the existence of recursive macros, and I suspect that people unfamiliar with Racket may be on a similar boat.

[Forthoney]

Also, a followup technical question: is there a fundamental reason why repetitions only work in a flat manner? I assume nested repetitions are at odds with some mechanism of macros, but I'm having trouble thinking of a concrete instance where this may arise.

[usaoc]

Also, a followup technical question: is there a fundamental reason why repetitions only work in a flat manner?

Afaik, there isn’t any technical reason why it cannot work for nesting. The reason is more historical: this is how ellipsis in Racket works, which goes back to Scheme and eventually the well-established notation traditionally used in theoretical literature. (Guy Steele’s talk on “Computer Science Metanotation” briefly mentions ellipsis, and indeed ellipsis seems to be used for nesting as well, but it’s significantly rarer and more limited.) Generally, it seems that ellipsis is most intuitively for flat, sequential repetitions, and its implementation also suggests that: underlyingly, repetitions are really just another way to write for forms. That said, I think nesting in limited cases is technically possible, but just no one has made a proposal about that.