(setf class-name) new-value class => new-value
* &rest numbers => product
+ &rest numbers => sum
- number => negation
- minuend &rest subtrahends+ => difference
/ number => reciprocal
/ numerator &rest denominators+ => quotient
1+ number => successor
1- number => predecessor
= &rest numbers+ => generalized-boolean
/= &rest numbers+ => generalized-boolean
< &rest numbers+ => generalized-boolean
> &rest numbers+ => generalized-boolean
<= &rest numbers+ => generalized-boolean
>= &rest numbers+ => generalized-boolean
abort &optional condition =>| 
 continue &optional condition => nil
muffle-warning &optional condition =>| 
 store-value value &optional condition => nil
use-value value &optional condition => nil
abs number => absolute-value
acons key datum alist => new-alist
add-method generic-function method => generic-function
adjoin item list &key key test test-not => new-list
adjust-array array new-dimensions &key element-type initial-element initial-contents fill-pointer displaced-to displaced-index-offset => adjusted-array
adjustable-array-p array => generalized-boolean
allocate-instance class &rest initargs &key &allow-other-keys => new-instance
alpha-char-p character => generalized-boolean
alphanumericp character => generalized-boolean
and form* => result*
append &rest lists => result
apply function &rest args+ => result*
apropos string &optional package => <no values>
apropos-list string &optional package => symbols
aref array &rest subscripts => element
(setf (aref array &rest subscripts) new-element)
arithmetic-error-operands condition => operands
arithmetic-error-operation condition => operation
array-dimension array axis-number => dimension
array-dimensions array => dimensions
array-displacement array => displaced-to, displaced-index-offset
array-element-type array => typespec
array-has-fill-pointer-p array => generalized-boolean
array-in-bounds-p array &rest subscripts => generalized-boolean
array-rank array => rank
array-row-major-index array &rest subscripts => index
array-total-size array => size
arrayp object => generalized-boolean
ash integer count => shifted-integer
asin number => radians
acos number => radians
atan number1 &optional number2 => radians
assert test-form [(place*) [datum-form argument-form*]] => nil
assoc item alist &key key test test-not => entry
 assoc-if predicate alist &key key => entry
