Package COM.INFORMATIMAGO.COMMON-LISP.LISP.STEPPER

Nicknames: COMMON-LISP-STEPPER CL-STEPPER STEPPER
Implements a Portable Common Lisp Stepper.

This package should be used instead of COMMON-LISP, and the code
recompiled or reloaded.  This will instrumentalize the functions so
that tracing and stepping is available.

To start running some code step-by-step, you can use:

    (step (some-expression)) ; note: it's cl-stepper:step, not cl:step.

Or you may use STEP-TRACE-FUNCTION, to activate tracing of some functions (that
must have been compiled with CL-STEPPER), or STEP-BREAK-ENTRY or
STEP-BREAK-EXIT to enter the stepper upon entry or exit of the named
functions.

It is also possible to run the tracer on all the code that has been
compiled with CL-STEPPER, with:

   (setf *step-mode* :trace)

Reset it with:

   (setf *step-mode* :run)

If you load a lot of packages with CL-STEPPER, you may want to set
*STEP-MAX-CALL-DEPTH* to a small integer when using *STEP-MODE*
:trace, to avoid very big output.  You may also redirect the tracing
output to a different stream setting *STEP-TRACE-OUTPUT*.

Note: when tracing a function with (step-trace-function fun), the depth is
reset while tracing that function (*step-max-call-depth* still applies
for the call tree starting from that function).


The stepper menu is:

    Step Into (s, si, RET), Step over (so), Trace (t), Run (r),
    Debugger (d), Abort (a, q)?

Step Into:

    Continue evaluating each forms and subforms step by step.

Step Over:

    Evaluate the current form in one step. 

Trace:

    The code is executed, and all the instrumented code produces traces.

Run:

    The code is executed silently.

Debugger:

    The debugger is invoked with a STEP-CONDITION.  There are restarts
    installed to invoke all the stepper menu commands.

Abort:

    The evaluation of the STEP form is aborted.

With the Step Over, Trace, and Run commands,  if a function with a
break-point or an active trace is reached, it will still enter the
stepper menu again, or trace it.



To disable instrumentation of a form, you can insert (stepper disable)
declarations in the places where declarations are allowed.

   (declaim (declaration stepper)) ; for when CL-STEPPER is not used.

   (…
     (declare (stepper disable))
     …)

declarations.  Use (locally (declare (stepper disable)) …) to disable
in random places.


Similarly, to force tracing a function or a form,
use the (declare (stepper trace)) declaration.
(stepper disable) has priority over (stepper trace).



Copyright Pascal J. Bourguignon 2012 - 2015
This package is provided under the Afero General Public License 3.
See the source file for details.

(* &lexpr numbers)
function
Return the product of its arguments. With no args, returns 1.
*
variable
the value of the most recent top level EVAL
Initial value: (COM.INFORMATIMAGO.LISPDOC)
**
variable
the previous value of *
Initial value: NIL
***
variable
the previous value of **
Initial value: NIL
*break-on-signals*
variable
When (TYPEP condition *BREAK-ON-SIGNALS*) is true, then calls to SIGNAL will
   enter the debugger prior to signalling that condition.
Initial value: NIL
*compile-file-pathname*
variable
The defaulted pathname of the file currently being compiled, or NIL if not
  compiling.
Initial value: NIL
*compile-file-truename*
variable
The TRUENAME of the file currently being compiled, or NIL if not
  compiling.
Initial value: NIL
*compile-print*
variable
The default for the :PRINT argument to COMPILE-FILE.
Initial value: NIL
*compile-verbose*
variable
The default for the :VERBOSE argument to COMPILE-FILE.
Initial value: NIL
*debug-io*
variable
interactive debugging stream
Initial value: #<SYNONYM-STREAM to *TERMINAL-IO* #x30200036D61D>
*debugger-hook*
variable
This is either NIL or a function of two arguments, a condition and the value
   of *DEBUGGER-HOOK*. This function can either handle the condition or return
   which causes the standard debugger to execute. The system passes the value
   of this variable to the function because it binds *DEBUGGER-HOOK* to NIL
   around the invocation.
Initial value: NIL

*DEFAULT-PATHNAME-DEFAULTS*

*error-output*
variable
error output stream
Initial value: #<SYNONYM-STREAM to *TERMINAL-IO* #x30200036D65D>
*features*
variable
a list of symbols that describe features provided by the
   implementation
Initial value: (OBJC-SUPPORT HEMLOCK APPLE-OBJC-2.0 APPLE-OBJC COM.INFORMATIMAGO.PJB BORDEAUX-THREADS CLOSER-MOP THREAD-SUPPORT UIOP SPLIT-SEQUENCE ...)
*gensym-counter*
variable
counter for generating unique GENSYM symbols
Initial value: 55218
*load-pathname*
variable
the defaulted pathname that LOAD is currently loading
Initial value: NIL
*load-print*
variable
the default for the :PRINT argument to LOAD
Initial value: NIL
*load-truename*
variable
the TRUENAME of the file that LOAD is currently loading
Initial value: NIL
*load-verbose*
variable
the default for the :VERBOSE argument to LOAD
Initial value: NIL
*macroexpand-hook*
variable
The value of this variable must be a designator for a function that can
  take three arguments, a macro expander function, the macro form to be
  expanded, and the lexical environment to expand in. The function should
  return the expanded form. This function is called by MACROEXPAND-1
  whenever a runtime expansion is needed. Initially this is set to
  FUNCALL.
Initial value: FUNCALL
*modules*
variable
This is a list of module names that have been loaded into Lisp so far.
   The names are case sensitive strings.  It is used by PROVIDE and REQUIRE.
Initial value: (COCOA HEMLOCK COMPILE-HEMLOCK OBJC-SUPPORT BRIDGE OBJC-RUNTIME OBJC-CLOS NAME-TRANSLATION SEQUENCE-UTILS OBJC-PACKAGE ...)

*PACKAGE*

*print-array*
variable
Non-NIL means that arrays should be printed using "#(...)" or
"=#nA(...)" syntax to show their contents.
If NIL, arrays other than strings are printed using "#<...>".
See also the (non-Common Lisp) variables *PRINT-SIMPLE-VECTOR*
and *PRINT-SIMPLE-BIT-VECTOR*
Initial value: T
*print-base*
variable
The output base for integers and rationals.
Must be an integer between 2 and 36.
Initial value: 10
*print-case*
variable
Specifies the alphabetic case in which symbols should
be printed.  Possible values include :UPCASE, :DOWNCASE and :CAPITALIZE
Initial value: UPCASE
*print-circle*
variable
Non-NIL means that the lisp printer should attempt to detect
circular structures, indicating them by using "#n=" and "#n#" syntax.
If this variable is false then an attempt to
output circular structure may cause unbounded output.
Initial value: NIL
*print-escape*
variable
Non-NIL means that the lisp printer should -attempt- to output
expressions `readably.'  When NIL the attempts to produce output
which is a little more human-readable (for example, pathnames
are represented by the characters of their namestring.)
Initial value: T
*print-gensym*
variable
Non-NIL means that symbols with no home package should be
printed using "#:" syntax.  NIL means no prefix is printed.
Initial value: T
*print-length*
variable
Specifies the length at which printing of lisp expressions
should be truncated.  NIL means that no such truncation should occur.
truncation is indicated by printing "..." instead of the
rest of the overly-long list or vector.
See also *PRINT-LEVEL*
Initial value: 10
*print-level*
variable
Specifies the depth at which printing of lisp expressions
should be truncated.  NIL means that no such truncation should occur.
Truncation is indicated by printing "#" instead of the
representation of the too-deeply-nested structure.
See also *PRINT-LENGTH*
Initial value: 4
*print-lines*
variable
+#/NIL truncates printing after # lines
Initial value: NIL
*print-miser-width*
variable
+#/NIL miser format starts when there is less than this width left
Initial value: 40

*PRINT-PPRINT-DISPATCH*

*print-pretty*
variable
Non-NIL means that the lisp printer should insert extra
indentation and newlines to make output more readable and `prettier.'
Initial value: NIL
*print-radix*
variable
Non-NIL means that the lisp printer will explicitly indicate
the output radix (see *PRINT-BASE*) which is used to print
integers and rational numbers.
Initial value: NIL
*print-readably*
variable
Non-NIL means that attempts to print unreadable objects
   signal PRINT-NOT-READABLE errors.  NIL doesn't.
Initial value: NIL
*print-right-margin*
variable
+#/NIL the right margin for pretty printing
Initial value: 80
*query-io*
variable
query I/O stream
Initial value: #<SYNONYM-STREAM to *TERMINAL-IO* #x30200036D61D>

*RANDOM-STATE*

*read-base*
variable
the radix that Lisp reads numbers in
Initial value: 10

*READ-DEFAULT-FLOAT-FORMAT*

*read-eval*
variable
When nil, #. signals an error.
Initial value: T
*read-suppress*
variable
Suppress most interpreting in the reader when T.
Initial value: NIL

*READTABLE*

*standard-input*
variable
default input stream
Initial value: #<SYNONYM-STREAM to *TERMINAL-IO* #x30200036D7FD>
*standard-output*
variable
default output stream
Initial value: #<SYNONYM-STREAM to *TERMINAL-IO* #x30200036D69D>
*step-max-trace-depth*
variable
The maximum depth of function calls that should be traced.  When
more than that depth of calls occur, the *step-mode* switches to
:run.
Initial value: NIL
*step-mode*
variable
May be :run, :function :trace or :step.

:run       don't print anything, just evaluate the forms.

:function just prints the function calls and their results.

:trace    just prints the forms and their results as they are evaluted.

:step     prints the form, then ask the user what to do (step over,
          step into, trace, run).

When break-points are implemented, :run, :function and :trace will run
until a break-point is reached.

Initial value: RUN
*step-package*
variable
The package bound to *PACKAGE* while printing tracing logs.
Initial value: #<Package "COMMON-LISP-USER">
*step-print-case*
variable
The value bound to *PRINT-CASE* while printing tracing logs.
Initial value: DOWNCASE
*step-print-length*
variable
The value bound to *PRINT-LENGTH* while printing tracing logs.
Initial value: 10
*step-print-level*
variable
The value bound to *PRINT-LEVEl* while printing tracing logs.
Initial value: 3
*step-trace-output*
variable
The stream where the stepper traces are written to.
Initial value: #<SYNONYM-STREAM to *TRACE-OUTPUT* #x30200161944D>
*terminal-io*
variable
terminal I/O stream
Initial value: #<ECHOING-TWO-WAY-STREAM input #<BASIC-CHARACTER-INPUT-STREAM UTF-8 (PIPE/0) #x30200036E81D>, output #<BASIC-CHARACTER-OUTPUT-STREAM UTF-8 (TTY/1) #x30200036E38D> #x302000373A4D>
*trace-output*
variable
trace output stream
Initial value: #<SYNONYM-STREAM to *TERMINAL-IO* #x30200036D69D>
(+ &lexpr numbers)
function
Return the sum of its arguments. With no args, returns 0.
+
variable
the value of the most recent top level READ
Initial value: (QUICKLOAD COM.INFORMATIMAGO.LISPDOC)
++
variable
the previous value of +
Initial value: NIL
+++
variable
the previous value of ++
Initial value: NIL
(- num &lexpr more)
function
Subtract the second and all subsequent arguments from the first; 
  or with one argument, negate the first argument.
-
variable
the form currently being evaluated
Initial value: (DOC)
(/ num &lexpr more)
function
Divide the first argument by each of the following arguments, in turn.
  With one argument, return reciprocal.
/
variable
a list of all the values returned by the most recent top level EVAL
Initial value: ((COM.INFORMATIMAGO.LISPDOC))
//
variable
the previous value of /
Initial value: NIL
///
variable
the previous value of //
Initial value: NIL
(/= num &lexpr more)
function
Return T if no two of its arguments are numerically equal, NIL otherwise.

1+

1-

(< num &lexpr more)
function
Return T if its arguments are in strictly increasing order, NIL otherwise.
(<= num &lexpr more)
function
Return T if arguments are in strictly non-decreasing order, NIL otherwise.
(= num &lexpr more)
function
Return T if all of its arguments are numerically equal, NIL otherwise.
(> num &lexpr more)
function
Return T if its arguments are in strictly decreasing order, NIL otherwise.
(>= num &lexpr more)
function
Return T if arguments are in strictly non-increasing order, NIL otherwise.
(abort &optional condition)
function
Transfer control to a restart named ABORT, signalling a CONTROL-ERROR if
   none exists.
(abs number)
function
Return the absolute value of the number.
(acons key datum a-list)
function
Construct a new alist by adding the pair (KEY . DATUM) to ALIST.
(acos x)
function
Return the arc cosine of NUMBER.
(acosh x)
function
Return the hyperbolic arc cosine of NUMBER.

ADD-METHOD

(adjoin item list &key test test-not key)
function
Add ITEM to LIST unless it is already a member
(adjust-array array dims &key element-type initial-element initial-contents fill-pointer displaced-to displaced-index-offset)
function
Adjust ARRAY's dimensions to the given DIMENSIONS and stuff.
(adjustable-array-p array)
function
Return T if (ADJUST-ARRAY ARRAY...) would return an array identical
   to the argument, this happens for complex arrays.

ALLOCATE-INSTANCE

(alpha-char-p c)
function
The argument must be a character object. ALPHA-CHAR-P returns T if the
   argument is an alphabetic character; otherwise NIL.
(alphanumericp c)
function
Given a character-object argument, ALPHANUMERICP returns T if the
   argument is either numeric or alphabetic.
(and &rest args)
macro
And Form*
AND evaluates each form in sequence, from left to right.  If any form
returns NIL, AND returns NIL; otherwise, AND returns the values(s) returned
by the last form.  If there are no forms, AND returns T.
(append &rest lists)
function
Construct a new list by concatenating the list arguments
(apply function arg &rest args)
function
Apply FUNCTION to a list of arguments produced by evaluating ARGUMENTS in
   the manner of LIST*. That is, a list is made of the values of all but the
   last argument, appended to the value of the last argument, which must be a
   list.

APROPOS

(apropos-list string &optional package)
function
Like APROPOS, except that it returns a list of the symbols found instead
  of describing them.
