> `let-optionals' has the advantage that we do no need any heavy new
> syntax to call and to define procedures taking optional arguments.  It
> also has the advantage that no new concept is needed (namely that of
> keyword arguments).
>
> It is no full replacement for keyword arguments, though.  You can
> meaningfully redo a procedure like `fox' from SRFI 183 with keyword
> arguments but not with optional arguments in the sense of `let-optionals'.

Agreed.

As Amirouche mentioned, there's a similar `let-keywords` in Chibi. IMHO
it has the same problem: it's not part of a standard lambda list
definition, so it's harder for humans and machines to analyze.

> Thus, the answer also depends on whether we want and need to have the
> full power of keyword arguments (and the full potential of abusing them)
> in R7RS-large or whether we think it is possible and sensible to stick
> to the way optional arguments have been handled so far in
> R7RS-small/R7RS-large.

IMHO we should consider the prior art here. People have written large
Lisp systems for decades. If one can be found that avoids keyword args
and is still easy to read, it would make for a good case study.

In Emacs, the parts lifted from (or inspired by) CL use keyword args,
and they are easier to read than the parts using positional optional
args. RMS didn't like keyword arguments so they were kept out for long.

> I haven't understood Lassi's argument about standardization, though.  As
> much as `call/kw' can be standardized, so can `let-optionals'.

Sorry, I was using the word "standard" ambiguously. I mean
standardization in the sense that different programmers would do the
same task the same way, i.e. conventions.

If optional arguments are done via case-lambda or SRFI 89, it's easier
to write tools like a documentation generator or an optimizer since
those tools have a standard place where to look for optional (and
keyword) arguments.

If it's just ordinary Scheme code matching on a lambda-list, the
analysis for tools (and humans) to figure out whether it parses the
procedure's arguments, or something else entirely, becomes harder. Every
time I see a let-optionals or let-keywords, I need to stop and verify
what it's doing. I've never had that feeling in Common Lisp, where
optional and keyword args are always in a natural place in the lambda
list itself. CL also has destructuring-bind (similar to Scheme's `
match`; a superset of let-optionals) for arbitrary lists. You can use it
to parse a rest argument, but people always use the standard optional
and keyword arguments. The convention makes code easy to read and
process. I'd like to have similar conventions for Scheme; hence a
standard case-lambda is a step in the right direction, and a standard
lambda/kw or define/kw (or their superset) could be another.

> Some may
> even say that the advantage of the latter is that it has been in use for
> a long time (for example, the reference implementation of SRFI 1 from
> 1998/99 is already using `let-optionals').

Keyword arguments have been used for decades in Lisp. If they were a new
invention, I'd be more suspicious.