assoc-if-not predicate alist &key key => entry
atom object => generalized-boolean
bit-and bit-array1 bit-array2 &optional opt-arg => resulting-bit-array
bit-andc1 bit-array1 bit-array2 &optional opt-arg => resulting-bit-array
bit-andc2 bit-array1 bit-array2 &optional opt-arg => resulting-bit-array
bit-eqv bit-array1 bit-array2 &optional opt-arg => resulting-bit-array
bit-ior bit-array1 bit-array2 &optional opt-arg => resulting-bit-array
bit-nand bit-array1 bit-array2 &optional opt-arg => resulting-bit-array
bit-nor bit-array1 bit-array2 &optional opt-arg => resulting-bit-array
bit-orc1 bit-array1 bit-array2 &optional opt-arg => resulting-bit-array
bit-orc2 bit-array1 bit-array2 &optional opt-arg => resulting-bit-array
bit-xor bit-array1 bit-array2 &optional opt-arg => resulting-bit-array
bit-not bit-array &optional opt-arg => resulting-bit-array
bit-vector-p object => generalized-boolean
bit bit-array &rest subscripts => bit
sbit bit-array &rest subscripts => bit
(setf (bit bit-array &rest subscripts) new-bit)
(setf (sbit bit-array &rest subscripts) new-bit)
block name form* => result*
boole op integer-1 integer-2 => result-integer
boundp symbol => generalized-boolean
break &optional format-control &rest format-arguments => nil
broadcast-stream-streams broadcast-stream => streams
butlast list &optional n => result-list
nbutlast list &optional n => result-list
byte size position => bytespec
byte-size bytespec => size
byte-position bytespec => position
call-method method &optional next-method-list => result*
make-method form => method-object
call-next-method &rest args => result*
car x => object
cdr x => object
caar x => object
cadr x => object
cdar x => object
cddr x => object
caaar x => object
caadr x => object
cadar x => object
caddr x => object
cdaar x => object
cdadr x => object
cddar x => object
cdddr x => object
caaaar x => object
caaadr x => object
caadar x => object
caaddr x => object
cadaar x => object
cadadr x => object
caddar x => object
cadddr x => object
cdaaar x => object
cdaadr x => object
cdadar x => object
cdaddr x => object
cddaar x => object
cddadr x => object
cdddar x => object
cddddr x => object(setf (car x) new-object)
(setf (cdr x) new-object)
(setf (caar x) new-object)
(setf (cadr x) new-object)
(setf (cdar x) new-object)
(setf (cddr x) new-object)
(setf (caaar x) new-object)
(setf (caadr x) new-object)
(setf (cadar x) new-object)
(setf (caddr x) new-object)
(setf (cdaar x) new-object)
(setf (cdadr x) new-object)
(setf (cddar x) new-object)
(setf (cdddr x) new-object)
(setf (caaaar x) new-object)
(setf (caaadr x) new-object)
(setf (caadar x) new-object)
(setf (caaddr x) new-object)
(setf (cadaar x) new-object)
(setf (cadadr x) new-object)
(setf (caddar x) new-object)
(setf (cadddr x) new-object)
(setf (cdaaar x) new-object)
(setf (cdaadr x) new-object)
(setf (cdadar x) new-object)
(setf (cdaddr x) new-object)
(setf (cddaar x) new-object)
(setf (cddadr x) new-object)
(setf (cdddar x) new-object)
(setf (cddddr x) new-object)
case keyform {normal-clause}* [otherwise-clause] => result*
ccase keyplace {normal-clause}* => result*
ecase keyform {normal-clause}* => result*
normal-clause::= (keys form*) 
otherwise-clause::= ({otherwise | t} form*) 
clause::= normal-clause | otherwise-clause 
catch tag form* => result* cell-error-name condition => name cerror continue-format-control datum &rest arguments => nil change-class instance new-class &key &allow-other-keys => instance char-code character => code char-int character => integer char-name character => name char-upcase character => corresponding-character char-downcase character => corresponding-character char string index => character schar string index => character (setf (char string index) new-character) (setf (schar string index) new-character) char= &rest characters+ => generalized-boolean char/= &rest characters+ => generalized-boolean char< &rest characters+ => generalized-boolean char> &rest characters+ => generalized-boolean char<= &rest characters+ => generalized-boolean char>= &rest characters+ => generalized-boolean char-equal &rest characters+ => generalized-boolean char-not-equal &rest characters+ => generalized-boolean char-lessp &rest characters+ => generalized-boolean char-greaterp &rest characters+ => generalized-boolean char-not-greaterp &rest characters+ => generalized-boolean char-not-lessp &rest characters+ => generalized-boolean character character => denoted-character characterp object => generalized-boolean check-type place typespec [string] => nil cis radians => number class-name class => name class-of object => class clear-input &optional input-stream => nil close stream &key abort => result clrhash hash-table => hash-table code-char code => char-p coerce object result-type => result compile-file-pathname input-file &key output-file &allow-other-keys => pathname compile-file input-file &key output-file verbose print external-format => output-truename, warnings-p, failure-p compile name &optional definition => function, warnings-p, failure-p compiled-function-p object => generalized-boolean compiler-macro-function name &optional environment => function (setf (compiler-macro-function name &optional environment) new-function) complement function => complement-function complex realpart &optional imagpart => complex complexp object => generalized-boolean compute-applicable-methods generic-function function-arguments => methods compute-restarts &optional condition => restarts concatenate result-type &rest sequences => result-sequence concatenated-stream-streams concatenated-stream => streams cond {clause}* => result*
clause::= (test-form form*) 
conjugate number => conjugate cons object-1 object-2 => cons consp object => generalized-boolean constantly value => function constantp form &optional environment => generalized-boolean copy-alist alist => new-alist copy-list list => copy copy-pprint-dispatch &optional table => new-table copy-readtable &optional from-readtable to-readtable => readtable copy-seq sequence => copied-sequence copy-structure structure => copy copy-symbol symbol &optional copy-properties => new-symbol copy-tree tree => new-tree count item sequence &key from-end start end key test test-not => n count-if predicate sequence &key from-end start end key => n count-if-not predicate sequence &key from-end start end key => n declaim declaration-specifier* => implementation-dependent declare declaration-specifier* decode-float float => significand, exponent, sign scale-float float integer => scaled-float float-radix float => float-radix float-sign float-1 &optional float-2 => signed-float float-digits float => digits1 float-precision float => digits2 integer-decode-float float => significand, exponent, integer-sign decode-universal-time universal-time &optional time-zone => second, minute, hour, date, month, year, day, daylight-p, zone defclass class-name ({superclass-name}*) ({slot-specifier}*) [[class-option]] => new-class
slot-specifier::= slot-name | (slot-name [[slot-option]])
slot-name::= symbol
slot-option::= {:reader reader-function-name}* | 
               {:writer writer-function-name}* | 
               {:accessor reader-function-name}* | 
               {:allocation allocation-type} | 
               {:initarg initarg-name}* | 
               {:initform form} | 
               {:type type-specifier} | 
               {:documentation string} 
function-name::= {symbol | (setf symbol)}
class-option::= (:default-initargs . initarg-list) | 
                (:documentation string) | 
                (:metaclass class-name) 

defconstant name initial-value [documentation] => name defgeneric function-name gf-lambda-list [[option | {method-description}*]] => new-generic

option::= (:argument-precedence-order parameter-name+) | 
          (declare gf-declaration+) | 
          (:documentation gf-documentation) | 
          (:method-combination method-combination method-combination-argument*) | 
          (:generic-function-class generic-function-class) | 
          (:method-class method-class) 
method-description::= (:method method-qualifier* specialized-lambda-list [[declaration* | documentation]] form*) 
define-compiler-macro name lambda-list [[declaration* | documentation]] form* => name define-condition name (parent-type*) ({slot-spec}*) option* => name
slot-spec::= slot-name | (slot-name slot-option) 
slot-option::= [[{:reader symbol}* |  
               {:writer function-name}* |  
               {:accessor symbol}* |  
               {:allocation allocation-type} |  
               {:initarg symbol}* |  
               {:initform form} |  
               {:type type-specifier} ]] 
option::= [[(:default-initargs . initarg-list) |  
          (:documentation string) |  
          (:report report-name) ]] 
function-name::= {symbol | (setf symbol)} 
allocation-type::= :instance | :class 
report-name::= string | symbol | lambda expression 
define-method-combination name [[short-form-option]] => name define-method-combination name lambda-list (method-group-specifier*) [(:arguments . args-lambda-list)] [(:generic-function generic-function-symbol)] [[declaration* | documentation]] form* => name
short-form-option::= :documentation documentation |  
                     :identity-with-one-argument identity-with-one-argument | 
                     :operator operator 