(aref a &lexpr subs)
function
Return the element of the ARRAY specified by the SUBSCRIPTS.

ARITHMETIC-ERROR

ARITHMETIC-ERROR-OPERANDS

ARITHMETIC-ERROR-OPERATION

ARRAY

(array-dimension array axis-number)
function
Return the length of dimension AXIS-NUMBER of ARRAY.
array-dimension-limit
constant
the exclusive upper bound on any given dimension of an array
Initial value: 72057594037927936
(array-dimensions array)
function
Return a list whose elements are the dimensions of the array
(array-displacement array)
function
Return the values of :DISPLACED-TO and :DISPLACED-INDEX-offset
   options to MAKE-ARRAY, or NIL and 0 if not a displaced array.
(array-element-type array)
function
Return the type of the elements of the array
(array-has-fill-pointer-p array)
function
Return T if the given ARRAY has a fill pointer, or NIL otherwise.
(array-in-bounds-p array &lexpr subscripts)
function
Return T if the SUBSCIPTS are in bounds for the ARRAY, NIL otherwise.
(array-rank array)
function
Return the number of dimensions of ARRAY.
array-rank-limit
constant
the exclusive upper bound on the rank of an array
Initial value: 4096

ARRAY-ROW-MAJOR-INDEX

(array-total-size array)
function
Return the total number of elements in the Array.
array-total-size-limit
constant
the exclusive upper bound on the total number of elements in an array
Initial value: 72057594037927936
(arrayp x)
function
Return true if OBJECT is an ARRAY, and NIL otherwise.
(ash integer count)
function
Shifts integer left by count places preserving sign. - count shifts right.
(asin x)
function
Return the arc sine of NUMBER.
(asinh x)
function
Return the hyperbolic arc sine of NUMBER.
(assert test-form &optional (places NIL) string &rest args)
macro
ASSERT Test-Form [(Place*) [String Arg*]]
  If the Test-Form is not true, then signal a correctable error.  If Places
  are specified, then new values are prompted for when the error is proceeded.
  String and Args are the format string and args to the error call.
(assoc item list &key test test-not key)
function
Return the cons in ALIST whose car is equal (by a given test or EQL) to
   the ITEM.
(assoc-if predicate alist &key key)
function
Return the first cons in ALIST whose CAR satisfies PREDICATE. If
   KEY is supplied, apply it to the CAR of each cons before testing.
(assoc-if-not predicate alist &key key)
function
Return the first cons in ALIST whose CAR does not satisfy PREDICATE.
  If KEY is supplied, apply it to the CAR of each cons before testing.
(atan y &optional x)
function
Return the arc tangent of Y if X is omitted or Y/X if X is supplied.
(atanh x)
function
Return the hyperbolic arc tangent of NUMBER.
(atom arg)
function
Return true if OBJECT is an ATOM, and NIL otherwise.

BASE-CHAR

BASE-STRING

BIGNUM

(bit bit-array &rest subscripts)
function
Return the bit from the BIT-ARRAY at the specified SUBSCRIPTS.
(bit-and bit-array1 bit-array2 &optional result-bit-array)
function
Perform a bit-wise LOGAND on the elements of BIT-ARRAY-1 and BIT-ARRAY-2,
  putting the results in RESULT-BIT-ARRAY. If RESULT-BIT-ARRAY is T,
  BIT-ARRAY-1 is used. If RESULT-BIT-ARRAY is NIL or omitted, a new array is
  created. All the arrays must have the same rank and dimensions.
(bit-andc1 bit-array1 bit-array2 &optional result-bit-array)
function
Perform a bit-wise LOGANDC1 on the elements of BIT-ARRAY-1 and BIT-ARRAY-2,
  putting the results in RESULT-BIT-ARRAY. If RESULT-BIT-ARRAY is T,
  BIT-ARRAY-1 is used. If RESULT-BIT-ARRAY is NIL or omitted, a new array is
  created. All the arrays must have the same rank and dimensions.
(bit-andc2 bit-array1 bit-array2 &optional result-bit-array)
function
Perform a bit-wise LOGANDC2 on the elements of BIT-ARRAY-1 and BIT-ARRAY-2,
  putting the results in RESULT-BIT-ARRAY. If RESULT-BIT-ARRAY is T,
  BIT-ARRAY-1 is used. If RESULT-BIT-ARRAY is NIL or omitted, a new array is
  created. All the arrays must have the same rank and dimensions.
(bit-eqv bit-array1 bit-array2 &optional result-bit-array)
function
Perform a bit-wise LOGEQV on the elements of BIT-ARRAY-1 and BIT-ARRAY-2,
  putting the results in RESULT-BIT-ARRAY. If RESULT-BIT-ARRAY is T,
  BIT-ARRAY-1 is used. If RESULT-BIT-ARRAY is NIL or omitted, a new array is
  created. All the arrays must have the same rank and dimensions.
(bit-ior bit-array1 bit-array2 &optional result-bit-array)
function
Perform a bit-wise LOGIOR on the elements of BIT-ARRAY-1 and BIT-ARRAY-2,
  putting the results in RESULT-BIT-ARRAY. If RESULT-BIT-ARRAY is T,
  BIT-ARRAY-1 is used. If RESULT-BIT-ARRAY is NIL or omitted, a new array is
  created. All the arrays must have the same rank and dimensions.
(bit-nand bit-array1 bit-array2 &optional result-bit-array)
function
Perform a bit-wise LOGNAND on the elements of BIT-ARRAY-1 and BIT-ARRAY-2,
  putting the results in RESULT-BIT-ARRAY. If RESULT-BIT-ARRAY is T,
  BIT-ARRAY-1 is used. If RESULT-BIT-ARRAY is NIL or omitted, a new array is
  created. All the arrays must have the same rank and dimensions.
(bit-nor bit-array1 bit-array2 &optional result-bit-array)
function
Perform a bit-wise LOGNOR on the elements of BIT-ARRAY-1 and BIT-ARRAY-2,
  putting the results in RESULT-BIT-ARRAY. If RESULT-BIT-ARRAY is T,
  BIT-ARRAY-1 is used. If RESULT-BIT-ARRAY is NIL or omitted, a new array is
  created. All the arrays must have the same rank and dimensions.
(bit-not bit-array &optional result-bit-array)
function
Performs a bit-wise logical NOT on the elements of BIT-ARRAY,
  putting the results in RESULT-BIT-ARRAY. If RESULT-BIT-ARRAY is T,
  BIT-ARRAY is used. If RESULT-BIT-ARRAY is NIL or omitted, a new array is
  created. Both arrays must have the same rank and dimensions.
(bit-orc1 bit-array1 bit-array2 &optional result-bit-array)
function
Perform a bit-wise LOGORC1 on the elements of BIT-ARRAY-1 and BIT-ARRAY-2,
  putting the results in RESULT-BIT-ARRAY. If RESULT-BIT-ARRAY is T,
  BIT-ARRAY-1 is used. If RESULT-BIT-ARRAY is NIL or omitted, a new array is
  created. All the arrays must have the same rank and dimensions.
(bit-orc2 bit-array1 bit-array2 &optional result-bit-array)
function
Perform a bit-wise LOGORC2 on the elements of BIT-ARRAY-1 and BIT-ARRAY-2,
  putting the results in RESULT-BIT-ARRAY. If RESULT-BIT-ARRAY is T,
  BIT-ARRAY-1 is used. If RESULT-BIT-ARRAY is NIL or omitted, a new array is
  created. All the arrays must have the same rank and dimensions.

BIT-VECTOR

(bit-vector-p thing)
function
Return true if OBJECT is a BIT-VECTOR, and NIL otherwise.
(bit-xor bit-array1 bit-array2 &optional result-bit-array)
function
Perform a bit-wise LOGXOR on the elements of BIT-ARRAY-1 and BIT-ARRAY-2,
  putting the results in RESULT-BIT-ARRAY. If RESULT-BIT-ARRAY is T,
  BIT-ARRAY-1 is used. If RESULT-BIT-ARRAY is NIL or omitted, a new array is
  created. All the arrays must have the same rank and dimensions.

BLOCK

(boole op integer1 integer2)
function
Bit-wise boolean function on two integers. Function chosen by OP:
        0       BOOLE-CLR
        1       BOOLE-SET
        2       BOOLE-1
        3       BOOLE-2
        4       BOOLE-C1
        5       BOOLE-C2
        6       BOOLE-AND
        7       BOOLE-IOR
        8       BOOLE-XOR
        9       BOOLE-EQV
        10      BOOLE-NAND
        11      BOOLE-NOR
        12      BOOLE-ANDC1
        13      BOOLE-ANDC2
        14      BOOLE-ORC1
        15      BOOLE-ORC2
boole-1
constant
Boole function op, makes BOOLE return integer1.
Initial value: 2
boole-2
constant
Boole function op, makes BOOLE return integer2.
Initial value: 3
boole-and
constant
Boole function op, makes BOOLE return logand of integer1 and integer2.
Initial value: 6
boole-andc1
constant
Boole function op, makes BOOLE return logandc1 of integer1 and integer2.
Initial value: 12
boole-andc2
constant
Boole function op, makes BOOLE return logandc2 of integer1 and integer2.
Initial value: 13
boole-c1
constant
Boole function op, makes BOOLE return complement of integer1.
Initial value: 4
boole-c2
constant
Boole function op, makes BOOLE return complement of integer2.
Initial value: 5
boole-clr
constant
Boole function op, makes BOOLE return 0.
Initial value: 0
boole-eqv
constant
Boole function op, makes BOOLE return logeqv of integer1 and integer2.
Initial value: 9
boole-ior
constant
Boole function op, makes BOOLE return logior of integer1 and integer2.
Initial value: 7
boole-nand
constant
Boole function op, makes BOOLE return log nand of integer1 and integer2.
Initial value: 10
boole-nor
constant
Boole function op, makes BOOLE return lognor of integer1 and integer2.
Initial value: 11
boole-orc1
constant
Boole function op, makes BOOLE return logorc1 of integer1 and integer2.
Initial value: 14
boole-orc2
constant
Boole function op, makes BOOLE return logorc2 of integer1 and integer2.
Initial value: 15
boole-set
constant
Boole function op, makes BOOLE return -1.
Initial value: 1
boole-xor
constant
Boole function op, makes BOOLE return logxor of integer1 and integer2.
Initial value: 8
(both-case-p c)
function
The argument must be a character object. BOTH-CASE-P returns T if the
  argument is an alphabetic character and if the character exists in
  both upper and lower case. For ASCII, this is the same as ALPHA-CHAR-P.
(boundp sym)
function
Return non-NIL if SYMBOL is bound to a value.
(break &optional string &rest args)
function
Print a message and invoke the debugger without allowing any possibility
   of condition handling occurring.

BROADCAST-STREAM

BROADCAST-STREAM-STREAMS

BUILT-IN-CLASS

(butlast list &optional n)
function
Returns a new list the same as List without the N last elements.
(byte size position)
function
Return a byte specifier which may be used by other byte functions
  (e.g. LDB).
(byte-position bytespec)
function
Return the position part of the byte specifier bytespec.
(byte-size bytespec)
function
Return the size part of the byte specifier bytespec.

CAAAAR

CAAADR

CAAAR

CAADAR

CAADDR

CAADR

CAAR

CADAAR

CADADR

CADAR

CADDAR

CADDDR

CADDR

CADR

call-arguments-limit
constant
The exclusive upper bound on the number of arguments which may be passed
  to a function, including &REST args.
Initial value: 65536

CAR

(case key &body forms)
macro
CASE Keyform {({(Key*) | Key} Form*)}*
  Evaluates the Forms in the first clause with a Key EQL to the value of
  Keyform. If a singleton key is T then the clause is a default clause.

CATCH

(ccase keyplace &body forms)
macro
CCASE Keyform {({(Key*) | Key} Form*)}*
  Evaluates the Forms in the first clause with a Key EQL to the value of
  Keyform. If none of the keys matches then a correctable error is
  signalled.

CDAAAR

CDAADR

CDAAR

CDADAR

CDADDR

CDADR

CDAR

CDDAAR

CDDADR

CDDAR

CDDDAR

CDDDDR

CDDDR

CDDR

CDR

(ceiling number &optional divisor)
function
Return the smallest integer not less than number, or number/divisor.
  The second returned value is the remainder.

CELL-ERROR

CELL-ERROR-NAME

CERROR

CHANGE-CLASS

(char string index)
function
Given a string and a non-negative integer index less than the length of
  the string, returns the character object representing the character at
  that position in the string.

CHAR-CODE

char-code-limit
constant
the upper exclusive bound on values produced by CHAR-CODE
Initial value: 1114112
(char-downcase c)
function
Return CHAR converted to lower-case if that is possible.
(char-equal char &rest others)
function
Return T if all of the arguments are the same character.
  Font, bits, and case are ignored.
(char-greaterp char &rest others)
function
Return T if the arguments are in strictly decreasing alphabetic order.
   Font, bits, and case are ignored.
(char-int c)
function
Return the integer code of CHAR.
(char-lessp char &rest others)
function
Return T if the arguments are in strictly increasing alphabetic order.
   Font, bits, and case are ignored.
(char-name c)
function
Return the name (a STRING) for a CHARACTER object.
(char-not-equal char &rest others)
function
Return T if no two of the arguments are the same character.
   Font, bits, and case are ignored.
(char-not-greaterp char &rest others)
function
Return T if the arguments are in strictly non-decreasing alphabetic order.
   Font, bits, and case are ignored.
(char-not-lessp char &rest others)
function
Return T if the arguments are in strictly non-increasing alphabetic order.
   Font, bits, and case are ignored.
(char-upcase c)
function
Return CHAR converted to upper-case if that is possible.  Don't convert
   lowercase eszet (U+DF).
(char/= ch &rest others)
function
Return T if no two of the arguments are the same character.
(char< char &rest others)
function
Return T if the arguments are in strictly increasing alphabetic order.
(char<= char &rest others)
function
Return T if the arguments are in strictly non-decreasing alphabetic order.
(char= ch &rest others)
function
Return T if all of the arguments are the same character.
(char> char &rest others)
function
Return T if the arguments are in strictly decreasing alphabetic order.
(char>= char &rest others)
function
Return T if the arguments are in strictly non-increasing alphabetic order.
(character arg)
function
Coerce OBJECT into a CHARACTER if possible. Legal inputs are 
  characters, strings and symbols of length 1.
