partitioning keyword arguments

Hello all,

This is a slightly more general Lisp oriented question, so perhaps I
should have sent it off to c.l.l, but all my examples are going to be
CAPI based, and I bet someone here has had to deal with these issues
before.

There is a macro capi:with-dialog-results which allows for (on OS X)
dialogs which are modal per window (and not for the whole
application.) For instance,

(capi:with-dialog-results (str okp)
    (capi:prompt-for-string "Enter a string")
  (when okp
    (print str)))

Now this is just syntactic sugar for (essentially) the following:

(capi:prompt-for-string
  "Enter a string"
  :continuation
  #'(lambda (str okp)
        (when okp
           (print string))))

so the point to notice is that the prompting function accepts a
:continuation keyword argument. Now prompt-for-string also accepts a
:text keyword argument specifiying initial-text for the prompt.

Now I'm trying to do something similar. Let's say I have
username/password prompt (i.e., an interface with text-input-panes for
username/password). I can display a prompt using capi:popup-confirmer,
like this:

(capi:popup-confirmer
   (make-instance
    'password-prompt
    :username username
    :password password)
    "Enter username and password:"
    :value-function #'combine-username-password))

and I'd like to wrap this up in a function, e.g.,

(defun prompt-for-username-and-password (&key username password)
  (capi:popup-confirmer
     (make-instance
      'password-prompt
      :username username
      :password password)
      "Enter username and password:"
      :value-function #'combine-username-password)))

but I'd also like to be able to use it in capi:with-dialog-results,
and so I need to have a continuation keyword:

(defun prompt-for-username-and-password (&key username password continuation)
  (capi:popup-confirmer
     (make-instance
      'password-prompt
      :username username
      :password password)
      "Enter username and password:"
      :value-function #'combine-username-password)
   :continuation continuation))

but at this point, it's clear that there a number of the
popup-confirmer args that I might want to use (e.g., owner, to make
sure that the popup is on the correct window.) Ideally I'd like to
have all these args mixed together, so as to be able to write

(defun prompt-for-username-and-password (&rest initargs &key username password)
  (apply #'capi:popup-confirmer
     (make-instance
      'password-prompt
      :username username
      :password password)
      "Enter username and password:"
      :value-function #'combine-username-password)
  initargs-w/o-username-and-password))

That is, I'd like to grab a few keyword arguments myself, and then to
send the rest of them on to the popup-confirmer. I need this behavior
so that my prompting functions can be used in a consistent manner as
the standard capi prompts.

Now, I realize that although capi:prompt-for-string has a
:continuation argument, there is still :popup-args (and
popup-confirmer /also/ accepts a :continuation argument) so things
like this can be written:

(capi:prompt-for-string
 "enter a string"
 :continuation #'(lambda (&rest args)
                   (print (cons 'prompt-for-string args)))
 :popup-args (list :continuation #'(lambda (&rest args)
                                     (print (cons 'popup-confirmer args)))))

and the result is that the continuation mentioning prompt-for-string
is invoked. So perhaps the best choice is provide :popup-args and
:continuation for my prompting functions and to hope for the best?

Thanks in advance!

-- 
=====================
Joshua Taylor
tayloj@rpi.edu

"A lot of good things went down one time,
     back in the goodle days."
               John Hartford