method-group-specifier::= (name {qualifier-pattern+ | predicate} [[long-form-option]]) 
long-form-option::= :description description | 
                    :order order | 
                    :required required-p 
define-modify-macro name lambda-list function [documentation] => name define-setf-expander access-fn lambda-list [[declaration* | documentation]] form* => access-fn define-symbol-macro symbol expansion => symbol defmacro name lambda-list [[declaration* | documentation]] form* => name defmethod function-name {method-qualifier}* specialized-lambda-list [[declaration* | documentation]] form* => new-method function-name::= {symbol | (setf symbol)} method-qualifier::= non-list
specialized-lambda-list::= ({var | (var parameter-specializer-name)}* 
                            [&optional {var | (var [initform [supplied-p-parameter] ])}*] 
                            [&rest var] 
                            [&key{var | ({var | (keywordvar)} [initform [supplied-p-parameter] ])}*
                                 [&allow-other-keys] ] 
                            [&aux {var | (var [initform] )}*] ) 
parameter-specializer-name::= symbol | (eql eql-specializer-form)

defpackage defined-package-name [[option]] => package

option::= (:nicknames nickname*)* |  
          (:documentation string) |  
          (:use package-name*)* |  
          (:shadow {symbol-name}*)* |  
          (:shadowing-import-from package-name {symbol-name}*)* |  
          (:import-from package-name {symbol-name}*)* |  
          (:export {symbol-name}*)* |  
          (:intern {symbol-name}*)* |  
          (:size integer) 
defparameter name initial-value [documentation] => name defvar name [initial-value [documentation]] => name defstruct name-and-options [documentation] {slot-description}* => structure-name
name-and-options::= structure-name | (structure-name [[options]]) 
options::= conc-name-option | 
           {constructor-option}* | 
           copier-option | 
           include-option | 
           initial-offset-option | 
           named-option | 
           predicate-option | 
           printer-option | 
conc-name-option::= :conc-name | (:conc-name) | (:conc-name conc-name) 
constructor-option::= :constructor | 
                      (:constructor) | 
                      (:constructor constructor-name) | 
                      (:constructor constructor-name constructor-arglist) 
copier-option::= :copier | (:copier) | (:copier copier-name) 
predicate-option::= :predicate | (:predicate) | (:predicate predicate-name) 
include-option::= (:include included-structure-name {slot-description}*) 
printer-option::= print-object-option | print-function-option 
print-object-option::= (:print-object printer-name) | (:print-object) 
print-function-option::= (:print-function printer-name) | (:print-function) 
type-option::= (:type type) 
named-option::= :named 
initial-offset-option::= (:initial-offset initial-offset) 
slot-description::= slot-name |  
                    (slot-name [slot-initform [[slot-option]]]) 
slot-option::= :type slot-type |  
               :read-only slot-read-only-p 