(characterp arg)
function
Return true if OBJECT is a CHARACTER, and NIL otherwise.
(check-type place typespec &optional string)
macro
CHECK-TYPE Place Typespec [String]
  Signal a restartable error of type TYPE-ERROR if the value of PLACE is
  not of the specified type. If an error is signalled and the restart is
  used to return, this can only return if the STORE-VALUE restart is
  invoked. In that case it will store into PLACE and start over.
(cis theta)
function
Return cos(Theta) + i sin(Theta), i.e. exp(i Theta).

CLASS

CLASS-NAME

CLASS-OF

(clear-input &optional input-stream)
function
Clear any available input from INPUT-STREAM.

CLEAR-OUTPUT

(close socket &key abort)
generic-function
The close generic function can be applied to sockets. It releases the
operating system resources associated with the socket.
(clrhash hash)
function
This removes all the entries from HASH-TABLE and returns the hash table
   itself.

CODE-CHAR

(coerce object output-type-spec)
function
Coerce the Object to an object of type Output-Type-Spec.
(compile spec &optional def)
function
Coerce DEFINITION (by default, the function whose name is NAME)
  to a compiled function, returning (VALUES THING WARNINGS-P FAILURE-P),
  where if NAME is NIL, THING is the result of compilation, and
  otherwise THING is NAME. When NAME is not NIL, the compiled function
  is also set into (MACRO-FUNCTION NAME) if NAME names a macro, or into
  (FDEFINITION NAME) otherwise.
(compile-file src &key output-file verbose print load features target save-local-symbols save-doc-strings save-definitions save-source-locations external-format force compile-file-original-truename compile-file-original-buffer-offset break-on-program-errors load-preserves-optimization-settings)
function
Compile SRC, producing a corresponding fasl file and returning its filename.
(compile-file-pathname pathname &rest ignore &key output-file &allow-other-keys)
function
Return a pathname describing what file COMPILE-FILE would write to given
   these arguments.

COMPILED-FUNCTION

(compiled-function-p form)
function
Return true if OBJECT is a COMPILED-FUNCTION, and NIL otherwise.
(compiler-macro-function name &optional env)
function
If NAME names a compiler-macro in ENV, return the expansion function, else
   return NIL. Can be set with SETF when ENV is NIL.
(complement function)
function
Return a new function that returns T whenever FUNCTION returns NIL and
   NIL whenever FUNCTION returns non-NIL.
(complex realpart &optional imagpart)
function
Return a complex number with the specified real and imaginary components.
(complexp x)
function
Return true if OBJECT is a COMPLEX, and NIL otherwise.

COMPUTE-APPLICABLE-METHODS

(compute-restarts &optional condition)
function
Return a list of all the currently active restarts ordered from most
   recently established to less recently established. If CONDITION is
   specified, then only restarts associated with CONDITION (or with no
   condition) will be returned.
(concatenate output-type-spec &rest sequences)
function
Return a new sequence of all the argument sequences concatenated together
  which shares no structure with the original argument sequences of the
  specified OUTPUT-TYPE-SPEC.

CONCATENATED-STREAM

CONCATENATED-STREAM-STREAMS

COND

CONDITION

(conjugate number)
function
Return the complex conjugate of NUMBER. For non-complex numbers, this is
  an identity.

CONS

(consp x)
function
Return true if OBJECT is a CONS, and NIL otherwise.
(constantly x)
function
Return a function that always returns VALUE.
(constantp form &optional env)
function
True of any Lisp object that has a constant value: types that eval to
  themselves, keywords, constants, and list whose car is QUOTE.
(continue &optional condition)
function
Transfer control to a restart named CONTINUE, or return NIL if none exists.

CONTROL-ERROR

(copy-alist alist)
function
Return a new association list which is EQUAL to ALIST.
(copy-list list)
function
Return a new list which is EQUAL to LIST.

COPY-PPRINT-DISPATCH

COPY-READTABLE

(copy-seq sequence)
function
Return a copy of SEQUENCE which is EQUAL to SEQUENCE but not EQ.
(copy-structure source)
function
Return a copy of STRUCTURE with the same (EQL) slot values.
(copy-symbol symbol &optional copy-props)
function
Make and return a new uninterned symbol with the same print name
  as SYMBOL. If COPY-PROPS is false, the new symbol is neither bound
  nor fbound and has no properties, else it has a copy of SYMBOL's
  function, value and property list.
(copy-tree tree)
function
Recursively copy trees of conses.
(cos x)
function
Return the cosine of NUMBER.
(cosh x)
function
Return the hyperbolic cosine of NUMBER.
(count item sequence &key from-end test test-not start end key)
function
Return the number of elements in SEQUENCE satisfying a test with ITEM,
   which defaults to EQL.
(count-if test sequence &key from-end start end key)
function
Return the number of elements in SEQUENCE satisfying PRED(el).
(count-if-not test sequence &key from-end start end key)
function
Return the number of elements in SEQUENCE not satisfying TEST(el).
(ctypecase keyplace &body clauses)
macro
CTYPECASE Key {(Type Form*)}*
  Evaluates the Forms in the first clause for which TYPEP of Keyform and Type
  is true. If no form is satisfied then a correctable error is signalled.
(decf place &optional (delta 1))
macro
The first argument is some location holding a number.  This number is
decremented by the second argument, DELTA, which defaults to 1.
(declaim &rest decl-specs)
macro
DECLAIM Declaration*
  Do a declaration or declarations for the global environment.
(decode-float n)
function
Return three values:
   1) a floating-point number representing the significand. This is always
      between 0.5 (inclusive) and 1.0 (exclusive).
   2) an integer representing the exponent.
   3) -1.0 or 1.0 (i.e. the sign of the argument.)
(decode-universal-time universal-time &optional time-zone)
function
Converts a universal-time to decoded time format returning the following
   nine values: second, minute, hour, date, month, year, day of week (0 =
   Monday), T (daylight savings time) or NIL (standard time), and timezone.
   Completely ignores daylight-savings-time when time-zone is supplied.

DEFCLASS

(defconstant sym val &optional (doc NIL doc-p))
macro
Define a global constant, saying that the value is constant and may be
  compiled into code. If the variable already has a value, and this is not
  EQL to the new value, the code is not portable (undefined behavior). The
  third argument is an optional documentation string for the variable.

DEFGENERIC

(define-compiler-macro name arglist &body body)
macro
Define a compiler-macro for NAME.

DEFINE-CONDITION

DEFINE-METHOD-COMBINATION

(define-modify-macro name lambda-list function &optional doc-string)
macro
Creates a new read-modify-write macro like PUSH or INCF.
(define-setf-expander access-fn lambda-list &body body)
macro
Syntax like DEFMACRO, but creates a setf expander function. The body
  of the definition must be a form that returns five appropriate values.

DEFINE-SYMBOL-MACRO

DEFMACRO

DEFMETHOD

(defpackage name &rest options)
macro
Defines a new package called PACKAGE. Each of OPTIONS should be one of the 
   following: 
    (NICKNAMES {package-name}*)

    (SIZE <integer>)
    (SHADOW {symbol-name}*)
    (SHADOWING-IMPORT-FROM <package-name> {symbol-name}*)
    (USE {package-name}*)
    (IMPORT-FROM <package-name> {symbol-name}*)
    (INTERN {symbol-name}*)
    (EXPORT {symbol-name}*)
    (IMPLEMENT {package-name}*)
    (LOCK boolean)
    (DOCUMENTATION doc-string)
   All options except SIZE, LOCK, and :DOCUMENTATION can be used multiple 
   times.
(defparameter var value &optional doc)
macro
Define a parameter that is not normally changed by the program,
  but that may be changed without causing an error. Declare the
  variable special and sets its value to VAL, overwriting any
  previous value. The third argument is an optional documentation
  string for the parameter.
(defsetf access-fn &rest rest)
macro
Associates a SETF update function or macro with the specified access
  function or macro. The format is complex. See the manual for details.
