Interesting to hear the opposite point of view from you :) For me,
keyword args are one of the most frequent things I miss.

> I never use keyword argument in Scheme. In Python I use them for documentation
> purpose, but good naming can avoid that problem.

In my experience, it can't. In a big program or complex library there
are going to be a few procedures where it's not possible to plan years
ahead. Emacs has many good examples, for example.

> FWIW, Guile has them in a
> convoluted way (you can reference arguments in other arguments and their are
> bound at call time) and I find it... disturbing. At some point Python
> arguments will
> be Turing Complete for sure.

:D Common Lisp also has a super-convoluted argument syntax when you go
into the details (but like most things in CL, it's very consistent, so
that's nice). I agree that it goes too far.

> FWIW, the worst thing in keyword arguments in Python is the **kwargs which
> is equivalent to Guile #:allow-other-keys.

Common Lisp also has that (it's called &allow-other-keys there too). I
like it - not good for most things, but it can help save the day where
you or someone else messed up the design. That's much of the point of
keyword arguments in general: compensate for innate weaknesses in human
planning ability.

> Yes Guile use #:keyword for keywords
> another thing that is disturbing. People end up abusing **kwargs and pass around
> all the keys and only pick what they want / need when they need it.

Clojure (well, Rich Hickey) actively encourages this kind of mentality.
I think his arguments are consistent and I respect them. Like most good
things, it can be taken too far.

In Python, keyword arguments compensate for the lack of macros a lot. In
a Lisp they probably wouldn't need to be as flexible.

> I think adding keyword, will make procedure signature much more difficult.
>
> The solution to use alist or case-lambda is enough complication.
>
> What I was thinking about this topic, is not introduce another datum
> like :keyword
> or #:keyword but instead create some argument parser procedure like used
> for command line arguments. This is backward compatible and build upon existing
> knowledge.
>
> E.g.
>
> (define (my-procedure . args)
>    (receive (parse-args '--wal? '--in-memory?)
>      (wal? in-memory?) ....)))

I've spent a lot of time thinking about Unix argument parsers, and it's
likely the solution will not be simpler than keyword arguments :)

I personally love the way Common Lisp and Python do them. (But Common
Lisp goes too far with the lambda list syntax. Python may go to far as
well; I haven't followed its development in the last 2-3 years.)

> I don't know what are plist.

plist = property list. The same thing as an alist (association list),
but the association pairs are flattened. For this example alist:

     '((foo . #t) (bar . 2) (baz 3 4))

The equivalent plist is:

     '(foo #t bar 2 baz (3 4))

Hence a plist must always have an even number of items (can be zero).
They are used in Common Lisp and Emacs Lisp quite a lot.