deftype name lambda-list [[declaration* | documentation]] form* => name defun function-name lambda-list [[declaration* | documentation]] form* => function-name delete-file filespec => t delete-package package => generalized-boolean deposit-field newbyte bytespec integer => result-integer describe-object object stream => implementation-dependent describe object &optional stream => <no values> destructuring-bind lambda-list expression declaration* form* => result* digit-char-p char &optional radix => weight digit-char weight &optional radix => char directory pathspec &key => pathnames disassemble fn => nil do-symbols (var [package [result-form]]) declaration* {tag | statement}* => result* do-external-symbols (var [package [result-form]]) declaration* {tag | statement}* => result* do-all-symbols (var [result-form]) declaration* {tag | statement}* => result* do ({var | (var [init-form [step-form]])}*) (end-test-form result-form*) declaration* {tag | statement}* => result* do* ({var | (var [init-form [step-form]])}*) (end-test-form result-form*) declaration* {tag | statement}* => result* documentation x doc-type => documentation (setf documentation) new-value x doc-type => new-value dolist (var list-form [result-form]) declaration* {tag | statement}* => result* dotimes (var count-form [result-form]) declaration* {tag | statement}* => result* dpb newbyte bytespec integer => result-integer dribble &optional pathname => implementation-dependent echo-stream-input-stream echo-stream => input-stream echo-stream-output-stream echo-stream => output-stream ed &optional x => implementation-dependent elt sequence index => object (setf (elt sequence index) new-object) encode-universal-time second minute hour date month year &optional time-zone => universal-time endp list => generalized-boolean ensure-directories-exist pathspec &key verbose => pathspec, created ensure-generic-function function-name &key argument-precedence-order declare documentation environment generic-function-class lambda-list method-class method-combination => generic-function eq x y => generalized-boolean eql x y => generalized-boolean equal x y => generalized-boolean equalp x y => generalized-boolean error datum &rest arguments =>| eval-when (situation*) form* => result* eval form => result* evenp integer => generalized-boolean oddp integer => generalized-boolean every predicate &rest sequences+ => generalized-boolean some predicate &rest sequences+ => result notevery predicate &rest sequences+ => generalized-boolean notany predicate &rest sequences+ => generalized-boolean exp number => result expt base-number power-number => result export symbols &optional package => t fboundp name => generalized-boolean fdefinition function-name => definition (setf (fdefinition function-name) new-definition) file-author pathspec => author file-error-pathname condition => pathspec file-length stream => length file-position stream => position file-position stream position-spec => success-p file-string-length stream object => length file-write-date pathspec => date fill-pointer vector => fill-pointer (setf (fill-pointer vector) new-fill-pointer) fill sequence item &key start end => sequence find-all-symbols string => symbols find-class symbol &optional errorp environment => class (setf (find-class symbol &optional errorp environment) new-class) find-method generic-function method-qualifiers specializers &optional errorp => method find-package name => package find-restart identifier &optional condition restart find-symbol string &optional package => symbol, status find item sequence &key from-end test test-not start end key => element find-if predicate sequence &key from-end start end key => element find-if-not predicate sequence &key from-end start end key => element finish-output &optional output-stream => nil force-output &optional output-stream => nil clear-output &optional output-stream => nil first list => object second list => object third list => object fourth list => object fifth list => object sixth list => object seventh list => object eighth list => object ninth list => object tenth list => object(setf (first list) new-object) (setf (second list) new-object) (setf (third list) new-object) (setf (fourth list) new-object) (setf (fifth list) new-object) (setf (sixth list) new-object) (setf (seventh list) new-object) (setf (eighth list) new-object) (setf (ninth list) new-object) (setf (tenth list) new-object) flet ((function-name lambda-list [[local-declaration* | local-documentation]] local-form*)*) declaration* form* => result* labels ((function-name lambda-list [[local-declaration* | local-documentation]] local-form*)*) declaration* form* => result* macrolet ((name lambda-list [[local-declaration* | local-documentation]] local-form*)*) declaration* form* => result* float number &optional prototype => float floatp object generalized-boolea floor number &optional divisor => quotient, remainder ffloor number &optional divisor => quotient, remainder ceiling number &optional divisor => quotient, remainder fceiling number &optional divisor => quotient, remainder truncate number &optional divisor => quotient, remainder ftruncate number &optional divisor => quotient, remainder round number &optional divisor => quotient, remainder fround number &optional divisor => quotient, remainder fmakunbound name => name format destination control-string &rest args => result formatter control-string => function funcall function &rest args => result* function-keywords method => keys, allow-other-keys-p function-lambda-expression function => lambda-expression, closure-p, name function name => function functionp object => generalized-boolean gcd &rest integers => greatest-common-denominator gensym &optional x => new-symbol gentemp &optional prefix package => new-symbol get-dispatch-macro-character disp-char sub-char &optional readtable => function set-dispatch-macro-character disp-char sub-char new-function &optional readtable => t get-internal-real-time <no arguments> => internal-time get-internal-run-time <no arguments> => internal-time get-macro-character char &optional readtable => function, non-terminating-p set-macro-character char new-function &optional non-terminating-p readtable => t get-output-stream-string string-output-stream => string get-properties plist indicator-list => indicator, value, tail get-setf-expansion place &optional environment => vars, vals, store-vars, writer-form, reader-form get-universal-time <no arguments> => universal-time get-decoded-time <no arguments> => second, minute, hour, date, month, year, day, daylight-p, zone get symbol indicator &optional default => value (setf (get symbol indicator &optional default) new-value) getf plist indicator &optional default => value (setf (getf place indicator &optional default) new-value) gethash key hash-table &optional default => value, present-p (setf (gethash key hash-table &optional default) new-value) go tag =>| graphic-char-p char => generalized-boolean handler-bind ({binding}*) form* => result*
binding::= (type handler) 
handler-case expression [[{error-clause}* | no-error-clause]] => result*
clause::= error-clause | no-error-clause 
error-clause::= (typespec ([var]) declaration* form*) 
no-error-clause::= (:no-error lambda-list declaration* form*) 
hash-table-count hash-table => count hash-table-p object => generalized-boolean hash-table-rehash-size hash-table => rehash-size hash-table-rehash-threshold hash-table => rehash-threshold hash-table-size hash-table => size hash-table-test hash-table => test identity object => object if test-form then-form [else-form] => result* ignore-errors form* => result* import symbols &optional package => t in-package name => package incf place [delta-form] => new-value decf place [delta-form] => new-value initialize-instance instance &rest initargs &key &allow-other-keys => instance input-stream-p stream => generalized-boolean output-stream-p stream => generalized-boolean inspect object => implementation-dependent integer-length integer => number-of-bits integerp object => generalized-boolean interactive-stream-p stream => generalized-boolean intern string &optional package => symbol, status intersection list-1 list-2 &key key test test-not => result-list nintersection list-1 list-2 &key key test test-not => result-list invalid-method-error method format-control &rest args => implementation-dependent invoke-debugger condition =>| invoke-restart-interactively restart => result* invoke-restart restart &rest arguments => result* keywordp object => generalized-boolean lambda lambda-list [[declaration* | documentation]] form* lambda lambda-list [[declaration* | documentation]] form* => function last list &optional n => tail lcm &rest integers => least-common-multiple ldb-test bytespec integer => generalized-boolean ldb bytespec integer => byte (setf (ldb bytespec place) new-byte) ldiff list object => result-list tailp object list => generalized-boolean length sequence => n let ({var | (var [init-form])}*) declaration* form* => result* let* ({var | (var [init-form])}*) declaration* form* => result* lisp-implementation-type <no arguments> => description lisp-implementation-version <no arguments> => description list-all-packages <no arguments> => packages list-length list => length list &rest objects => list list* &rest objects+ => result listen &optional input-stream => generalized-boolean listp object => generalized-boolean load-logical-pathname-translations host => just-loaded load-time-value form &optional read-only-p => object load filespec &key verbose print if-does-not-exist external-format => generalized-boolean locally declaration* form* => result* log number &optional base => logarithm logand &rest integers => result-integer logandc1 integer-1 integer-2 => result-integer logandc2 integer-1 integer-2 => result-integer logeqv &rest integers => result-integer logior &rest integers => result-integer lognand integer-1 integer-2 => result-integer lognor integer-1 integer-2 => result-integer lognot integer => result-integer logorc1 integer-1 integer-2 => result-integer logorc2 integer-1 integer-2 => result-integer logxor &rest integers => result-integer logbitp index integer => generalized-boolean logcount integer => number-of-on-bits logical-pathname-translations host => translations (setf (logical-pathname-translations host) new-translations) logical-pathname pathspec => logical-pathname logtest integer-1 integer-2 => generalized-boolean loop-finish <no arguments> =>| machine-instance <no arguments> => description machine-type <no arguments> => description machine-version <no arguments> => description macro-function symbol &optional environment => function (setf (macro-function symbol &optional environment) new-function) macroexpand form &optional env => expansion, expanded-p macroexpand-1 form &optional env => expansion, expanded-p make-array dimensions &key element-type initial-element initial-contents adjustable fill-pointer displaced-to displaced-index-offset => new-array make-broadcast-stream &rest streams => broadcast-stream make-concatenated-stream &rest input-streams => concatenated-stream make-condition type &rest slot-initializations => condition make-dispatch-macro-character char &optional non-terminating-p readtable => t make-echo-stream input-stream output-stream => echo-stream make-hash-table &key test size rehash-size rehash-threshold => hash-table make-instance class &rest initargs &key &allow-other-keys => instance make-instances-obsolete class => class make-list size &key initial-element => list make-load-form-saving-slots object &key slot-names environment => creation-form, initialization-form make-load-form object &optional environment => creation-form[, initialization-form] make-package package-name &key nicknames use => package make-pathname &key host device directory name type version defaults case => pathname make-random-state &optional state => new-state make-sequence result-type size &key initial-element => sequence make-string-input-stream string &optional start end => string-stream make-string-output-stream &key element-type => string-stream make-string size &key initial-element element-type => string make-symbol name => new-symbol make-synonym-stream symbol => synonym-stream make-two-way-stream input-stream output-stream => two-way-stream makunbound symbol => symbol map-into result-sequence function &rest sequences => result-sequence map result-type function &rest sequences+ => result mapc function &rest lists+ => list-1 mapcar function &rest lists+ => result-list mapcan function &rest lists+ => concatenated-results mapl function &rest lists+ => list-1 maplist function &rest lists+ => result-list mapcon function &rest lists+ => concatenated-results maphash function hash-table => nil mask-field bytespec integer => masked-integer (setf (mask-field bytespec place) new-masked-integer) max &rest reals+ => max-real min &rest reals+ => min-real member item list &key key test test-not => tail member-if predicate list &key key => tail member-if-not predicate list &key key => tail merge-pathnames pathname &optional default-pathname default-version => merged-pathname merge result-type sequence-1 sequence-2 predicate &key key => result-sequence method-combination-error format-control &rest args => implementation-dependent method-qualifiers method => qualifiers minusp real => generalized-boolean plusp real => generalized-boolean mismatch sequence-1 sequence-2 &key from-end test test-not key start1 start2 end1 end2 => position mod number divisor => modulus rem number divisor => remainder multiple-value-bind (var*) values-form declaration* form* => result* multiple-value-call function-form form* => result* multiple-value-list form => list multiple-value-prog1 first-form form* => first-form-results multiple-value-setq vars form => result name-char name => char-p namestring pathname => namestring file-namestring pathname => namestring directory-namestring pathname => namestring host-namestring pathname => namestring enough-namestring pathname &optional defaults => namestring nconc &rest lists => concatenated-list next-method-p <no arguments> => generalized-boolean no-applicable-method generic-function &rest function-arguments => result* no-next-method generic-function method &rest args => result* not x => boolean nth-value n form => object nth n list => object (setf (nth n list) new-object) nthcdr n list => tail null object => boolean numberp object => generalized-boolean numerator rational => numerator denominator rational => denominator open-stream-p stream => generalized-boolean open filespec &key direction element-type if-exists if-does-not-exist external-format => stream or form* => results* package-error-package condition => package package-name package => name package-nicknames package => nicknames package-shadowing-symbols package => symbols package-use-list package => use-list package-used-by-list package => used-by-list packagep object => generalized-boolean pairlis keys data &optional alist => new-alist parse-integer string &key start end radix junk-allowed => integer, pos parse-namestring thing &optional host default-pathname &key start end junk-allowed => pathname, position pathname-host pathname &key case => host pathname-device pathname &key case => device pathname-directory pathname &key case => directory pathname-name pathname &key case => name pathname-type pathname &key case => type pathname-version pathname => version pathname-match-p pathname wildcard => generalized-boolean pathname pathspec => pathname pathnamep object => generalized-boolean peek-char &optional peek-type input-stream eof-error-p eof-value recursive-p => char phase number => phase pop place => element position item sequence &key from-end test test-not start end key => position position-if predicate sequence &key from-end start end key => position position-if-not predicate sequence &key from-end start end key => position pprint-dispatch object &optional table => function, found-p pprint-exit-if-list-exhausted <no arguments> => nil pprint-fill stream object &optional colon-p at-sign-p => nil pprint-linear stream object &optional colon-p at-sign-p => nil pprint-tabular stream object &optional colon-p at-sign-p tabsize => nil pprint-indent relative-to n &optional stream => nil pprint-logical-block (stream-symbol object &key prefix per-line-prefix suffix) declaration* form* => nil pprint-newline kind &optional stream => nil pprint-pop <no arguments> => object pprint-tab kind colnum colinc &optional stream => nil print-not-readable-object condition => object print-object object stream => object print-unreadable-object (object stream &key type identity) form* => nil probe-file pathspec => truename proclaim declaration-specifier => implementation-dependent prog1 first-form form* => result-1 prog2 first-form second-form form* => result-2 prog ({var | (var [init-form])}*) declaration* {tag | statement}* => result* prog* ({var | (var [init-form])}*) declaration* {tag | statement}* => result* progn form* => result* progv symbols values form* => result* provide module-name => implementation-dependent require module-name &optional pathname-list => implementation-dependent psetq {pair}* => nil
pair::= var form 
push item place => new-place-value pushnew item place &key key test test-not => new-place-value quote object => object random-state-p object => generalized-boolean random limit &optional random-state => random-number rassoc item alist &key key test test-not => entry rassoc-if predicate alist &key key => entry rassoc-if-not predicate alist &key key => entry rational number => rational rationalize number => rational rationalp object => generalized-boolean read-byte stream &optional eof-error-p eof-value => byte read-char-no-hang &optional input-stream eof-error-p eof-value recursive-p => char read-char &optional input-stream eof-error-p eof-value recursive-p => char read-delimited-list char &optional input-stream recursive-p => list read-from-string string &optional eof-error-p eof-value &key start end preserve-whitespace => object, position read-line &optional input-stream eof-error-p eof-value recursive-p => line, missing-newline-p read-sequence sequence stream &key start end => position sequence---a sequence. stream---an input stream. start, end---bounding index designators of sequence. The defaults for start and end are 0 and nil, respectively. position---an integer greater than or equal to zero, and less than or equal to the length of the sequence read &optional input-stream eof-error-p eof-value recursive-p => object read-preserving-whitespace &optional input-stream eof-error-p eof-value recursive-p => object readtable-case readtable => mode (setf (readtable-case readtable) mode) readtablep object => generalized-boolean realp object => generalized-boolean realpart number => real imagpart number => real reduce function sequence &key key from-end start end initial-value => result reinitialize-instance instance &rest initargs &key &allow-other-keys => instance remf place indicator => generalized-boolean remhash key hash-table => generalized-boolean remove-duplicates sequence &key from-end test test-not start end key => result-sequence delete-duplicates sequence &key from-end test test-not start end key => result-sequence remove-method generic-function method => generic-function remove item sequence &key from-end test test-not start end count key => result-sequence remove-if test sequence &key from-end start end count key => result-sequence remove-if-not test sequence &key from-end start end count key => result-sequence delete item sequence &key from-end test test-not start end count key => result-sequence delete-if test sequence &key from-end start end count key => result-sequence delete-if-not test sequence &key from-end start end count key => result-sequence remprop symbol indicator => generalized-boolean rename-file filespec new-name => defaulted-new-name, old-truename, new-truename rename-package package new-name &optional new-nicknames => package-object replace sequence-1 sequence-2 &key start1 end1 start2 end2 => sequence-1 rest list => tail (setf (rest list) new-tail) restart-bind ({(name function {key-val-pair}*)}) form* => result*
key-val-pair::= :interactive-function interactive-function |  
                :report-function report-function |  
                :test-function test-function 