(defstruct options &rest slots)
macro
DEFSTRUCT {Name | (Name Option*)} {Slot | (Slot [Default] {Key Value}*)}
   Define the structure type Name. Instances are created by MAKE-<name>, 
   which takes &KEY arguments allowing initial slot values to the specified.
   A SETF'able function <name>-<slot> is defined for each slot to read and
   write slot values. <name>-p is a type predicate.

   Popular DEFSTRUCT options (see manual for others):

   (:CONSTRUCTOR Name)
   (:PREDICATE Name)
       Specify the name for the constructor or predicate.

   (:CONSTRUCTOR Name Lambda-List)
       Specify the name and arguments for a BOA constructor
       (which is more efficient when keyword syntax isn't necessary.)

   (:INCLUDE Supertype Slot-Spec*)
       Make this type a subtype of the structure type Supertype. The optional
       Slot-Specs override inherited slot options.

   Slot options:

   :TYPE Type-Spec
       Asserts that the value of this slot is always of the specified type.

   :READ-ONLY {T | NIL}
       If true, no setter function is defined for this slot.
(deftype name arglist &body body)
macro
Define a new type, with syntax like DEFMACRO.

DEFUN

(defvar var &optional (value NIL value-p) doc)
macro
Define a global variable at top level. Declare the variable
  SPECIAL and, optionally, initialize it. If the variable already has a
  value, the old value is not clobbered. The third argument is an optional
  documentation string for the variable.
(delete item sequence &key from-end test test-not start end count key)
function
Return a sequence formed by destructively removing the specified ITEM from
  the given SEQUENCE.
(delete-duplicates sequence &key test test-not start from-end end key)
function
The elements of SEQUENCE are examined, and if any two match, one is
   discarded.  The resulting sequence, which may be formed by destroying the
   given sequence, is returned.
   Sequences of type STR have a NEW str returned.
(delete-file path)
function
Delete the specified FILE.
(delete-if test sequence &key from-end start end count key)
function
Return a sequence formed by destructively removing the elements satisfying
  the specified PREDICATE from the given SEQUENCE.
(delete-if-not test sequence &key from-end start end count key)
function
Return a sequence formed by destructively removing the elements not
  satisfying the specified PREDICATE from the given SEQUENCE.
(delete-package package)
function
Delete the package designated by PACKAGE-DESIGNATOR from the package
  system data structures.
(denominator rational)
function
Return the denominator of NUMBER, which must be rational.
(deposit-field value bytespec integer)
function
Return new integer with newbyte in specified position, newbyte is not right justified.
(describe object &optional stream)
function
Print a description of the object X.

DESCRIBE-OBJECT

(destructuring-bind lambda-list expression &body body)
macro
Bind the variables in LAMBDA-LIST to the contents of ARG-LIST.
(digit-char weight &optional radix)
function
All arguments must be integers. Returns a character object that
  represents a digit of the given weight in the specified radix. Returns
  NIL if no such character exists.
(digit-char-p char &optional radix)
function
If char is a digit in the specified radix, returns the fixnum for
  which that digit stands, else returns NIL.
(directory path &key directories files all directory-pathnames include-emacs-lockfiles test follow-links)
function
Return a list of PATHNAMEs, each the TRUENAME of a file that matched the
   given pathname. Note that the interaction between this ANSI-specified
   TRUENAMEing and the semantics of the Unix filesystem (symbolic links..)
   means this function can sometimes return files which don't have the same
   directory as PATHNAME.
(directory-namestring path)
function
Return a string representation of the directories used in the pathname.
(disassemble thing)
function
Disassemble the compiled code associated with OBJECT, which can be a
  function, a lambda expression, or a symbol with a function definition. If
  it is not already compiled, the compiler is called to produce something to
  disassemble.

DIVISION-BY-ZERO

(do var-init-steps (&optional end-test &rest result) &body body)
macro
DO ({(Var [Init] [Step])}*) (Test Exit-Form*) Declaration* Form*
  Iteration construct. Each Var is initialized in parallel to the value of the
  specified Init form. On subsequent iterations, the Vars are assigned the
  value of the Step form (if any) in parallel. The Test is evaluated before
  each evaluation of the body Forms. When the Test is true, the Exit-Forms
  are evaluated as a PROGN, with the result being the value of the DO. A block
  named NIL is established around the entire expansion, allowing RETURN to be
  used as an alternate exit mechanism.
(do* var-init-steps (&optional end-test &rest result) &body body)
macro
DO* ({(Var [Init] [Step])}*) (Test Exit-Form*) Declaration* Form*
  Iteration construct. Each Var is initialized sequentially (like LET*) to the
  value of the specified Init form. On subsequent iterations, the Vars are
  sequentially assigned the value of the Step form (if any). The Test is
  evaluated before each evaluation of the body Forms. When the Test is true,
  the Exit-Forms are evaluated as a PROGN, with the result being the value
  of the DO. A block named NIL is established around the entire expansion,
  allowing RETURN to be used as an laternate exit mechanism.
(do-all-symbols (var &optional resultform) &body body)
macro
DO-ALL-SYMBOLS (VAR [RESULT-FORM]) {DECLARATION}* {TAG | FORM}*
   Executes the FORMs once for each symbol in every package with VAR bound
   to the current symbol.
(do-external-symbols (var &optional pkg result) &body body)
macro
DO-EXTERNAL-SYMBOLS (VAR [PACKAGE [RESULT-FORM]]) {DECL}* {TAG | FORM}*
   Executes the FORMs once for each external symbol in the given PACKAGE with
   VAR bound to the current symbol.
(do-symbols (var &optional pkg result) &body body)
macro
DO-SYMBOLS (VAR [PACKAGE [RESULT-FORM]]) {DECLARATION}* {TAG | FORM}*
   Executes the FORMs at least once for each symbol accessible in the given
   PACKAGE with VAR bound to the current symbol.

DOCUMENTATION

DOLIST

DOTIMES

DOUBLE-FLOAT

DOUBLE-FLOAT-EPSILON

DOUBLE-FLOAT-NEGATIVE-EPSILON

(dpb value bytespec integer)
function
Return new integer with newbyte in specified position, newbyte is right justified.
(dribble &optional filename)
function
With a file name as an argument, dribble opens the file and sends a
     record of further I/O to that file. Without an argument, it closes
     the dribble file, and quits logging.
(ecase key &body forms)
macro
ECASE Keyform {({(Key*) | Key} Form*)}*
  Evaluates the Forms in the first clause with a Key EQL to the value of
  Keyform. If none of the keys matches then an error is signalled.

ECHO-STREAM

ECHO-STREAM-INPUT-STREAM

ECHO-STREAM-OUTPUT-STREAM

ED

(eighth list)
function
Return the 8th object in a list or NIL if there is no 8th object.
(elt sequence idx)
function
Return the element of SEQUENCE specified by INDEX.
(encode-universal-time second minute hour date month year &optional time-zone)
function
The time values specified in decoded format are converted to
   universal time, which is returned.

END-OF-FILE

ENDP

(enough-namestring path &optional defaults)
function
Return an abbreviated pathname sufficent to identify the pathname relative
   to the defaults.
(ensure-directories-exist pathspec &key verbose mode)
function
Test whether the directories containing the specified file
  actually exist, and attempt to create them if they do not.
  The MODE argument is an extension to control the Unix permission
  bits.  Portable programs should avoid using the :MODE keyword
  argument.

ENSURE-GENERIC-FUNCTION

(eq x y)
function
Return T if OBJ1 and OBJ2 are the same object, otherwise NIL.
(eql arg-0 arg-1)
function
Return T if OBJ1 and OBJ2 represent either the same object or
numbers with the same type and value.
(equal arg-0 arg-1)
function
Return T if X and Y are EQL or if they are structured components
  whose elements are EQUAL. Strings and bit-vectors are EQUAL if they
  are the same length and have identical components. Other arrays must be
  EQ to be EQUAL.  Pathnames are EQUAL if their components are.
(equalp x y)
function
Just like EQUAL, but more liberal in several respects.
  Numbers may be of different types, as long as the values are identical
  after coercion.  Characters may differ in alphabetic case.  Vectors and
  arrays must have identical dimensions and EQUALP elements, but may differ
  in their type restriction.
  If one of x or y is a pathname and one is a string with the name of the
  pathname then this will return T.
(error condition &rest args)
function
Invoke the signal facility on a condition formed from DATUM and ARGUMENTS.
  If the condition is not handled, the debugger is invoked.
(etypecase keyform &body clauses)
macro
ETYPECASE Keyform {(Type Form*)}*
  Evaluates the Forms in the first clause for which TYPEP of Keyform and Type
  is true. If no form is satisfied then an error is signalled.

EVAL

EVAL-WHEN

(evenp n)
function
Is this integer even?
(every predicate one-seq &rest sequences)
function
Apply PREDICATE to the 0-indexed elements of the sequences, then
   possibly to those with index 1, and so on. Return NIL as soon
   as any invocation of PREDICATE returns NIL, or T if every invocation
   is non-NIL.
(exp x)
function
Return e raised to the power NUMBER.
(export sym-or-syms &optional package)
function
Exports SYMBOLS from PACKAGE, checking that no name conflicts result.
(expt b e)
function
Return BASE raised to the POWER.
(fboundp name)
function
Return true if name has a global function definition.
(fceiling number &optional divisor)
function
Same as CEILING, but returns first value as a float.

FDEFINITION

(ffloor number &optional divisor)
function
Same as FLOOR, but returns first value as a float.
(fifth list)
function
Return the 5th object in a list or NIL if there is no 5th object.
(file-author path)
function
Return the file author as a string, or NIL if the author cannot be
  determined. Signal an error of type FILE-ERROR if FILE doesn't exist,
  or FILE is a wild pathname.

FILE-ERROR

FILE-ERROR-PATHNAME

FILE-LENGTH

(file-namestring path)
function
Return a string representation of the name used in the pathname.

FILE-POSITION

FILE-STREAM

(file-string-length stream object)
function
Return the delta in STREAM's FILE-POSITION that would be caused by writing
   OBJECT to STREAM. Non-trivial only in implementations that support
   international character sets.
(file-write-date path)
function
Return file's last modification date, or NIL if it doesn't exist.
  An error of type file-error is signaled if file is a wild pathname
(fill sequence item &key start end)
function
Replace the specified elements of SEQUENCE with ITEM.
   !$ could be sped up by calling iv-fill, sv-fill to avoid aref overhead.
(fill-pointer array)
function
Return the FILL-POINTER of the given VECTOR.

FIND

(find-all-symbols name)
function
Return a list of all symbols in the system having the specified name.

FIND-CLASS

FIND-IF

FIND-IF-NOT

FIND-METHOD

FIND-PACKAGE

(find-restart name &optional condition)
function
Return the first active restart named NAME. If NAME names a
   restart, the restart is returned if it is currently active. If no such
   restart is found, NIL is returned. It is an error to supply NIL as a
   name. If CONDITION is specified and not NIL, then only restarts
   associated with that condition (or with no condition) will be
   returned.
(find-symbol string &optional package)
function
Return the symbol named STRING in PACKAGE. If such a symbol is found
  then the second value is :INTERNAL, :EXTERNAL or :INHERITED to indicate
  how the symbol is accessible. If no symbol is found then both values
  are NIL.

FINISH-OUTPUT

(first list)
function
Return the 1st object in a list or NIL if the list is empty.

FIXNUM

FLET

(float number &optional other)
function
Converts any REAL to a float. If OTHER is not provided, it returns a
  SINGLE-FLOAT if NUMBER is not already a FLOAT. If OTHER is provided, the
  result is the same float format as OTHER.

FLOAT-DIGITS

(float-precision float)
function
Return a non-negative number of significant digits in its float argument.
  Will be less than FLOAT-DIGITS if denormalized or zero.
(float-radix float)
function
Return (as an integer) the radix b of its floating-point argument.
(float-sign n1 &optional n2)
function
Return a floating-point number that has the same sign as
   FLOAT1 and, if FLOAT2 is given, has the same absolute value
   as FLOAT2.

FLOATING-POINT-INEXACT

FLOATING-POINT-INVALID-OPERATION

FLOATING-POINT-OVERFLOW

FLOATING-POINT-UNDERFLOW

(floatp x)
function
Return true if OBJECT is a FLOAT, and NIL otherwise.
(floor number &optional divisor)
function
Return the greatest integer not greater than number, or number/divisor.
  The second returned value is (mod number divisor).
(fmakunbound name)
function
Make NAME have no global function definition.

FORCE-OUTPUT

FORMAT

FORMATTER

(fourth list)
function
Return the 4th object in a list or NIL if there is no 4th object.
(fresh-line &optional output-stream)
function
Output #Newline only if the OUTPUT-STREAM is not already at the
start of a line.  Return T if #Newline needed.
(fround number &optional divisor)
function
Same as ROUND, but returns first value as a float.
(ftruncate number &optional divisor)
function
Same as TRUNCATE, but returns first value as a float.
(funcall fn &rest args)
function
Call FUNCTION with the given ARGUMENTS.

FUNCTION

FUNCTION-KEYWORDS

(function-lambda-expression fn)
function
Return (VALUES DEFINING-LAMBDA-EXPRESSION CLOSURE-P NAME), where
  DEFINING-LAMBDA-EXPRESSION is NIL if unknown, or a suitable argument
  to COMPILE otherwise, CLOSURE-P is non-NIL if the function's definition
  might have been enclosed in some non-null lexical environment, and
  NAME is some name (for debugging only) or NIL if there is no name.
(functionp arg)
function
Return true if OBJECT is a FUNCTION, and NIL otherwise.
(gcd &lexpr numbers)
function
Return the greatest common divisor of the arguments, which must be
  integers. Gcd with no arguments is defined to be 0.

GENERIC-FUNCTION

(gensym &optional string-or-integer)
function
Creates a new uninterned symbol whose name is a prefix string (defaults
   to "G"), followed by a decimal number. Thing, when supplied, will
   alter the prefix if it is a string, or be used for the decimal number
   if it is a number, of this symbol. The default value of the number is
   the current value of *gensym-counter* which is incremented each time
   it is used.
(gentemp &optional prefix package)
function
Creates a new symbol interned in package PACKAGE with the given PREFIX.
(get sym key &optional default)
function
Look on the property list of SYMBOL for the specified INDICATOR. If this
  is found, return the associated value, else return DEFAULT.
(get-decoded-time)
function
Return nine values specifying the current time as follows:
   second, minute, hour, date, month, year, day of week (0 = Monday), T
   (daylight savings times) or NIL (standard time), and timezone.
(get-dispatch-macro-character disp-ch sub-ch &optional readtable)
function
Return the macro character function for SUB-CHAR under DISP-CHAR
   or NIL if there is no associated function.
(get-internal-real-time)
function
Return the real time in the internal time format. (See
  INTERNAL-TIME-UNITS-PER-SECOND.) This is useful for finding elapsed time.
(get-internal-run-time)
function
Return the run time in the internal time format. (See
  INTERNAL-TIME-UNITS-PER-SECOND.) This is useful for finding CPU usage.
(get-macro-character char &optional readtable)
function
Return the function associated with the specified CHAR which is a macro
  character, or NIL if there is no such function. As a second value, return
  T if CHAR is a macro character which is non-terminating, i.e. which can
  be embedded in a symbol name.

GET-OUTPUT-STREAM-STRING

(get-properties place indicator-list)
function
Like GETF, except that INDICATOR-LIST is a list of indicators which will
  be looked for in the property list stored in PLACE. Three values are
  returned, see manual for details.
(get-setf-expansion form &optional env)
function
Return five values needed by the SETF machinery: a list of temporary
   variables, a list of values with which to fill them, a list of temporaries
   for the new values, the setting function, and the accessing function.
(get-universal-time)
function
Return a single integer for the current time of
   day in universal time format.
(getf place key &optional default)
function
Search the property list stored in Place for an indicator EQ to INDICATOR.
  If one is found, return the corresponding value, else return DEFAULT.
(gethash key hash &optional default)
function
Finds the entry in HASH-TABLE whose key is KEY and returns the associated
   value and T as multiple values, or returns DEFAULT and NIL if there is no
   such entry. Entries can be added using SETF.

GO

(graphic-char-p c)
function
The argument must be a character object. GRAPHIC-CHAR-P returns NIL if the
  argument is a Unicode control character, otherwise returns T.
(handler-bind clauses &body body)
macro
(HANDLER-BIND ( {(type handler)}* )  body)
   Executes body in a dynamic context where the given handler bindings are
   in effect. Each handler must take the condition being signalled as an
   argument. The bindings are searched first to last in the event of a
   signalled condition.
(handler-case form &rest clauses)
macro
(HANDLER-CASE form
   { (type ([var]) body) }* )
   Execute FORM in a context with handlers established for the condition
   types. A peculiar property allows type to be :NO-ERROR. If such a clause
   occurs, and form returns normally, all its values are passed to this clause
   as if by MULTIPLE-VALUE-CALL.  The :NO-ERROR clause accepts more than one
   var specification.

HASH-TABLE

(hash-table-count hash)
function
Return the number of entries in the given HASH-TABLE.

HASH-TABLE-P

(hash-table-rehash-size hash)
function
Return the rehash-size HASH-TABLE was created with.
(hash-table-rehash-threshold hash)
function
Return the rehash-threshold HASH-TABLE was created with.
(hash-table-size hash)
function
Return a size that can be used with MAKE-HASH-TABLE to create a hash
   table that can hold however many entries HASH-TABLE can hold without
   having to be grown.
(hash-table-test hash)
function
Return the test HASH-TABLE was created with.
(host-namestring path)
function
Return a string representation of the name of the host in the pathname.
(identity x)
function
This function simply returns what was passed to it.

IF

(ignore-errors &rest forms)
macro
Execute FORMS handling ERROR conditions, returning the result of the last
  form, or (VALUES NIL the-ERROR-that-was-caught) if an ERROR was handled.
(imagpart number)
function
Extract the imaginary part of a number.
(import sym-or-syms &optional package)
function
Make SYMBOLS accessible as internal symbols in PACKAGE. If a symbol
  is already accessible then it has no effect. If a name conflict
  would result from the importation, then a correctable error is signalled.

IN-PACKAGE

(incf place &optional (delta 1))
macro
The first argument is some location holding a number.  This number is
incremented by the second argument, DELTA, which defaults to 1.

INITIALIZE-INSTANCE

INPUT-STREAM-P

INSPECT

INTEGER

(integer-decode-float x)
function
Returns three values:
   1) an integer representation of the significand.
   2) the exponent for the power of 2 that the significand must be multiplied
      by to get the actual value.  This differs from the DECODE-FLOAT exponent
      by FLOAT-DIGITS, since the significand has been scaled to have all its
      digits before the radix point.
   3) -1 or 1 (i.e. the sign of the argument.)
(integer-length integer)
function
Return the number of significant bits in the absolute value of integer.
(integerp x)
function
Return true if OBJECT is an INTEGER, and NIL otherwise.

INTERACTIVE-STREAM-P

(intern str &optional package)
function
Return a symbol in PACKAGE having the specified NAME, creating it
  if necessary.
internal-time-units-per-second
constant
The number of internal time units that fit into a second. See
  GET-INTERNAL-REAL-TIME and GET-INTERNAL-RUN-TIME.
Initial value: 1000000
(intersection list1 list2 &key key test test-not)
function
Return the intersection of LIST1 and LIST2.

INVALID-METHOD-ERROR

(invoke-debugger condition)
function
Enter the debugger.
(invoke-restart restart &rest values)
function
Calls the function associated with the given restart, passing any given
   arguments. If the argument restart is not a restart or a currently active
   non-nil restart name, then a CONTROL-ERROR is signalled.
(invoke-restart-interactively restart)
function
Calls the function associated with the given restart, prompting for any
   necessary arguments. If the argument restart is not a restart or a
   currently active non-NIL restart name, then a CONTROL-ERROR is signalled.
(isqrt n)
function
Return the root of the nearest integer less than n which is a perfect
   square.  Argument n must be a non-negative integer

KEYWORD

(keywordp x)
function
Return true if Object is a symbol in the "KEYWORD" package.

LABELS

LAMBDA

