> I'm starting to get lost in all these options.  Here's how I think things
> should look:
>
>          (call/kw name expr ... marker :kw expr :kw  expr ...)
>
> I don't care exactly what the marker is.  But this way it looks exactly
> like a normal function call except for the leading call/kw and the marker.
> If a user thinks call/kw is too verbose, it's easy to write a syntax-rules
> macro that lets you use a shorter (or even longer) name.
>
> I also don't care if the keyword identifiers have colons in them or not.

> And by the same token:
>
>          (lambda/kw (identifier ... marker identifier ...) . body)
>
> Again, it looks as much like plain lambda as it possibly could.

I like this, and it's basically what all the implementation-native
syntax already use.

> Thirdly, I would also like this:
>
>          (define/kw (procname identifier ... marker identifier ...) . body)

I've had `define` in mind from the beginning, but have kept it out on
grounds of simplicity. I still don't know what to do about it. SRFI 89
has `define*`.

My worry is there may be Scheme implementations where `define` is magic
so that `(define x (lambda (y z) ...))` is not an adequate substitute
for `(define (x y z) ...)`. Care has to be taken so that 177's
`define/kw` would expand into a `(define (x ...) ...)` form instead of
`(define x <whatever>)`. Then we can probably ensure that any subtleties
of the implementation's `define` are preserved, and it would be fine.

Editor indentation is also worth keeping in mind. Luckily, Emacs already
indents both (define x (lambda/kw ...)) and (define/kw ...) correctly.

> What do you think of this design?  It sacrifices the possibility of a
> syntax-rules implementation, and it doesn't allow for these mythical
> hygienic keywords, but I don't care about either of these points.  Because
> this is simple to use.

I have the same priorities as you.

Based on the above meditations, a `define/kw` is probably fine. But
something about it makes me intuitively cautious; I can't tell what it
is. Probably that too many `define` forms in the language can cause
confusion. It's clear that `lambda/whatever` defines some kind of
procedure, but does `define/whatever` define a procedure or some other
kind of object? Of course one can look all that up in the documentation,
but I always try to go for designs that remove the need for subconscious
worries and diligence. From a usability standpoint, I love `lambda/kw`
since it fits like a glove: everyone already knows what lambda is. Maybe
we should try writing some sample code with `define/kw` to see if we get
used to it.

> Question:  You can use apply to call a kw-procedure with no keywords.  Does
> that also mean you can call it directly without call/kw?

Yes, absolutely. That's one of the most important properties of the
current design to me. One less thing for users (and people adding
keywords to previously non-keyword procedures) to worry about!