restart-case restartable-form {clause} => result*
clause::= (case-name lambda-list  
           [[:interactive interactive-expression | :report report-expression | :test test-expression]]  
           declaration* form*) 
restart-name restart => name return-from name [result] =>| return [result] =>| revappend list tail => result-list nreconc list tail => result-list reverse sequence => reversed-sequence nreverse sequence => reversed-sequence room &optional x => implementation-dependent rotatef place* => nil row-major-aref array index => element (setf (row-major-aref array index) new-element) rplaca cons object => cons rplacd cons object => cons search sequence-1 sequence-2 &key from-end test test-not key start1 start2 end1 end2 => position set-difference list-1 list-2 &key key test test-not => result-list nset-difference list-1 list-2 &key key test test-not => result-list set-exclusive-or list-1 list-2 &key key test test-not => result-list nset-exclusive-or list-1 list-2 &key key test test-not => result-list set-pprint-dispatch type-specifier function &optional priority table => nil set-syntax-from-char to-char from-char &optional to-readtable from-readtable => t set symbol value => value setf {pair}* => result* psetf {pair}* => nil
pair::= place newvalue 
setq {pair}* => result
pair::= var form 
shadow symbol-names &optional package => t shadowing-import symbols &optional package => t shared-initialize instance slot-names &rest initargs &key &allow-other-keys => instance shiftf place+ newvalue => old-value-1 short-site-name <no arguments> => description long-site-name <no arguments> => description signal datum &rest arguments => nil signum number => signed-prototype simple-bit-vector-p object => generalized-boolean simple-condition-format-control condition => format-control simple-condition-format-arguments condition => format-arguments simple-string-p object => generalized-boolean simple-vector-p object => generalized-boolean sin radians => number cos radians => number tan radians => number sinh number => result cosh number => result tanh number => result asinh number => result acosh number => result atanh number => result sleep seconds => nil slot-boundp instance slot-name => generalized-boolean slot-exists-p object slot-name => generalized-boolean slot-makunbound instance slot-name => instance slot-missing class object slot-name operation &optional new-value => result* slot-unbound class instance slot-name => result* slot-value object slot-name => value software-type <no arguments> => description software-version <no arguments> => description sort sequence predicate &key key => sorted-sequence stable-sort sequence predicate &key key => sorted-sequence special-operator-p symbol => generalized-boolean sqrt number => root isqrt natural => natural-root standard-char-p character => generalized-boolean step form => result* stream-element-type stream => typespec stream-error-stream condition => stream stream-external-format stream => format streamp object => generalized-boolean string-trim character-bag string => trimmed-string string-left-trim character-bag string => trimmed-string string-right-trim character-bag string => trimmed-string string-upcase string &key start end => cased-string string-downcase string &key start end => cased-string string-capitalize string &key start end => cased-string nstring-upcase string &key start end => string nstring-downcase string &key start end => string nstring-capitalize string &key start end => string string x => string string= string1 string2 &key start1 end1 start2 end2 => generalized-boolean string/= string1 string2 &key start1 end1 start2 end2 => mismatch-index string< string1 string2 &key start1 end1 start2 end2 => mismatch-index string> string1 string2 &key start1 end1 start2 end2 => mismatch-index string<= string1 string2 &key start1 end1 start2 end2 => mismatch-index string>= string1 string2 &key start1 end1 start2 end2 => mismatch-index string-equal string1 string2 &key start1 end1 start2 end2 => generalized-boolean string-not-equal string1 string2 &key start1 end1 start2 end2 => mismatch-index string-lessp string1 string2 &key start1 end1 start2 end2 => mismatch-index string-greaterp string1 string2 &key start1 end1 start2 end2 => mismatch-index string-not-greaterp string1 string2 &key start1 end1 start2 end2 => mismatch-index string-not-lessp string1 string2 &key start1 end1 start2 end2 => mismatch-index stringp object => generalized-boolean sublis alist tree &key key test test-not => new-tree nsublis alist tree &key key test test-not => new-tree subseq sequence start &optional end => subsequence (setf (subseq sequence start &optional end) new-subsequence) subsetp list-1 list-2 &key key test test-not => generalized-boolean subst new old tree &key key test test-not => new-tree subst-if new predicate tree &key key => new-tree subst-if-not new predicate tree &key key => new-tree nsubst new old tree &key key test test-not => new-tree nsubst-if new predicate tree &key key => new-tree nsubst-if-not new predicate tree &key key => new-tree substitute newitem olditem sequence &key from-end test test-not start end count key => result-sequence substitute-if newitem predicate sequence &key from-end start end count key => result-sequence substitute-if-not newitem predicate sequence &key from-end start end count key => result-sequence nsubstitute newitem olditem sequence &key from-end test test-not start end count key => sequence nsubstitute-if newitem predicate sequence &key from-end start end count key => sequence nsubstitute-if-not newitem predicate sequence &key from-end start end count key => sequence subtypep type-1 type-2 &optional environment => subtype-p, valid-p svref simple-vector index => element (setf (svref simple-vector index) new-element) sxhash object => hash-code symbol-function symbol => contents (setf (symbol-function symbol) new-contents) symbol-macrolet ((symbol expansion)*) declaration* form* => result* symbol-name symbol => name symbol-package symbol => contents symbol-plist symbol => plist (setf (symbol-plist symbol) new-plist) symbol-value symbol => value (setf (symbol-value symbol) new-value) symbolp object => generalized-boolean synonym-stream-symbol synonym-stream => symbol tagbody {tag | statement}* => nil terpri &optional output-stream => nil fresh-line &optional output-stream => generalized-boolean the value-type form => result* throw tag result-form =>| time form => result* trace function-name* => trace-result untrace function-name* => untrace-result translate-logical-pathname pathname &key => physical-pathname translate-pathname source from-wildcard to-wildcard &key => translated-pathname tree-equal tree-1 tree-2 &key test test-not => generalized-boolean truename filespec => truename two-way-stream-input-stream two-way-stream => input-stream two-way-stream-output-stream two-way-stream => output-stream type-error-datum condition => datum type-error-expected-type condition => expected-type type-of object => typespec typecase keyform {normal-clause}* [otherwise-clause] => result* ctypecase keyplace {normal-clause}* => result* etypecase keyform {normal-clause}* => result*
normal-clause::= (type form*) 
otherwise-clause::= ({otherwise | t} form*) 
clause::= normal-clause | otherwise-clause 
typep object type-specifier &optional environment => generalized-boolean unbound-slot-instance condition => instance unexport symbols &optional package => t unintern symbol &optional package => generalized-boolean union list-1 list-2 &key key test test-not => result-list nunion list-1 list-2 &key key test test-not => result-list unread-char character &optional input-stream => nil unuse-package packages-to-unuse &optional package => t unwind-protect protected-form cleanup-form* => result* update-instance-for-different-class previous current &rest initargs &key &allow-other-keys => implementation-dependent update-instance-for-redefined-class instance added-slots discarded-slots property-list &rest initargs &key &allow-other-keys => result* upgraded-array-element-type typespec &optional environment => upgraded-typespec upgraded-complex-part-type typespec &optional environment => upgraded-typespec upper-case-p character => generalized-boolean lower-case-p character => generalized-boolean both-case-p character => generalized-boolean use-package packages-to-use &optional package => t user-homedir-pathname &optional host => pathname values-list list => element* values &rest object => object* (setf (values &rest place) new-values) vector-pop vector => element vector-push new-element vector => new-index-p vector-push-extend new-element vector &optional extension => new-index vector &rest objects => vector vectorp object => generalized-boolean warn datum &rest arguments => nil when test-form form* => result* unless test-form form* => result* wild-pathname-p pathname &optional field-key => generalized-boolean with-accessors (slot-entry*) instance-form declaration* form* => result*
slot-entry::= (variable-name accessor-name) 
with-compilation-unit ([[option]]) form* => result*
option::= :override override 
with-condition-restarts condition-form restarts-form form* => result* with-hash-table-iterator (name hash-table) declaration* form* => result* with-input-from-string (var string &key index start end) declaration* form* => result* with-open-file (stream filespec options*) declaration* form* => results with-open-stream (var stream) declaration* form* => result* with-output-to-string (var &optional string-form &key element-type) declaration* form* => result* with-package-iterator (name package-list-form &rest symbol-types) declaration* form* => result* with-simple-restart (name format-control format-argument*) form* => result* with-slots (slot-entry*) instance-form declaration* form* => result*
slot-entry::= slot-name | (variable-name slot-name) 
with-standard-io-syntax form* => result* write-byte byte stream => byte write-char character &optional output-stream => character write-sequence sequence stream &key start end => sequence sequence---a sequence. stream---an output stream. start, end---bounding index designators of sequence. The defaults for start and end are 0 and nil, respectively write-string string &optional output-stream &key start end => string write-line string &optional output-stream &key start end => string write-to-string object &key array base case circle escape gensym length level lines miser-width pprint-dispatch pretty radix readably right-margin => string prin1-to-string object => string princ-to-string object => string write object &key array base case circle escape gensym length level lines miser-width pprint-dispatch pretty radix readably right-margin stream => object prin1 object &optional output-stream => object princ object &optional output-stream => object print object &optional output-stream => object pprint object &optional output-stream => <no values> y-or-n-p &optional control &rest arguments => generalized-boolean yes-or-no-p &optional control &rest arguments => generalized-boolean zerop number => generalized-boolean (declaration name*)(dynamic-extent [[var* | (function fn)*]])(ftype type function-name*) (inline function-name*) (notinline function-name*)(optimize {quality | (quality value)}*) (special var*)(type typespec var*) (typespec var*)(ignore {var | (function fn)}*) (ignorable {var | (function fn)}*)defsetf access-fn update-fn [documentation] => access-fn The ``long form'': defsetf access-fn lambda-list (store-variable*) [[declaration* | documentation]] form* => access-fn The ``simple'' loop form: loop compound-form* => result* The ``extended'' loop form: loop [name-clause] {variable-clause}* {main-clause}* => result*
name-clause::= named name 
variable-clause::= with-clause | initial-final | for-as-clause 
with-clause::= with var1 [type-spec] [= form1] {and var2 [type-spec] [= form2]}* 
main-clause::= unconditional | accumulation | conditional | termination-test | initial-final 
initial-final::= initially compound-form+ | finally compound-form+ 
unconditional::= {do | doing} compound-form+ | return {form | it} 
accumulation::= list-accumulation | numeric-accumulation 
list-accumulation::= {collect | collecting | append | appending | nconc | nconcing} {form | it}  
                     [into simple-var] 