lambda-list-keywords
constant
symbols which are magical in a lambda list
Initial value: (&OPTIONAL &REST &AUX &KEY &ALLOW-OTHER-KEYS &BODY &ENVIRONMENT &WHOLE)
lambda-parameters-limit
constant
The exclusive upper bound on the number of parameters which may be specifed
  in a given lambda list. This is actually the limit on required and &OPTIONAL
  parameters. With &KEY and &AUX you can get more.
Initial value: 4096
(last list &optional n)
function
Return the last N conses (not the last element!) of a list.
(lcm &lexpr numbers)
function
Return the least common multiple of one or more integers. LCM of no
  arguments is defined to be 1.
(ldb bytespec integer)
function
Extract the specified byte from integer, and right justify result.
(ldb-test bytespec integer)
function
Return T if any of the specified bits in integer are 1's.
(ldiff list object)
function
Return a new list, whose elements are those of LIST that appear before
   OBJECT. If OBJECT is not a tail of LIST, a copy of LIST is returned.
   LIST must be a proper list or a dotted list.

LEAST-NEGATIVE-DOUBLE-FLOAT

LEAST-NEGATIVE-LONG-FLOAT

LEAST-NEGATIVE-NORMALIZED-DOUBLE-FLOAT

LEAST-NEGATIVE-NORMALIZED-LONG-FLOAT

LEAST-NEGATIVE-NORMALIZED-SHORT-FLOAT

LEAST-NEGATIVE-NORMALIZED-SINGLE-FLOAT

LEAST-NEGATIVE-SHORT-FLOAT

LEAST-NEGATIVE-SINGLE-FLOAT

LEAST-POSITIVE-DOUBLE-FLOAT

LEAST-POSITIVE-LONG-FLOAT

LEAST-POSITIVE-NORMALIZED-DOUBLE-FLOAT

LEAST-POSITIVE-NORMALIZED-LONG-FLOAT

LEAST-POSITIVE-NORMALIZED-SHORT-FLOAT

LEAST-POSITIVE-NORMALIZED-SINGLE-FLOAT

LEAST-POSITIVE-SHORT-FLOAT

LEAST-POSITIVE-SINGLE-FLOAT

(length seq)
function
Return an integer that is the length of SEQUENCE.

LET

LET*

LISP-IMPLEMENTATION-TYPE

LISP-IMPLEMENTATION-VERSION

(list &rest args)
function
Return constructs and returns a list of its arguments.
(list* arg &rest others)
function
Return a list of the arguments with last cons a dotted pair
(list-all-packages)
function
Return a list of all existing packages.
(list-length l)
function
Return the length of the given LIST, or NIL if the LIST is circular.

LISTEN

LISTP

(load file-name &key verbose print if-does-not-exist external-format preserve-optimization-settings)
function
Load the file given by FILESPEC into the Lisp environment, returning
   T on success.

   Extension: :PRINT :SOURCE means print source as well as value

LOAD-LOGICAL-PATHNAME-TRANSLATIONS

LOAD-TIME-VALUE

LOCALLY

(log x &optional b)
function
Return the logarithm of NUMBER in the base BASE, which defaults to e.
(logand &lexpr numbers)
function
Return the bit-wise and of its arguments. Args must be integers.
(logandc1 x y)
function
Return the logical AND of (LOGNOT integer1) and integer2.
(logandc2 integer1 integer2)
function
Bitwise AND INTEGER1 with (LOGNOT INTEGER2).
(logbitp index integer)
function
Predicate returns T if bit index of integer is a 1.
(logcount integer)
function
Count the number of 1 bits if INTEGER is positive, and the number of 0 bits
  if INTEGER is negative.
(logeqv &lexpr numbers)
function
Return the bit-wise equivalence of its arguments. Args must be integers.
(logical-pathname thing)
function
Converts the pathspec argument to a logical-pathname and returns it.
(logical-pathname-translations host)
function
Return the (logical) host object argument's list of translations.
(logior &lexpr numbers)
function
Return the bit-wise or of its arguments. Args must be integers.
(lognand integer1 integer2)
function
Complement the logical AND of INTEGER1 and INTEGER2.
(lognor integer1 integer2)
function
Complement the logical AND of INTEGER1 and INTEGER2.
(lognot number)
function
Return the bit-wise logical not of integer.
(logorc1 integer1 integer2)
function
Return the logical OR of (LOGNOT integer1) and integer2.
(logorc2 integer1 integer2)
function
Bitwise OR INTEGER1 with (LOGNOT INTEGER2).
(logtest integer1 integer2)
function
Predicate which returns T if logand of integer1 and integer2 is not zero.
(logxor &lexpr numbers)
function
Return the bit-wise exclusive or of its arguments. Args must be integers.

LONG-FLOAT

LONG-FLOAT-EPSILON

LONG-FLOAT-NEGATIVE-EPSILON

(long-site-name)
function
Return a string with the long form of the site name, or NIL if not known.

LOOP

(loop-finish)
macro
Cause the iteration to terminate "normally", the same as implicit
termination by an iteration driving clause, or by use of WHILE or
UNTIL -- the epilogue code (if any) will be run, and any implicitly
collected result will be returned as the value of the LOOP.
(lower-case-p c)
function
The argument must be a character object; LOWER-CASE-P returns T if the
   argument is a lower-case character, NIL otherwise.
(machine-instance)
function
Return a string giving the name of the local machine.
(machine-type)
function
Returns a string describing the type of the local machine.
(machine-version)
function
Return a string describing the version of the computer hardware we
are running on, or NIL if we can't find any useful information.
(macro-function form &optional env)
function
If SYMBOL names a macro in ENV, returns the expansion function,
   else returns NIL. If ENV is unspecified or NIL, use the global
   environment only.
(macroexpand form &optional env)
function
Repetitively call MACROEXPAND-1 until the form can no longer be expanded.
   Returns the final resultant form, and T if it was expanded. ENV is the
   lexical environment to expand in, or NIL (the default) for the null
   environment.
(macroexpand-1 form &optional env)
function
If form is a macro (or symbol macro), expand it once. Return two values,
   the expanded form and a T-or-NIL flag indicating whether the form was, in
   fact, a macro. ENV is the lexical environment to expand in, which defaults
   to the null environment.

MACROLET

MAKE-ARRAY

MAKE-BROADCAST-STREAM

(make-concatenated-stream &rest streams)
function
Return a stream which takes its input from each of the streams in turn,
   going on to the next at EOF.
(make-condition name &rest init-list)
function
Make an instance of a condition object using the specified initargs.
(make-dispatch-macro-character char &optional non-terminating-p readtable)
function
Cause CHAR to become a dispatching macro character in readtable (which
   defaults to the current readtable). If NON-TERMINATING-P, the char will
   be non-terminating.
(make-echo-stream input-stream output-stream)
function
Return a bidirectional stream which gets its input from INPUT-STREAM and
   sends its output to OUTPUT-STREAM. In addition, all input is echoed to
   the output stream.
(make-hash-table &key test size rehash-size rehash-threshold hash-function weak finalizeable address-based lock-free shared)
function
Create and return a new hash table. The keywords are as follows:
     :TEST -- Indicates what kind of test to use.
     :SIZE -- A hint as to how many elements will be put in this hash
       table.
     :REHASH-SIZE -- Indicates how to expand the table when it fills up.
       If an integer, add space for that many elements. If a floating
       point number (which must be greater than 1.0), multiply the size
       by that amount.
     :REHASH-THRESHOLD -- Indicates how dense the table can become before
       forcing a rehash. Can be any positive number <=1, with density
       approaching zero as the threshold approaches 0. Density 1 means an
       average of one entry per bucket.

MAKE-INSTANCE

MAKE-INSTANCES-OBSOLETE

(make-list size &key initial-element)
function
Constructs a list with size elements each set to value

MAKE-LOAD-FORM

MAKE-LOAD-FORM-SAVING-SLOTS

(make-package name &key nicknames use internal-size external-size)
function
Make a new package having the specified NAME, NICKNAMES, and 
  USE list. :INTERNAL-SYMBOLS and :EXTERNAL-SYMBOLS are
  estimates for the number of internal and external symbols which
  will ultimately be present in the package. The default value of
  USE is implementation-dependent, and in this implementation
  it is NIL.
(make-pathname &key host device directory name type version defaults case)
function
Makes a new pathname from the component arguments. Note that host is
a host-structure or string.
(make-random-state &optional state)
function
Make a new random state object. If STATE is not supplied, return a
  copy of the current random state. If STATE is a random state, then
  return a copy of it. If STATE is T then return a randomly
  initialized random state.
(make-sequence type length &key initial-element)
function
Return a sequence of the given TYPE and LENGTH, with elements initialized
  to INITIAL-ELEMENT.
(make-string size &key initial-element element-type)
function
Given a character count and an optional fill character, makes and returns
   a new string COUNT long filled with the fill character.
(make-string-input-stream string &optional start end)
function
Return an input stream which will supply the characters of STRING between
  START and END in order.
(make-string-output-stream &key element-type)
function
Return an output stream which will accumulate all output given it for
   the benefit of the function GET-OUTPUT-STREAM-STRING.
(make-symbol name)
function
Make and return a new symbol with the NAME as its print name.

MAKE-SYNONYM-STREAM

(make-two-way-stream in out)
function
Return a bidirectional stream which gets its input from INPUT-STREAM and
   sends its output to OUTPUT-STREAM.
(makunbound sym)
function
Make SYMBOL unbound, removing any value it may currently have.

MAP

MAP-INTO

(mapc function list &rest more-lists)
function
Apply FUNCTION to successive elements of lists. Return the second argument.
(mapcan function list &rest more-lists)
function
Apply FUNCTION to successive elements of LIST. Return NCONC of FUNCTION
   results.
(mapcar function list &rest more-lists)
function
Apply FUNCTION to successive elements of LIST. Return list of FUNCTION
   return values.
(mapcon function list &rest more-lists)
function
Apply FUNCTION to successive CDRs of lists. Return NCONC of results.
(maphash function hash-table)
function
For each entry in HASH-TABLE, call the designated two-argument function
   on the key and value of the entry. Return NIL.
(mapl function list &rest more-lists)
function
Apply FUNCTION to successive CDRs of list. Return NIL.
(maplist function list &rest more-lists)
function
Apply FUNCTION to successive CDRs of list. Return list of results.
(mask-field bytespec integer)
function
Extract the specified byte from integer, but do not right justify result.
(max num &lexpr more)
function
Return the greatest of its arguments; among EQUALP greatest, return
   the first.
(member item list &key test test-not key)
function
Return the tail of LIST beginning with first element satisfying EQLity,
   :TEST, or :TEST-NOT with the given ITEM.
(member-if test list &key key)
function
Return tail of LIST beginning with first element satisfying TEST.
(member-if-not test list &key key)
function
Return tail of LIST beginning with first element not satisfying TEST.
(merge result-type sequence1 sequence2 predicate &key key)
function
Merge the sequences SEQUENCE1 and SEQUENCE2 destructively into a
   sequence of type RESULT-TYPE using PREDICATE to order the elements.
   If result-type specifies an array, the returned array will not be
   a complex array. Usually, result-type is either LIST, ARRAY or STRING.
(merge-pathnames path &optional defaults default-version)
function
Construct a filled in pathname by completing the unspecified components
   from the defaults.

METHOD

METHOD-COMBINATION

METHOD-COMBINATION-ERROR

METHOD-QUALIFIERS

(min num &lexpr more)
function
Return the least of its arguments; among EQUALP least, return
  the first.
(minusp number)
function
Is this real number strictly negative?
(mismatch seq1 seq2 &key from-end test test-not key start1 start2 end1 end2)
function
The specified subsequences of SEQUENCE1 and SEQUENCE2 are compared
   element-wise. If they are of equal length and match in every element, the
   result is NIL. Otherwise, the result is a non-negative integer, the index
   within SEQUENCE1 of the leftmost position at which they fail to match; or,
   if one is shorter than and a matching prefix of the other, the index within
   SEQUENCE1 beyond the last position tested is returned. If a non-NIL
   :FROM-END argument is given, then one plus the index of the rightmost
   position in which the sequences differ is returned.
(mod number divisor)
function
Returns second result of FLOOR.

MOST-NEGATIVE-DOUBLE-FLOAT

most-negative-fixnum
constant
the fixnum closest in value to negative infinity
Initial value: -1152921504606846976

MOST-NEGATIVE-LONG-FLOAT

MOST-NEGATIVE-SHORT-FLOAT

MOST-NEGATIVE-SINGLE-FLOAT

MOST-POSITIVE-DOUBLE-FLOAT

most-positive-fixnum
constant
the fixnum closest in value to positive infinity
Initial value: 1152921504606846975

MOST-POSITIVE-LONG-FLOAT

MOST-POSITIVE-SHORT-FLOAT

MOST-POSITIVE-SINGLE-FLOAT

(muffle-warning &optional condition)
function
Transfer control to a restart named MUFFLE-WARNING, signalling a
   CONTROL-ERROR if none exists.

MULTIPLE-VALUE-BIND

MULTIPLE-VALUE-CALL

MULTIPLE-VALUE-LIST

MULTIPLE-VALUE-PROG1

MULTIPLE-VALUE-SETQ

multiple-values-limit
constant
The exclusive upper bound on the number of multiple VALUES that you can
  return.
Initial value: 200
(name-char name)
function
Given an argument acceptable to STRING, NAME-CHAR returns a character
  whose name is that string, if one exists. Otherwise, NIL is returned.
(namestring path)
function
Construct the full (name)string form of the pathname.
(nbutlast list &optional n)
function
Modifies List to remove the last N elements.
(nconc &rest lists)
function
Concatenates the lists given as arguments (by changing them)

NIL

(nintersection list1 list2 &key key test test-not)
function
Destructively return the intersection of LIST1 and LIST2.
(ninth list)
function
Return the 9th object in a list or NIL if there is no 9th object.

NO-APPLICABLE-METHOD

NO-NEXT-METHOD

NOT

(notany predicate one-seq &rest sequences)
function
Apply PREDICATE to the 0-indexed elements of the sequences, then 
   possibly to those with index 1, and so on. Return NIL as soon
   as any invocation of PREDICATE returns a non-NIL value, or T if the end
   of any sequence is reached.
(notevery predicate one-seq &rest sequences)
function
Apply PREDICATE to 0-indexed elements of the sequences, then
   possibly to those with index 1, and so on. Return T as soon
   as any invocation of PREDICATE returns NIL, or NIL if every invocation
   is non-NIL.
