As nuntius says, the ANSI Spec is the final say on anything within ANSI Common Lisp.
I think it is fair to say that in some sense, there are no key/reserved words in Common Lisp. That is, in terms of syntactic elements, no
token in Common Lisp is reserved. Common Lisp, however, has some restrictions on
symbols, which have a meaning outside of pure syntax. To be precise, any symbol that comes from the Common-Lisp package has restrictions placed on what it can be used for (actually, the spec says "the consequences are undefined if..." but that is just how the spec says "if you do this, don't expect anything good to happen" (see "11.1.2.1.2 Constraints on the COMMON-LISP Package for Conforming Programs" in the Spec)). So, the reserved words in Common Lisp are kind of like all of the symbols exported from the Common-Lisp package. The spec tells me that there are 978 exported symbols from the Common-Lisp package. In some sense, there are 978 reserved words in Common Lisp. This is a result of the fact that ANSI Common Lisp is a tremendously large language.
That said, you don't need to know all of the exported symbols of the Common-Lisp package in order to be productive (I certainly don't, but believe I am productive).
In most languages, the reserved words are syntactic markers that typically indicate a change in syntax. In Common Lisp, this most closely maps onto something we would call a special form or a macro (two different things but either typically mark a change in syntactic structure). These are much less frequent than the actual symbols that are restricted; there are some 25 special forms (see "3.1.2.1.2.1 Special Forms" in the Spec):
block let* return-from catch quote
load-time-value setq eval-when
locally symbol-macrolet flet macrolet
tagbody function multiple-value-call
the go multiple-value-prog1 throw if
progn unwind-protect labels progv let
...and another 91 standard macros (exported from the Common-Lisp package):
CL-USER> (let ((count 0))
(do-external-symbols (sym (find-package :common-lisp))
(when (and (ignore-errors (macro-function sym))
(not (member sym '(block let* return-from catch
load-time-value setq eval-when
locally symbol-macrolet flet macrolet
tagbody function multiple-value-call
the go multiple-value-prog1 throw if
progn unwind-protect labels progv let
quote))))
(let ((*print-case* :downcase))
(print sym))
(incf count)))
count)
untrace decf and case do-external-symbols handler-case when
pprint-logical-block remf call-method define-compiler-macro
with-open-stream with-compilation-unit do-all-symbols or cond
defpackage with-hash-table-iterator ctypecase defgeneric
etypecase dotimes multiple-value-list pop restart-case defclass
with-output-to-string rotatef with-slots
pprint-exit-if-list-exhausted with-input-from-string do typecase
psetq pprint-pop assert with-accessors handler-bind do*
print-unreadable-object define-setf-expander do-symbols
with-open-file with-package-iterator restart-bind defun trace
prog1 setf defstruct check-type defmacro dolist step unless ccase
deftype multiple-value-setq ecase loop formatter ignore-errors
time lambda destructuring-bind shiftf loop-finish
multiple-value-bind defsetf prog define-method-combination
declaim pushnew with-standard-io-syntax define-modify-macro psetf
in-package defparameter with-simple-restart
with-condition-restarts defmethod nth-value incf defconstant
define-symbol-macro push define-condition prog* return defvar
prog2
91
...with some slight formatting for saving space. These are in some sense the keywords of Common Lisp that you are looking for. Sorry I can't group them by purpose right now... you can consult the Spec to understand what each does.