numeric-accumulation::= {count | counting | sum | summing | } 
                         maximize | maximizing | minimize | minimizing {form | it} 
                        [into simple-var] [type-spec] 
conditional::= {if | when | unless} form selectable-clause {and selectable-clause}*  
               [else selectable-clause {and selectable-clause}*]  
selectable-clause::= unconditional | accumulation | conditional 
termination-test::= while form | until form | repeat form | always form | never form | thereis form 
for-as-clause::= {for | as} for-as-subclause {and for-as-subclause}* 
for-as-subclause::= for-as-arithmetic | for-as-in-list | for-as-on-list | for-as-equals-then | 
                    for-as-across | for-as-hash | for-as-package 
for-as-arithmetic::= var [type-spec] for-as-arithmetic-subclause 
for-as-arithmetic-subclause::= arithmetic-up | arithmetic-downto | arithmetic-downfrom 
arithmetic-up::= [[{from | upfrom} form1 |   {to | upto | below} form2 |   by form3]]+ 
arithmetic-downto::= [[{{from form1}}1  |   {{{downto | above} form2}}1  |   by form3]] 
arithmetic-downfrom::= [[{{downfrom form1}}1  |   {to | downto | above} form2 |   by form3]] 
for-as-in-list::= var [type-spec] in form1 [by step-fun] 
for-as-on-list::= var [type-spec] on form1 [by step-fun] 
for-as-equals-then::= var [type-spec] = form1 [then form2] 
for-as-across::= var [type-spec] across vector 
for-as-hash::= var [type-spec] being {each | the}  
               {{hash-key | hash-keys} {in | of} hash-table  
                [using (hash-value other-var)] |  
                {hash-value | hash-values} {in | of} hash-table  
                [using (hash-key other-var)]} 
for-as-package::= var [type-spec] being {each | the}  
                  {symbol | symbols | 
                   present-symbol | present-symbols | 
                   external-symbol | external-symbols} 
                  [{in | of} package] 
type-spec::= simple-type-spec | destructured-type-spec 
simple-type-spec::= fixnum | float | t | nil 
destructured-type-spec::= of-type d-type-spec 
d-type-spec::= type-specifier | (d-type-spec . d-type-spec) 
var::= d-var-spec 
var1::= d-var-spec 
var2::= d-var-spec 
other-var::= d-var-spec 
d-var-spec::= simple-var | nil | (d-var-spec . d-var-spec)