(nreconc x y)
function
Return (NCONC (NREVERSE X) Y).
(nreverse seq)
function
Return a sequence of the same elements in reverse order; the argument
   is destroyed.
(nset-difference list1 list2 &key key test test-not)
function
Destructively return the elements of LIST1 which are not in LIST2.
(nset-exclusive-or list1 list2 &key key test test-not)
function
Destructively return a list with elements which appear but once in LIST1
   and LIST2.

NSTRING-CAPITALIZE

NSTRING-DOWNCASE

NSTRING-UPCASE

(nsublis alist tree &key key test test-not)
function
Substitute from ALIST into TRUE destructively.
(nsubst new old tree &key key test test-not)
function
Substitute NEW for subtrees matching OLD.
(nsubst-if new test tree &key key)
function
Substitute NEW for subtrees of TREE for which TEST is true.
(nsubst-if-not new test tree &key key)
function
Substitute NEW for subtrees of TREE for which TEST is false.
(nsubstitute new old sequence &key from-end test test-not end count key start)
function
Return a sequence of the same kind as SEQUENCE with the same elements
  except that all elements equal to OLD are replaced with NEW. The SEQUENCE
  may be destructively modified. See manual for details.
(nsubstitute-if new test sequence &key from-end start end count key)
function
Return a sequence of the same kind as SEQUENCE with the same elements
   except that all elements satisfying the PRED are replaced with NEW. 
   SEQUENCE may be destructively modified. See manual for details.
(nsubstitute-if-not new test sequence &key from-end start end count key)
function
Return a sequence of the same kind as SEQUENCE with the same elements
   except that all elements not satisfying the TEST are replaced with NEW.
   SEQUENCE may be destructively modified. See manual for details.
(nth index list)
function
Return the nth object in a list where the car is the zero-th element.
(nth-value n form)
macro
Evaluate FORM and return the Nth value (zero based). This involves no
  consing when N is a trivial constant integer.
(nthcdr index list)
function
Performs the cdr function n times on a list.

NULL

NUMBER

(numberp x)
function
Return true if OBJECT is a NUMBER, and NIL otherwise.
(numerator rational)
function
Return the numerator of NUMBER, which must be rational.
(nunion list1 list2 &key key test test-not)
function
Destructively return the union of LIST1 and LIST2.
(oddp n)
function
Is this integer odd?
(open filename &key direction element-type if-exists if-does-not-exist external-format class sharing basic)
function
Return a stream which reads from or writes to FILENAME.
  Defined keywords:
   :DIRECTION - one of :INPUT, :OUTPUT, :IO, or :PROBE
   :ELEMENT-TYPE - the type of object to read or write, default BASE-CHAR
   :IF-EXISTS - one of :ERROR, :NEW-VERSION, :RENAME, :RENAME-AND-DELETE,
                       :OVERWRITE, :APPEND, :SUPERSEDE or NIL
   :IF-DOES-NOT-EXIST - one of :ERROR, :CREATE or NIL
  See the manual for details.

OPEN-STREAM-P

(or &rest args)
macro
Or Form*
OR evaluates each Form, in sequence, from left to right.
If any Form but the last returns a non-NIL value, OR returns that
single value (without evaluating any subsequent Forms.)  If OR evaluates
the last Form, it returns all values returned by that Form.  If there
are no Forms, OR returns NIL.

OUTPUT-STREAM-P

PACKAGE

PACKAGE-ERROR

PACKAGE-ERROR-PACKAGE

PACKAGE-NAME

PACKAGE-NICKNAMES

PACKAGE-SHADOWING-SYMBOLS

PACKAGE-USE-LIST

PACKAGE-USED-BY-LIST

PACKAGEP

(pairlis keys data &optional alist)
function
Construct an association list from KEYS and DATA (adding to ALIST).

PARSE-ERROR

(parse-integer string &key start end radix junk-allowed)
function
Examine the substring of string delimited by start and end
  (default to the beginning and end of the string)  It skips over
  whitespace characters and then tries to parse an integer. The
  radix parameter must be between 2 and 36.

PARSE-NAMESTRING

(pathname path)
function
Convert thing (a pathname, string or stream) into a pathname.
(pathname-device thing &key case)
function
Return PATHNAME's device.
(pathname-directory path &key case)
function
Return PATHNAME's directory.
(pathname-host thing &key case)
function
Return PATHNAME's host.
(pathname-match-p pathname wildname)
function
Pathname matches the wildname template?
(pathname-name path &key case)
function
Return PATHNAME's name.
(pathname-type path &key case)
function
Return PATHNAME's type.
(pathname-version path)
function
Return PATHNAME's version.

PATHNAMEP

PEEK-CHAR

(phase number)
function
Return the angle part of the polar representation of a complex number.
  For complex numbers, this is (atan (imagpart number) (realpart number)).
  For non-complex positive numbers, this is 0. For non-complex negative
  numbers this is PI.

PI

(plusp number)
function
Is this real number strictly positive?
(pop place)
macro
The argument is a location holding a list. Pops one item off the front
  of the list and returns it.

POSITION

POSITION-IF

POSITION-IF-NOT

(pprint object &optional stream)
function
Prettily output OBJECT preceded by a newline.

PPRINT-DISPATCH

