How to raise an error when unrecogized keyword arguments are passed to a function?

Question

With a function that uses keyword arguments using this style of function definition:

(defun some-name (&rest kwargs)
  (plist-get kwargs 'example))

Is there a convenient way to ensure only supported keyword-arguments as passed in?

So a typo in a keyword argument doesn't pass by unnoticed.

Answer 1

cl-defun handles this usecase:

(require 'cl-lib)
(cl-defun test (&key foo bar)
  (list foo bar))

(test :foo 1 :bar 2) ; (1 2)
(test :foo 1 :bar 2 :baz 3) ; Error: "Keyword argument :baz not one of (:foo :bar)"

In case you want the opposite behavior, pass &allow-other-keys after the key list.

Answer 2

This can be done by parsing the keyword arguments directly.

;; Function that takes two optional keyword arguments: `example-a', `example-b'.
(defun some-name (&rest kwargs)
  ;; Two example keywords.
  (let ((example-a-as-var nil)
        (example-b-as-var nil))

  ;; Extract keyword args.
    (let ((kw-iter keyword-args))
      (while kw-iter
        (let ((kw-key (pop kw-iter))
              (kw-val (pop kw-iter)))
          (cond
           ((eq kw-key :example-a) (setq example-a-as-var kw-val))
           ((eq kw-key :example-b) (setq example-b-as-var kw-val))
           (t (error "Unknown keyword argument %S" kw-key))))))
    ;; End argument extraction/validation.

    ;; function body.
    ))