Using #!optional, #!rest, and #!key together

["Sudarshan S Chawathe" <chaw at eip10 dot org>]

Some background: I'd like to define a procedure that accepts a few
keyword-arguments as well as a variable number of non-keyword arguments
(both required and optional).  So, I'm looking at using #!optional,
#!rest, and #!key together but am confused by the specification.

Which brings me to my main, somewhat vague, question:

  1.   What is a good way to achieve the above (in Kawa)?  

My more specific questions follow.

  2. When a lambda uses #!key, my reading of the specification seems to
     require an even number of actual arguments following the
     required+optional actual arguments in a corresponding invocation,
     even if there is a #!rest. Is that really the case?

  3. To be even more specific, given

       (define (test-args a b #!optional c d #!rest e
                          #!key (f 'vf) (g 'vg))
         (list a b c d e f g))

     is it true that the first of the following is OK but the second is
     an error? 

       (test-args 1 2 3 4 5 6 f: 7 g: 8)

       (test-args 1 2 3 4 5 f: 6 g: 7)

Kawa doesn't flag an error (which is fine, I understand), but binds f
and g to 7 and 8 in the first case, and to their default values vf and
vg in the second case, so it does seem to treat them quite differently.

My confusion is probably not specific to Kawa, as the relevant text in
the manual is probably essentially from the DSSSL spec (based on similar
text in other manuals).  However, Chicken and Bigloo (just the ones I
looked at) seem to have implemented extensions that work around the
above issues and I'm trying to figure out a suitable strategy using
Kawa.

I'm guessing others have encountered similar situations and have some
good solutions, which I would love to hear.

Regards,

-chaw