(pprint-fill s list &optional colon? atsign?)
function
Output LIST to STREAM putting :FILL conditional newlines between each
   element. If COLON? is NIL (defaults to T), then no parens are printed
   around the output. ATSIGN? is ignored (but allowed so that PPRINT-FILL
   can be used with the ~/.../ format directive.
(pprint-indent relative-to n &optional stream)
function
Specify the indentation to use in the current logical block if STREAM
   (which defaults to *STANDARD-OUTPUT*) is it is a pretty-printing stream
   and do nothing if not. (See PPRINT-LOGICAL-BLOCK.)  N is the indentation
   to use (in ems, the width of an ``m'') and RELATIVE-TO can be either:
     :BLOCK - Indent relative to the column the current logical block
        started on.
     :CURRENT - Indent relative to the current column.
   The new indentation value does not take effect until the following line
   break.
(pprint-linear s list &optional colon? atsign?)
function
Output LIST to STREAM putting :LINEAR conditional newlines between each
   element. If COLON? is NIL (defaults to T), then no parens are printed
   around the output. ATSIGN? is ignored (but allowed so that PPRINT-LINEAR
   can be used with the ~/.../ format directive.

PPRINT-LOGICAL-BLOCK

(pprint-newline kind &optional stream)
function
Output a conditional newline to STREAM (which defaults to
   *STANDARD-OUTPUT*) if it is a pretty-printing stream, and do
   nothing if not. KIND can be one of:
     :LINEAR - A line break is inserted if and only if the immediatly
        containing section cannot be printed on one line.
     :MISER - Same as LINEAR, but only if ``miser-style'' is in effect.
        (See *PRINT-MISER-WIDTH*.)
     :FILL - A line break is inserted if and only if either:
       (a) the following section cannot be printed on the end of the
           current line,
       (b) the preceding section was not printed on a single line, or
       (c) the immediately containing section cannot be printed on one
           line and miser-style is in effect.
     :MANDATORY - A line break is always inserted.
   When a line break is inserted by any type of conditional newline, any
   blanks that immediately precede the conditional newline are ommitted
   from the output and indentation is introduced at the beginning of the
   next line. (See PPRINT-INDENT.)
(pprint-tab kind colnum colinc &optional stream)
function
If STREAM (which defaults to *STANDARD-OUTPUT*) is a pretty-printing
   stream, perform tabbing based on KIND, otherwise do nothing. KIND can
   be one of:
     :LINE - Tab to column COLNUM. If already past COLNUM tab to the next
       multiple of COLINC.
     :SECTION - Same as :LINE, but count from the start of the current
       section, not the start of the line.
     :LINE-RELATIVE - Output COLNUM spaces, then tab to the next multiple of
       COLINC.
     :SECTION-RELATIVE - Same as :LINE-RELATIVE, but count from the start
       of the current section, not the start of the line.
(pprint-tabular s list &optional colon? atsign? tabsize)
function
Output LIST to STREAM tabbing to the next column that is an even multiple
   of TABSIZE (which defaults to 16) between each element. :FILL style
   conditional newlines are also output between each element. If COLON? is
   NIL (defaults to T), then no parens are printed around the output.
   ATSIGN? is ignored (but allowed so that PPRINT-TABULAR can be used with
   the ~/.../ format directive.
(prin1 object &optional stream)
function
Output a mostly READable printed representation of OBJECT on the specified
  STREAM.
(prin1-to-string object)
function
Return the printed representation of OBJECT as a string with
   slashification on.
(princ object &optional stream)
function
Output an aesthetic but not necessarily READable printed representation
  of OBJECT on the specified STREAM.
(princ-to-string object)
function
Return the printed representation of OBJECT as a string with
  slashification off.
(print object &optional stream)
function
Output a newline, the mostly READable printed representation of OBJECT, and
  space to the specified STREAM.

PRINT-NOT-READABLE

PRINT-NOT-READABLE-OBJECT

PRINT-OBJECT

(print-unreadable-object (object stream &key type identity) &body forms)
macro
Output OBJECT to STREAM with "#<" prefix, ">" suffix, optionally
  with object-type prefix and object-identity suffix, and executing the
  code in BODY to provide possible further output.
(probe-file path)
function
Return a pathname which is the truename of the file if it exists, or NIL
  otherwise. An error of type FILE-ERROR is signaled if pathname is wild.

PROCLAIM

PROG

PROG*

PROG1

PROG2

PROGN

PROGRAM-ERROR

PROGV

(provide module)
function
Adds a new module name to *MODULES* indicating that it has been loaded.
   Module-name is a string designator
(psetf &rest pairs)
macro
This is to SETF as PSETQ is to SETQ. Args are alternating place
  expressions and values to go into those places. All of the subforms and
  values are determined, left to right, and only then are the locations
  updated. Returns NIL.
(psetq &body pairs)
macro
PSETQ {var value}*
   Set the variables to the values, like SETQ, except that assignments
   happen in parallel, i.e. no assignments take place until all the
   forms have been evaluated.
(push value place)
macro
Takes an object and a location holding a list. Conses the object onto
  the list, returning the modified list. OBJ is evaluated before PLACE.
(pushnew value place &rest keys)
macro
Takes an object and a location holding a list. If the object is
  already in the list, does nothing; otherwise, conses the object onto
  the list. Returns the modified list. If there is a :TEST keyword, this
  is used for the comparison.

QUOTE

RANDOM

RANDOM-STATE

RANDOM-STATE-P

(rassoc item alist &key test test-not key)
function
Return the cons in ALIST whose CDR is equal (by a given test or EQL) to
   the ITEM.
(rassoc-if predicate alist &key key)
function
Return the first cons in ALIST whose CDR satisfies PREDICATE. If KEY
  is supplied, apply it to the CDR of each cons before testing.
(rassoc-if-not predicate alist &key key)
function
Return the first cons in ALIST whose CDR does not satisfy PREDICATE.
  If KEY is supplied, apply it to the CDR of each cons before testing.

RATIO

(rational number)
function
RATIONAL produces a rational number for any real numeric argument. This is
  more efficient than RATIONALIZE, but it assumes that floating-point is
  completely accurate, giving a result that isn't as pretty.
(rationalize number)
function
Converts any REAL to a RATIONAL.  Floats are converted to a simple rational
  representation exploiting the assumption that floats are only accurate to
  their precision.  RATIONALIZE (and also RATIONAL) preserve the invariant:
      (= x (float (rationalize x) x))
(rationalp x)
function
Return true if OBJECT is a RATIONAL, and NIL otherwise.

READ

READ-BYTE

READ-CHAR

READ-CHAR-NO-HANG

(read-delimited-list char &optional stream recursive-p)
function
Read Lisp values from INPUT-STREAM until the next character after a
   value's representation is CHAR, and return the objects as a list.
(read-from-string string &optional eof-error-p eof-value &key start end preserve-whitespace)
function
The characters of string are successively given to the lisp reader
   and the lisp object built by the reader is returned. Macro chars
   will take effect.

READ-LINE

(read-preserving-whitespace &optional stream eof-error-p eof-value recursive-p)
function
Read from STREAM and return the value read, preserving any whitespace
   that followed the object.
(read-sequence seq stream &key start end)
function
Destructively modify SEQ by reading elements from STREAM.
  That part of SEQ bounded by START and END is destructively modified by
  copying successive elements into it from STREAM. If the end of file
  for STREAM is reached before copying all elements of the subsequence,
  then the extra elements near the end of sequence are not updated, and
  the index of the next element is returned.

READER-ERROR

READTABLE

READTABLE-CASE

READTABLEP

REAL

(realp x)
function
Return true if OBJECT is a REAL, and NIL otherwise.
(realpart number)
function
Extract the real part of a number.
(reduce function sequence &key from-end start end initial-value key)
function
The specified Sequence is ``reduced'' using the given Function.
  See manual for details.

REINITIALIZE-INSTANCE

(rem number divisor)
function
Returns second result of TRUNCATE.
(remf place indicator)
macro
Place may be any place expression acceptable to SETF, and is expected
  to hold a property list or (). This list is destructively altered to
  remove the property specified by the indicator. Returns T if such a
  property was present, NIL if not.
(remhash key hash)
function
Remove the entry in HASH-TABLE associated with KEY. Return T if there
   was such an entry, or NIL if not.
(remove item sequence &key from-end test test-not start end count key)
function
Return a copy of SEQUENCE with elements satisfying the test (default is
   EQL) with ITEM removed.
(remove-duplicates sequence &key test test-not start from-end end key)
function
The elements of SEQUENCE are compared pairwise, and if any two match,
   the one occurring earlier is discarded, unless FROM-END is true, in
   which case the one later in the sequence is discarded. The resulting
   sequence is returned.

   The :TEST-NOT argument is deprecated.
(remove-if test sequence &key from-end start end count key)
function
Return a copy of sequence with elements such that predicate(element)
   is non-null removed
(remove-if-not test sequence &key from-end start end count key)
function
Return a copy of sequence with elements such that predicate(element)
   is null removed

REMOVE-METHOD

(remprop symbol key)
function
Look on property list of SYMBOL for property with specified
  INDICATOR. If found, splice this indicator and its value out of
  the plist, and return the tail of the original list starting with
  INDICATOR. If not found, return () with no side effects.

  NOTE: The ANSI specification requires REMPROP to return true (not false)
  or false (the symbol NIL). Portable code should not rely on any other value.
(rename-file file new-name &key if-exists)
function
Rename FILE to have the specified NEW-NAME. If FILE is a stream open to a
  file, then the associated file is renamed.
(rename-package package new-name &optional new-nicknames)
function
Changes the name and nicknames for a package.
(replace target-sequence source-sequence &key start1 end1 start2 end2)
function
The target sequence is destructively modified by copying successive
   elements into it from the source sequence.
(require module &optional pathname)
function
Loads a module, unless it already has been loaded. PATHNAMES, if supplied,
   is a designator for a list of pathnames to be loaded if the module
   needs to be. If PATHNAMES is not supplied, functions from the list
   *MODULE-PROVIDER-FUNCTIONS* are called in order with MODULE-NAME
   as an argument, until one of them returns non-NIL.  User code is
   responsible for calling PROVIDE to indicate a successful load of the
   module.
(rest list)
function
Means the same as the cdr of a list.

RESTART

(restart-bind clauses &body body)
macro
Executes forms in a dynamic context where the given restart bindings are
   in effect. Users probably want to use RESTART-CASE. When clauses contain
   the same restart name, FIND-RESTART will find the first such clause.
(restart-case form &rest clauses)
macro
(RESTART-CASE form
   {(case-name arg-list {keyword value}* body)}*)
   The form is evaluated in a dynamic context where the clauses have special
   meanings as points to which control may be transferred (see INVOKE-RESTART).
   When clauses contain the same case-name, FIND-RESTART will find the first
   such clause. If Expression is a call to SIGNAL, ERROR, CERROR or WARN (or
   macroexpands into such) then the signalled condition will be associated with
   the new restarts.
(restart-name restart)
function
Return the name of the given restart object.

RETURN

RETURN-FROM

(revappend x y)
function
Return (append (reverse x) y).
(reverse seq)
function
Return a new sequence containing the same elements but in reverse order.
(room &optional verbose)
function
Print to *STANDARD-OUTPUT* information about the state of internal
  storage and its management. The optional argument controls the
  verbosity of output. If it is T, ROOM prints out a maximal amount of
  information. If it is NIL, ROOM prints out a minimal amount of
  information. If it is :DEFAULT or it is not supplied, ROOM prints out
  an intermediate amount of information.
(rotatef &rest args)
macro
Takes any number of SETF-style place expressions. Evaluates all of the
   expressions in turn, then assigns to each place the value of the form to
   its right. The rightmost form gets the value of the leftmost.
   Returns NIL.
(round number &optional divisor)
function
Rounds number (or number/divisor) to nearest integer.
  The second returned value is the remainder.
(row-major-aref array index)
function
Return the element of array corressponding to the row-major index. This is
   SETF'able.

RPLACA

RPLACD

(sbit v &optional sub0 &rest others)
function
Return the bit from SIMPLE-BIT-ARRAY at the specified SUBSCRIPTS.
(scale-float float int)
function
Return the value (* f (expt (float 2 f) ex)), but with no unnecessary loss
  of precision or overflow.
(schar s i)
function
SCHAR returns the character object at an indexed position in a string
   just as CHAR does, except the string must be a simple-string.

SEARCH

(second list)
function
Return the 2nd object in a list or NIL if there is no 2nd object.

SEQUENCE

SERIOUS-CONDITION

(set sym value)
function
Set SYMBOL's value cell to NEW-VALUE.
(set-difference list1 list2 &key key test test-not)
function
Return the elements of LIST1 which are not in LIST2.
(set-dispatch-macro-character disp-ch sub-ch fn &optional readtable)
function
Cause FUNCTION to be called whenever the reader reads DISP-CHAR
   followed by SUB-CHAR.
(set-exclusive-or list1 list2 &key key test test-not)
function
Return new list of elements appearing exactly once in LIST1 and LIST2.
(set-macro-character char fn &optional non-terminating-p readtable)
function
Causes CHAR to be a macro character which invokes FUNCTION when seen
   by the reader. The NON-TERMINATINGP flag can be used to make the macro
   character non-terminating, i.e. embeddable in a symbol name.

SET-PPRINT-DISPATCH

(set-syntax-from-char to-char from-char &optional to-readtable from-readtable)
function
Causes the syntax of TO-CHAR to be the same as FROM-CHAR in the
  optional readtable (defaults to the current readtable). The
  FROM-TABLE defaults to the standard Lisp readtable when NIL.
(setf &rest args)
macro
Takes pairs of arguments like SETQ. The first is a place and the second
  is the value that is supposed to go into that place. Returns the last
  value. The place argument may be any of the access forms for which SETF
  knows a corresponding setting form.

SETQ

(seventh list)
function
Return the 7th object in a list or NIL if there is no 7th object.
(shadow sym-or-symbols-or-string-or-strings &optional package)
function
Make an internal symbol in PACKAGE with the same name as each of
  the specified SYMBOLS. If a symbol with the given name is already
  present in PACKAGE, then the existing symbol is placed in the
  shadowing symbols list if it is not already present.
(shadowing-import sym-or-syms &optional package)
function
Import SYMBOLS into package, disregarding any name conflict. If
  a symbol of the same name is present, then it is uninterned.

SHARED-INITIALIZE

(shiftf arg1 arg2 &rest places-&-nuval)
macro
One or more SETF-style place expressions, followed by a single
   value expression. Evaluates all of the expressions in turn, then
   assigns the value of each expression to the place on its left,
   returning the value of the leftmost.

SHORT-FLOAT

SHORT-FLOAT-EPSILON

SHORT-FLOAT-NEGATIVE-EPSILON

(short-site-name)
function
Return a string with the abbreviated site name, or NIL if not known.
(signal condition &rest args)
function
Invokes the signal facility on a condition formed from DATUM and
   ARGUMENTS. If the condition is not handled, NIL is returned. If
   (TYPEP condition *BREAK-ON-SIGNALS*) is true, the debugger is invoked
   before any signalling is done.

SIGNED-BYTE

(signum x)
function
If NUMBER is zero, return NUMBER, else return (/ NUMBER (ABS NUMBER)).

SIMPLE-ARRAY

SIMPLE-BASE-STRING

SIMPLE-BIT-VECTOR

(simple-bit-vector-p form)
function
Return true if OBJECT is a SIMPLE-BIT-VECTOR, and NIL otherwise.

SIMPLE-CONDITION

SIMPLE-CONDITION-FORMAT-ARGUMENTS

SIMPLE-CONDITION-FORMAT-CONTROL

SIMPLE-ERROR

SIMPLE-STRING

(simple-string-p x)
function
Return true if OBJECT is a SIMPLE-STRING, and NIL otherwise.

SIMPLE-TYPE-ERROR

SIMPLE-VECTOR

(simple-vector-p x)
function
Return true if OBJECT is a SIMPLE-VECTOR, and NIL otherwise.

SIMPLE-WARNING

(sin x)
function
Return the sine of NUMBER.

SINGLE-FLOAT

SINGLE-FLOAT-EPSILON

SINGLE-FLOAT-NEGATIVE-EPSILON

(sinh x)
function
Return the hyperbolic sine of NUMBER.
(sixth list)
function
Return the 6th object in a list or NIL if there is no 6th object.
(sleep seconds)
function
This function causes execution to be suspended for N seconds. N may
  be any non-negative, non-complex number.

SLOT-BOUNDP

SLOT-EXISTS-P

SLOT-MAKUNBOUND

SLOT-MISSING

SLOT-UNBOUND

SLOT-VALUE

(software-type)
function
Return a string describing the supporting software.
(software-version)
function
Return a string describing version of the supporting software, or NIL
   if not available.
(some predicate one-seq &rest sequences)
function
Apply PREDICATE to the 0-indexed elements of the sequences, then 
   possibly to those with index 1, and so on. Return the first 
   non-NIL value encountered, or NIL if the end of any sequence is reached.
(sort sequence predicate &key key)
function
Returns SEQUENCE, which has been modified to be in order.
   If sequence is a displaced array, sorts just that portion of the
   data-array which is part of SEQUENCE.
(special-operator-p symbol)
function
If the symbol globally names a special form, return T, otherwise NIL.
(sqrt x)
function
Return the square root of NUMBER.
(stable-sort sequence predicate &key key)
function
Returns SEQUENCE, which has been modified to be in order.
   If sequence is a displaced array, sorts just that portion of the
   data-array which is part of SEQUENCE.

STANDARD-CHAR

(standard-char-p c)
function
The argument must be a character object. STANDARD-CHAR-P returns T if the
   argument is a standard character -- one of the 95 ASCII printing characters
   or <return>.

STANDARD-CLASS

STANDARD-GENERIC-FUNCTION

STANDARD-METHOD

STANDARD-OBJECT

STEP

(step-break-entry &rest fnames)
macro
DO:             Enable breaking on entry of functions named by FNAMES.

FNAMES:         A list of function names.

NOTE:           The functions must have been compiled with the operators from
                the CL-STEPPER package not the CL package.

RETURN:         The list of function names added.
(step-break-exit &rest fnames)
macro
DO:             Enable breaking on exit of functions named by FNAMES.

FNAMES:         A list of function names.

NOTE:           The functions must have been compiled with the operators from
                the CL-STEPPER package not the CL package.

RETURN:         The list of function names added.
(step-trace-function &rest fnames)
macro
DO:             Enable tracing of functions named by FNAMES.

FNAMES:         A list of function names.

NOTE:           The functions must have been compiled with the operators from
                the CL-STEPPER package not the CL package.

RETURN:         The list of function names added.
(step-unbreak-entry &rest fnames)
macro
DO:             Disable breaking on entry of functions named by FNAMES.

FNAMES:         A list of function names.

NOTE:           The functions must have been compiled with the operators from
                the CL-STEPPER package not the CL package.

RETURN:         The list of step-break-entry functions remaining.
(step-unbreak-exit &rest fnames)
macro
DO:             Disable breaking on exit of functions named by FNAMES.

FNAMES:         A list of function names.

NOTE:           The functions must have been compiled with the operators from
                the CL-STEPPER package not the CL package.

RETURN:         The list of step-break-entry functions remaining.
(step-untrace-function &rest fnames)
macro
DO:             Disable tracing of functions named by FNAMES.

FNAMES:         A list of function names.

NOTE:           The functions must have been compiled with the operators from
                the CL-STEPPER package not the CL package.

RETURN:         The list of step-traced functions remaining.

STORAGE-CONDITION

(store-value value &optional condition)
function
Transfer control and VALUE to a restart named STORE-VALUE, or return NIL if
   none exists.

STREAM

STREAM-ELEMENT-TYPE

STREAM-ERROR

STREAM-ERROR-STREAM

STREAM-EXTERNAL-FORMAT

STREAMP

(string thing)
function
Coerces X into a string. If X is a string, X is returned. If X is a
   symbol, X's pname is returned. If X is a character then a one element
   string containing that character is returned. If X cannot be coerced
   into a string, an error occurs.

STRING-CAPITALIZE

STRING-DOWNCASE

(string-equal string1 string2 &key start1 end1 start2 end2)
function
Given two strings (string1 and string2), and optional integers start1,
  start2, end1 and end2, compares characters in string1 to characters in
  string2 (using char-equal).
(string-greaterp string1 string2 &key start1 end1 start2 end2)
function
Given two strings, if the first string is lexicographically greater than
  the second string, returns the longest common prefix (using char-equal)
  of the two strings. Otherwise, returns ().
(string-left-trim char-bag string)
function
Given a set of characters (a list or string) and a string, returns
  a copy of the string with the characters in the set removed from the
  left end.
(string-lessp string1 string2 &key start1 end1 start2 end2)
function
Given two strings, if the first string is lexicographically less than
  the second string, returns the longest common prefix (using char-equal)
  of the two strings. Otherwise, returns ().
(string-not-equal string1 string2 &key start1 end1 start2 end2)
function
Given two strings, if the first string is not lexicographically equal
  to the second string, returns the longest common prefix (using char-equal)
  of the two strings. Otherwise, returns ().
(string-not-greaterp string1 string2 &key start1 end1 start2 end2)
function
Given two strings, if the first string is lexicographically less than
  or equal to the second string, returns the longest common prefix
  (using char-equal) of the two strings. Otherwise, returns ().
(string-not-lessp string1 string2 &key start1 end1 start2 end2)
function
Given two strings, if the first string is lexicographically greater
  than or equal to the second string, returns the longest common prefix
  (using char-equal) of the two strings. Otherwise, returns ().
(string-right-trim char-bag string)
function
Given a set of characters (a list or string) and a string, returns
  a copy of the string with the characters in the set removed from the
  right end.

STRING-STREAM

(string-trim char-bag string)
function
Given a set of characters (a list or string) and a string, returns a
  copy of the string with the characters in the set removed from both
  ends.

STRING-UPCASE

(string/= string1 string2 &key start1 end1 start2 end2)
function
Given two strings, if the first string is not lexicographically equal
  to the second string, returns the longest common prefix (using char=)
  of the two strings. Otherwise, returns ().
(string< string1 string2 &key start1 end1 start2 end2)
function
Given two strings, if the first string is lexicographically less than
  the second string, returns the longest common prefix (using char=)
  of the two strings. Otherwise, returns ().
(string<= string1 string2 &key start1 end1 start2 end2)
function
Given two strings, if the first string is lexicographically less than
  or equal to the second string, returns the longest common prefix
  (using char=) of the two strings. Otherwise, returns ().
(string= string1 string2 &key start1 end1 start2 end2)
function
Given two strings (string1 and string2), and optional integers start1,
  start2, end1 and end2, compares characters in string1 to characters in
  string2 (using char=).
(string> string1 string2 &key start1 end1 start2 end2)
function
Given two strings, if the first string is lexicographically greater than
  the second string, returns the longest common prefix (using char=)
  of the two strings. Otherwise, returns ().
(string>= string1 string2 &key start1 end1 start2 end2)
function
Given two strings, if the first string is lexicographically greater
  than or equal to the second string, returns the longest common prefix
  (using char=) of the two strings. Otherwise, returns ().
(stringp x)
function
Return true if OBJECT is a STRING, and NIL otherwise.

STRUCTURE-CLASS

STRUCTURE-OBJECT

STYLE-WARNING

(sublis alist tree &key key test test-not)
function
Substitute from ALIST into TREE nondestructively.
(subseq sequence start &optional end)
function
Return a copy of a subsequence of SEQUENCE starting with element number
   START and continuing to the end of SEQUENCE or the optional END.
(subsetp list1 list2 &key key test test-not)
function
Return T if every element in LIST1 is also in LIST2.
(subst new old tree &key key test test-not)
function
Substitutes new for subtrees matching old.
(subst-if new test tree &key key)
function
Substitutes new for subtrees for which test is true.
(subst-if-not new test tree &key key)
function
Substitutes new for subtrees for which test is false.
(substitute new old sequence &key from-end test test-not start count end key)
function
Return a sequence of the same kind as SEQUENCE with the same elements,
  except that all elements equal to OLD are replaced with NEW. See manual
  for details.
(substitute-if new test sequence &key from-end start end count key)
function
Return a sequence of the same kind as SEQUENCE with the same elements
  except that all elements satisfying the PRED are replaced with NEW. See
  manual for details.
(substitute-if-not new test sequence &key from-end start end count key)
function
Return a sequence of the same kind as SEQUENCE with the same elements
  except that all elements not satisfying the PRED are replaced with NEW.
  See manual for details.
(subtypep type1 type2 &optional env)
function
Return two values indicating the relationship between type1 and type2.
  If values are T and T, type1 definitely is a subtype of type2.
  If values are NIL and T, type1 definitely is not a subtype of type2.
  If values are NIL and NIL, it couldn't be determined.

SVREF

(sxhash s-expr)
function
Computes a hash code for S-EXPR and returns it as an integer.

SYMBOL

(symbol-function name)
function
Return the definition of NAME, even if it is a macro or a special form.
   Error if NAME doesn't have a definition.

SYMBOL-MACROLET

(symbol-name sym)
function
Return SYMBOL's name as a string.
(symbol-package sym)
function
Return the package SYMBOL was interned in, or NIL if none.
(symbol-plist sym)
function
Return SYMBOL's property list.
(symbol-value sym)
function
Return SYMBOL's current bound value.
(symbolp thing)
function
Return true if OBJECT is a SYMBOL, and NIL otherwise.

SYNONYM-STREAM

SYNONYM-STREAM-SYMBOL

T

TAGBODY

(tailp sublist list)
function
Return true if OBJECT is the same as some tail of LIST, otherwise
   returns false. LIST must be a proper list or a dotted list.
(tan x)
function
Return the tangent of NUMBER.
(tanh x)
function
Return the hyperbolic tangent of NUMBER.
(tenth list)
function
Return the 10th object in a list or NIL if there is no 10th object.

TERPRI

THE

(third list)
function
Return the 3rd object in a list or NIL if there is no 3rd object.

THROW

(time form)
macro
Execute FORM and print timing information on *TRACE-OUTPUT*.
(trace &rest syms)
macro
TRACE {Option Global-Value}* { Name | (Name {Option Value}*) }*

TRACE is a debugging tool that provides information when specified
functions are called.
(translate-logical-pathname pathname &key)
function
Translate PATHNAME to a physical pathname, which is returned.
(translate-pathname source from-wildname to-wildname &key reversible)
function
Use the source pathname to translate the from-wildname's wild and
   unspecified elements into a completed to-pathname based on the to-wildname.
(tree-equal x y &key test test-not)
function
Returns T if X and Y are isomorphic trees with identical leaves.
(truename path)
function
Return the pathname for the actual file described by PATHNAME.
  An error of type FILE-ERROR is signalled if no such file exists,
  or the pathname is wild.

  Under Unix, the TRUENAME of a broken symlink is considered to be
  the name of the broken symlink itself.
(truncate number &optional divisor)
function
Returns number (or number/divisor) as an integer, rounded toward 0.
  The second returned value is the remainder.

TWO-WAY-STREAM

TWO-WAY-STREAM-INPUT-STREAM

TWO-WAY-STREAM-OUTPUT-STREAM

TYPE-ERROR

TYPE-ERROR-DATUM

TYPE-ERROR-EXPECTED-TYPE

(type-of form)
function
Return the type of OBJECT.
(typecase keyform &body clauses)
macro
TYPECASE Keyform {(Type Form*)}*
  Evaluates the Forms in the first clause for which TYPEP of Keyform and Type
  is true.
(typep object type &optional env)
function
Is OBJECT of type TYPE?

UNBOUND-SLOT

UNBOUND-SLOT-INSTANCE

UNBOUND-VARIABLE

UNDEFINED-FUNCTION

(unexport sym-or-symbols &optional package)
function
Makes SYMBOLS no longer exported from PACKAGE.
(unintern symbol &optional package)
function
Makes SYMBOL no longer present in PACKAGE. If SYMBOL was present
  then T is returned, otherwise NIL. If PACKAGE is SYMBOL's home
  package, then it is made uninterned.
(union list1 list2 &key key test test-not)
function
Returns the union of LIST1 and LIST2.
(unless test &body body)
macro
If the first argument is not true, the rest of the forms are
  evaluated as a PROGN.

UNREAD-CHAR

UNSIGNED-BYTE

(untrace &rest syms)
macro
Remove tracing from the specified functions. With no args, untrace all
   functions.
(unuse-package packages-to-unuse &optional package)
function
Remove PACKAGES-TO-UNUSE from the USE list for PACKAGE.

UNWIND-PROTECT

UPDATE-INSTANCE-FOR-DIFFERENT-CLASS

UPDATE-INSTANCE-FOR-REDEFINED-CLASS

(upgraded-array-element-type type &optional env)
function
Return the element type that will actually be used to implement an array
   with the specifier :ELEMENT-TYPE Spec.

UPGRADED-COMPLEX-PART-TYPE

(upper-case-p c)
function
The argument must be a character object; UPPER-CASE-P returns T if the
   argument is an upper-case character, NIL otherwise.
(use-package packages-to-use &optional package)
function
Add all the PACKAGES-TO-USE to the use list for PACKAGE so that
  the external symbols of the used packages are accessible as internal
  symbols in PACKAGE.
(use-value value &optional condition)
function
Transfer control and VALUE to a restart named USE-VALUE, or return NIL if
   none exists.
(user-homedir-pathname &optional host)
function
Return the home directory of the user as a pathname.

VALUES

(values-list arg)
function
Return all of the elements of LIST, in order, as values.
(vector &lexpr vals)
function
Construct a SIMPLE-VECTOR from the given objects.
(vector-pop vector)
function
Decrease the fill pointer by 1 and return the element pointed to by the
  new fill pointer.
(vector-push elt vector)
function
Attempt to set the element of ARRAY designated by its fill pointer
   to NEW-EL, and increment the fill pointer by one. If the fill pointer is
   too large, NIL is returned, otherwise the index of the pushed element is
   returned.
(vector-push-extend elt vector &optional extension)
function
Attempt to set the element of VECTOR designated by its fill pointer
to ELT, and increment the fill pointer by one. If the fill pointer is
too large, VECTOR is extended using adjust-array.  EXTENSION is the
minimum number of elements to add if it must be extended.
(vectorp x)
function
Return true if OBJECT is a VECTOR, and NIL otherwise.
(warn condition-or-format-string &rest args)
function
Warn about a situation by signalling a condition formed by DATUM and
   ARGUMENTS. While the condition is being signaled, a MUFFLE-WARNING restart
   exists that causes WARN to immediately return NIL.

WARNING

(when test &body body)
macro
If the first argument is true, the rest of the forms are
  evaluated as a PROGN.
(wild-pathname-p pathname &optional field-key)
function
Predicate for determining whether pathname contains any wildcards.
(with-accessors slot-entries instance-form &body body)
macro
Create a lexical environment in which the slots specified by slot-entry
are lexically available through their accessors as if they were variables.
The appropriate accessors are invoked to access the slots specified by
slot-entry. Both setf and setq can be used to set the value of the slot.
(with-compilation-unit (&key override) &body body)
macro
WITH-COMPILATION-UNIT ({Key Value}*) Form*
  This form affects compilations that take place within its dynamic extent. It
  is intended to be wrapped around the compilation of all files in the same
  system. These keywords are defined:
    :OVERRIDE Boolean-Form
        One of the effects of this form is to delay undefined warnings
        until the end of the form, instead of giving them at the end of each
        compilation. If OVERRIDE is NIL (the default), then the outermost
        WITH-COMPILATION-UNIT form grabs the undefined warnings. Specifying
        OVERRIDE true causes that form to grab any enclosed warnings, even if
        it is enclosed by another WITH-COMPILATION-UNIT.
(with-condition-restarts condition restarts &body body)
macro
Evaluates the BODY in a dynamic environment where the restarts in the list
   RESTARTS-FORM are associated with the condition returned by CONDITION-FORM.
   This allows FIND-RESTART, etc., to recognize restarts that are not related
   to the error currently being debugged. See also RESTART-CASE.
(with-hash-table-iterator (mname hash-table) &body body)
macro
WITH-HASH-TABLE-ITERATOR ((function hash-table) &body body)
   provides a method of manually looping over the elements of a hash-table.
   FUNCTION is bound to a generator-macro that, within the scope of the
   invocation, returns one or three values. The first value tells whether
   any objects remain in the hash table. When the first value is non-NIL,
   the second and third values are the key and the value of the next object.
(with-input-from-string (var string &key index start end) &body forms)
macro
Create an input string stream, provide an opportunity to perform
operations on the stream (returning zero or more values), and then close
the string stream.

STRING is evaluated first, and VAR is bound to a character input string
stream that supplies characters from the subsequence of the resulting
string bounded by start and end. BODY is executed as an implicit progn.
(with-open-file (var filename . args) &body body)
macro
Use open to create a file stream to file named by filename. Filename is
the name of the file to be opened. Options are used as keyword arguments
to open.
(with-open-stream (var stream) &body body)
macro
Perform a series of operations on stream, return a value, and then
close the stream.  VAR is bound to the value of STREAM, and then BODY is
executed as an implicit progn. STREAM is automatically closed on exit
from with-open-stream, no matter whether the exit is normal or abnormal.
The stream has dynamic extent; its extent ends when the form is exited.
(with-output-to-string (var &optional string &key (element-type (quote base-char) element-type-p)) &body body)
macro
Create a character output stream, perform a series of operations that
may send results to this stream, and then close the stream.  BODY is
executed as an implicit progn with VAR bound to an output string stream.
All output to that string stream is saved in a string.
(with-package-iterator (mname package-list first-type &rest other-types) &body body)
macro
Within the lexical scope of the body forms, MNAME is defined via macrolet
   such that successive invocations of (MNAME) will return the symbols,
   one by one, from the packages in PACKAGE-LIST. SYMBOL-TYPES may be
   any of :INHERITED :EXTERNAL :INTERNAL.
(with-simple-restart (restart-name format-string &rest format-args) &body body)
macro
(WITH-SIMPLE-RESTART (restart-name format-string format-arguments)
   body)
   If restart-name is not invoked, then all values returned by forms are
   returned. If control is transferred to this restart, it immediately
   returns the values NIL and T.
(with-slots slot-entries instance-form &body body)
macro
Establish a lexical environment for referring to the slots in the
instance named by the given slot-names as though they were variables.
Within such a context the value of the slot can be specified by using
its slot name, as if it were a lexically bound variable. Both setf and
setq can be used to set the value of the slot.
(with-standard-io-syntax &body body)
macro
Bind the reader and printer control variables to values that enable READ
   to reliably read the results of PRINT. These values are:
       *PACKAGE*                        the COMMON-LISP-USER package
       *PRINT-ARRAY*                    T
       *PRINT-BASE*                     10
       *PRINT-CASE*                     :UPCASE
       *PRINT-CIRCLE*                   NIL
       *PRINT-ESCAPE*                   T
       *PRINT-GENSYM*                   T
       *PRINT-LENGTH*                   NIL
       *PRINT-LEVEL*                    NIL
       *PRINT-LINES*                    NIL
       *PRINT-MISER-WIDTH*              NIL
       *PRINT-PRETTY*                   NIL
       *PRINT-RADIX*                    NIL
       *PRINT-READABLY*                 T
       *PRINT-RIGHT-MARGIN*             NIL
       *READ-BASE*                      10
       *READ-DEFAULT-FLOAT-FORMAT*      SINGLE-FLOAT
       *READ-EVAL*                      T
       *READ-SUPPRESS*                  NIL
       *READTABLE*                      the standard readtable
(write object &key stream escape radix base circle pretty level length case gensym array readably right-margin miser-width lines pprint-dispatch structure simple-vector simple-bit-vector string-length)
function
Output OBJECT to the specified stream, defaulting to *STANDARD-OUTPUT*
(write-byte byte stream)
function
Write one byte, BYTE, to STREAM.
(write-char char &optional output-stream)
function
Output CHAR to OUTPUT-STREAM.
(write-line string &optional output-stream &key start end)
function
Write the characters of the subsequence of STRING bounded by START
and END to OUTPUT-STREAM then output a #Newline at end.
(write-sequence seq stream &key start end)
function
Write the elements of SEQ bounded by START and END to STREAM.
(write-string string &optional output-stream &key start end)
function
Write the characters of the subsequence of STRING bounded by START
and END to OUTPUT-STREAM.
(write-to-string object &key escape radix base circle pretty level length case gensym array readably right-margin miser-width lines pprint-dispatch structure simple-vector simple-bit-vector string-length)
function
Return the printed representation of OBJECT as a string.
(y-or-n-p &optional format-string &rest arguments)
function
Y-OR-N-P prints the message, if any, and reads characters from
   *QUERY-IO* until the user enters y or Y as an affirmative, or either
   n or N as a negative answer. It asks again if you enter any other
   characters.
(yes-or-no-p &optional format-string &rest arguments)
function
YES-OR-NO-P is similar to Y-OR-N-P, except that it clears the
   input buffer, beeps, and uses READ-LINE to get the strings
   YES or NO.
(zerop number)
function
Is this number zero?