(define-syntax curried-lambda
(syntax-rules ()
((_ () exp exps …)
(lambda as
(cond ((null? as) exp exps …)
(else (apply (begin exp exps …) as)))))
((_ (arg args …) exp exps …)
(letrec ((papp (lambda as
(cond ((null? as) papp)
(else (let ((arg (car as)))
(apply (curried-lambda (args …) exp exps …) (cdr as))))))))
papp))))

The code above provides both.

(define id (curried (x) x))

uses the lambda form (perhaps ‘curried’ should be renamed ‘curried-lambda’ ?)

On the other hand,

(define-curried (id x) x)

provides a definition with a curried argument list in the same fashion that (define (id x) x) desugars to (define id (lambda (x) x)) — a convenience that I seem to recall you don’t like using. ;)

I noticed that one of the comments mentioned using a curried lambda. I think that having
a curried lambda instead of a curried define
makes much more sense, given that the define
is like let/letrec/ etc., but it is lambda that absorbs values.

… Dan

It looks like my parametricity concern was a bit of a misapprehension. I wasn’t able to concoct a scenario where it led to a problem. ;)

If we ignore the existence of nullary functions the new version works really well, as would, I suppose, your fix.

I like your fix; a definite improvement! Can you offer more detail on your parametricity concern, though? Like many others, I, too, have a toy monad library in my collection, but it’s not obvious to me how this situation with my proposed patch raises a problem in that area.

Nice macro. =) While, alas, it doesn’t handle over or null application, it is really succinct!

Good point. I was trying to avoid discriminating, so I could just work parametrically, but a quick procedure? check isn’t such a high price to pay to handle the base case more gracefully.

I have two concerns with this proposed fix though.

1. One is that this will silently eat the remaining arguments when you try to handle a non-procedure. Perhaps it should do the null? check on args rather than swallow them in the non-procedure case.
2. The other is more subtle and has to do with parametricity. Since we now may or may not invoke the result, I might not be able to use this in a number of situations inside of my toy monad library.

By redefining (define-curried name body) to just use a define and migrating its current behavior to (define-curried (name) body) this obtains, perhaps a more pleasing result. Patching it thus:

((_ () body)
     (lambda args
         (if (null? args)
             body
             (apply body args))))

yields a result that is identical to the handling of the other two cases in behavior.

Then (define-curried x 5) does the right thing, and just gives you 5.
and (define-curried (x) 5) gives you a nullary function that when invoked will give you back 5, but will try to pass any superfluous over-applied arguments to 5 and crash.

One option might be,
((_ () body)
(λ args (let ((r body))
(if (procedure? r)
(apply r args)
r))))

Then I can have something like,
(define-curried x (begin (printf “hi~n”) 5))
that does the right thing, afaict.