(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 | 
           type-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}*]  
               [end] 
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)