Am Fr., 24. Apr. 2020 um 01:36 Uhr schrieb John Cowan <xxxxxx@ccil.org>:

[...]

> The idea is to correctly take apart (lambda/kw (foo ... &kw baz ...) ...) and reassemble it, where &kw is a syntax keyword.

In any case, this syntax has to be amended if we do not want to have
the keyword `baz' bound to the lexical identifier with the name `baz'.
Apart from that symbols shouldn't be muddled with identifiers, the
body of `lambda/kw' may want to easily access a `baz' defined outside.

> The Chibi approach is absolutely workable and portable, but does not allow interoperability with native keyword arguments in those Schemes that have them.  What is more, if the compiler understands and can efficiently compile keywords, as Racket can, using Chibi-style keywords instead is a performance hit.  So we need a macro wrapper for each call with keywords (you don't need the wrapper if you are omitting all of them) to generate the correct procedure call.

Unless we are turning procedures taking keyword arguments into macros,
for all keyword approaches we have discussed so far help from the
compiler is needed to efficiently compile the call. Such a compiler
can equally well optimize a procedure call with keyword arguments in
the form `(foo 1 2 'bar 3 'baz 4)', where the symbols `bar' and `baz'
introduce optional arguments.

In terms of language complexity, this looks more convincing to me than
introducing keyword objects just to be able to write `(foo 1 2 :bar 3
:baz 4)'.

If one really wants this, one could add to the expander a new binding
form `(define-name <id> <symbol>)', which binds `<id>' to a unique (!)
entity, which evaluates to `<symbol>'. A library `(foo)' that uses the
arguments keywords `bert' and `ernie' would contain `(define-name
:bert bert)' and `(define-name :ernie ernie)' and export `:bert' and
`:ernie'. A user could then write `(foo 1 2 :bert 3 :ernie 4)'.

The library `(quux)' may make use of `bert' and `kermit', so it will
export `:bert' and `:kermit' using the same machinery. The binding of
`:bert' will, however, not clash with the binding of `:bert' in
`(foo)' because the bindings are exactly the same by the special
property of the `define-name' binding form.