Common Lisp Package: IOLIB.BASE

README:

FUNCTION

Public

* (&REST NUMBERS)

Return the product of its arguments. With no args, returns 1.

+ (&REST NUMBERS)

Return the sum of its arguments. With no args, returns 0.

- (NUMBER &REST MORE-NUMBERS)

Subtract the second and all subsequent arguments from the first; or with one argument, negate the first argument.

/ (NUMBER &REST MORE-NUMBERS)

Divide the first argument by each of the following arguments, in turn. With one argument, return reciprocal.

/= (NUMBER &REST MORE-NUMBERS)

Return T if no two of its arguments are numerically equal, NIL otherwise.

1+ (NUMBER)

Return NUMBER + 1.

1- (NUMBER)

Return NUMBER - 1.

< (NUMBER &REST MORE-NUMBERS)

Return T if its arguments are in strictly increasing order, NIL otherwise.

<= (NUMBER &REST MORE-NUMBERS)

Return T if arguments are in strictly non-decreasing order, NIL otherwise.

= (NUMBER &REST MORE-NUMBERS)

Return T if all of its arguments are numerically equal, NIL otherwise.

> (NUMBER &REST MORE-NUMBERS)

Return T if its arguments are in strictly decreasing order, NIL otherwise.

>= (NUMBER &REST MORE-NUMBERS)

Return T if arguments are in strictly non-increasing order, NIL otherwise.

ABORT (&OPTIONAL CONDITION)

Transfer control to a restart named ABORT, signalling a CONTROL-ERROR if none exists.

ABS (NUMBER)

Return the absolute value of the number.

ACONS (KEY DATUM ALIST)

Construct a new alist by adding the pair (KEY . DATUM) to ALIST.

ACOS (NUMBER)

Return the arc cosine of NUMBER.

ACOSH (NUMBER)

Return the hyperbolic arc cosine of NUMBER.

ADJOIN (ITEM LIST &KEY KEY (TEST #'EQL TESTP) (TEST-NOT NIL NOTP))

Add ITEM to LIST unless it is already a member

ADJUST-ARRAY (ARRAY DIMENSIONS &KEY (ELEMENT-TYPE (ARRAY-ELEMENT-TYPE ARRAY)) (INITIAL-ELEMENT NIL INITIAL-ELEMENT-P) (INITIAL-CONTENTS NIL INITIAL-CONTENTS-P) FILL-POINTER DISPLACED-TO DISPLACED-INDEX-OFFSET)

Adjust ARRAY's dimensions to the given DIMENSIONS and stuff.

ADJUSTABLE-ARRAY-P (ARRAY)

Return T if (ADJUST-ARRAY ARRAY...) would return an array identical to the argument, this happens for complex arrays.

ALIST-HASH-TABLE (ALIST &REST HASH-TABLE-INITARGS)

Returns a hash table containing the keys and values of the association list ALIST. Hash table is initialized using the HASH-TABLE-INITARGS.

ALIST-PLIST (ALIST)

Returns a property list containing the same keys and values as the association list ALIST in the same order.

ALPHA-CHAR-P (CHAR)

The argument must be a character object. ALPHA-CHAR-P returns T if the argument is an alphabetic character, A-Z or a-z; otherwise NIL.

ALPHANUMERICP (CHAR)

Given a character-object argument, ALPHANUMERICP returns T if the argument is either numeric or alphabetic.

APPEND (&REST LISTS)

Construct a new list by concatenating the list arguments

APPLY (FUNCTION ARG &REST ARGUMENTS)

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 (STRING-DESIGNATOR &OPTIONAL PACKAGE EXTERNAL-ONLY)

Briefly describe all symbols which contain the specified STRING. If PACKAGE is supplied then only describe symbols present in that package. If EXTERNAL-ONLY then only describe external symbols in the specified package.

APROPOS-LIST (STRING-DESIGNATOR &OPTIONAL PACKAGE-DESIGNATOR EXTERNAL-ONLY)

Like APROPOS, except that it returns a list of the symbols found instead of describing them.

AREF (ARRAY &REST SUBSCRIPTS)

Return the element of the ARRAY specified by the SUBSCRIPTS.

ARITHMETIC-ERROR-OPERANDS (CONDITION)

Return the offending thread that the THREAD-ERROR pertains to.

ARITHMETIC-ERROR-OPERATION (CONDITION)

Return the offending thread that the THREAD-ERROR pertains to.

ARRAY-DIMENSION (ARRAY AXIS-NUMBER)

Return the length of dimension AXIS-NUMBER of ARRAY.

ARRAY-DIMENSIONS (ARRAY)

Return a list whose elements are the dimensions of the array

ARRAY-DISPLACEMENT (ARRAY)

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)

Return the type of the elements of the array

ARRAY-HAS-FILL-POINTER-P (ARRAY)

Return T if the given ARRAY has a fill pointer, or NIL otherwise.

ARRAY-IN-BOUNDS-P (ARRAY &REST SUBSCRIPTS)

Return T if the SUBSCRIPTS are in bounds for the ARRAY, NIL otherwise.

ARRAY-RANK (ARRAY)

Return the number of dimensions of ARRAY.

ARRAY-TOTAL-SIZE (ARRAY)

Return the total number of elements in the Array.

ARRAYP (OBJECT)

Return true if OBJECT is an ARRAY, and NIL otherwise.

ASH (INTEGER COUNT)

Shifts integer left by count places preserving sign. - count shifts right.

ASIN (NUMBER)

Return the arc sine of NUMBER.

ASINH (NUMBER)

Return the hyperbolic arc sine of NUMBER.

ASSOC (ITEM ALIST &KEY KEY (TEST NIL TESTP) (TEST-NOT NIL NOTP))

Return the cons in ALIST whose car is equal (by a given test or EQL) to the ITEM.

ASSOC-IF (PREDICATE ALIST &KEY KEY)

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)

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.

ASSOC-VALUE (ALIST KEY &KEY (TEST 'EQL))

ASSOC-VALUE is an alist accessor very much like ASSOC, but it can be used with SETF.

ATAN (Y &OPTIONAL (X NIL XP))

Return the arc tangent of Y if X is omitted or Y/X if X is supplied.

ATANH (NUMBER)

Return the hyperbolic arc tangent of NUMBER.

ATOM (OBJECT)

Return true if OBJECT is an ATOM, and NIL otherwise.

BINOMIAL-COEFFICIENT (N K)

Binomial coefficient of N and K, also expressed as N choose K. This is the number of K element combinations given N choises. N must be equal to or greater then K.

BIT (BIT-ARRAY &REST SUBSCRIPTS)

Return the bit from the BIT-ARRAY at the specified SUBSCRIPTS.

BIT-AND (BIT-ARRAY-1 BIT-ARRAY-2 &OPTIONAL RESULT-BIT-ARRAY)

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-ARRAY-1 BIT-ARRAY-2 &OPTIONAL RESULT-BIT-ARRAY)

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-ARRAY-1 BIT-ARRAY-2 &OPTIONAL RESULT-BIT-ARRAY)

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-ARRAY-1 BIT-ARRAY-2 &OPTIONAL RESULT-BIT-ARRAY)

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-ARRAY-1 BIT-ARRAY-2 &OPTIONAL RESULT-BIT-ARRAY)

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-ARRAY-1 BIT-ARRAY-2 &OPTIONAL RESULT-BIT-ARRAY)

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-ARRAY-1 BIT-ARRAY-2 &OPTIONAL RESULT-BIT-ARRAY)

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)

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-ARRAY-1 BIT-ARRAY-2 &OPTIONAL RESULT-BIT-ARRAY)

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-ARRAY-1 BIT-ARRAY-2 &OPTIONAL RESULT-BIT-ARRAY)

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-P (OBJECT)

Return true if OBJECT is a BIT-VECTOR, and NIL otherwise.

BIT-XOR (BIT-ARRAY-1 BIT-ARRAY-2 &OPTIONAL RESULT-BIT-ARRAY)

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 (NAME &REST FORMS)

BLOCK name form* Evaluate the FORMS as a PROGN. Within the lexical scope of the body, RETURN-FROM can be used to exit the form.

BOOLE (OP INTEGER1 INTEGER2)

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

BOTH-CASE-P (CHAR)

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 (SYMBOL)

Return non-NIL if SYMBOL is bound to a value.

BREAK (&OPTIONAL (DATUM break) &REST ARGUMENTS)

Print a message and invoke the debugger without allowing any possibility of condition handling occurring.

BROADCAST-STREAM-STREAMS (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

BYTE (SIZE POSITION)

Return a byte specifier which may be used by other byte functions (e.g. LDB).

BYTE-POSITION (BYTESPEC)

Return the position part of the byte specifier bytespec.

BYTE-SIZE (BYTESPEC)

Return the size part of the byte specifier bytespec.

CAAAAR (LIST)

Return the car of the caaar of a list.

CAAADR (LIST)

Return the car of the caadr of a list.

CAAAR (LIST)

Return the 1st object in the caar of a list.

CAADAR (LIST)

Return the car of the cadar of a list.

CAADDR (LIST)

Return the car of the caddr of a list.

CAADR (LIST)

Return the 1st object in the cadr of a list.

CAAR (LIST)

Return the car of the 1st sublist.

CADAAR (LIST)

Return the car of the cdaar of a list.

CADADR (LIST)

Return the car of the cdadr of a list.

CADAR (LIST)

Return the car of the cdar of a list.

CADDAR (LIST)

Return the car of the cddar of a list.

CADDDR (LIST)

Return the car of the cdddr of a list.

CADDR (LIST)

Return the 1st object in the cddr of a list.

CADR (LIST)

Return the 2nd object in a list.

CAR (LIST)

Return the 1st object in a list.

CATCH (TAG &BODY BODY)

CATCH tag form* Evaluate TAG and instantiate it as a catcher while the body forms are evaluated in an implicit PROGN. If a THROW is done to TAG within the dynamic scope of the body, then control will be transferred to the end of the body and the thrown values will be returned.

CDAAAR (LIST)

Return the cdr of the caaar of a list.

CDAADR (LIST)

Return the cdr of the caadr of a list.

CDAAR (LIST)

Return the cdr of the caar of a list.

CDADAR (LIST)

Return the cdr of the cadar of a list.

CDADDR (LIST)

Return the cdr of the caddr of a list.

CDADR (LIST)

Return the cdr of the cadr of a list.

CDAR (LIST)

Return the cdr of the 1st sublist.

CDDAAR (LIST)

Return the cdr of the cdaar of a list.

CDDADR (LIST)

Return the cdr of the cdadr of a list.

CDDAR (LIST)

Return the cdr of the cdar of a list.

CDDDAR (LIST)

Return the cdr of the cddar of a list.

CDDDDR (LIST)

Return the cdr of the cdddr of a list.

CDDDR (LIST)

Return the cdr of the cddr of a list.

CDDR (LIST)

Return all but the 1st two objects of a list.

CDR (LIST)

Return all but the first object in a list.

CEILING (NUMBER &OPTIONAL (DIVISOR 1))

Return the smallest integer not less than number, or number/divisor. The second returned value is the remainder.

CELL-ERROR-NAME (CONDITION)

Return the offending thread that the THREAD-ERROR pertains to.

CHAR (STRING INDEX)

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)

Return the integer code of CHAR.

CHAR-DOWNCASE (CHAR)

Return CHAR converted to lower-case if that is possible.

CHAR-EQUAL (CHARACTER &REST MORE-CHARACTERS)

Return T if all of the arguments are the same character. Case is ignored.

CHAR-GREATERP (CHARACTER &REST MORE-CHARACTERS)

Return T if the arguments are in strictly decreasing alphabetic order. Case is ignored.

CHAR-INT (CHAR)

Return the integer code of CHAR. (In SBCL this is the same as CHAR-CODE, as there are no character bits or fonts.)

CHAR-LESSP (CHARACTER &REST MORE-CHARACTERS)

Return T if the arguments are in strictly increasing alphabetic order. Case is ignored.

CHAR-NAME (CHAR)

Return the name (a STRING) for a CHARACTER object.

CHAR-NOT-EQUAL (CHARACTER &REST MORE-CHARACTERS)

Return T if no two of the arguments are the same character. Case is ignored.

CHAR-NOT-GREATERP (CHARACTER &REST MORE-CHARACTERS)

Return T if the arguments are in strictly non-decreasing alphabetic order. Case is ignored.

CHAR-NOT-LESSP (CHARACTER &REST MORE-CHARACTERS)

Return T if the arguments are in strictly non-increasing alphabetic order. Case is ignored.

CHAR-UPCASE (CHAR)

Return CHAR converted to upper-case if that is possible. Don't convert lowercase eszet (U+DF).

CHAR/= (CHARACTER &REST MORE-CHARACTERS)

Return T if no two of the arguments are the same character.

CHAR< (CHARACTER &REST MORE-CHARACTERS)

Return T if the arguments are in strictly increasing alphabetic order.

CHAR<= (CHARACTER &REST MORE-CHARACTERS)

Return T if the arguments are in strictly non-decreasing alphabetic order.

CHAR= (CHARACTER &REST MORE-CHARACTERS)

Return T if all of the arguments are the same character.

CHAR> (CHARACTER &REST MORE-CHARACTERS)

Return T if the arguments are in strictly decreasing alphabetic order.

CHAR>= (CHARACTER &REST MORE-CHARACTERS)

Return T if the arguments are in strictly non-increasing alphabetic order.

CHARACTER (OBJECT)

Coerce OBJECT into a CHARACTER if possible. Legal inputs are characters, strings and symbols of length 1.

CHARACTERP (OBJECT)

Return true if OBJECT is a CHARACTER, and NIL otherwise.

CIRCULAR-LIST (&REST ELEMENTS)

Creates a circular list of ELEMENTS.

CIRCULAR-LIST-P (OBJECT)

Returns true if OBJECT is a circular list, NIL otherwise.

CIRCULAR-TREE-P (OBJECT)

Returns true if OBJECT is a circular tree, NIL otherwise.

CIS (THETA)

Return cos(Theta) + i sin(Theta), i.e. exp(i Theta).

CLAMP (NUMBER MIN MAX)

Clamps the NUMBER into [min, max] range. Returns MIN if NUMBER is lesser then MIN and MAX if NUMBER is greater then MAX, otherwise returns NUMBER.

CLRHASH (HASH-TABLE)

This removes all the entries from HASH-TABLE and returns the hash table itself.

CODE-CHAR (CODE)

Return the character with the code CODE.

COERCE (OBJECT OUTPUT-TYPE-SPEC)

Coerce the Object to an object of type Output-Type-Spec.

COMPILE (NAME &OPTIONAL (DEFINITION (OR (MACRO-FUNCTION NAME) (FDEFINITION NAME))))

Produce a compiled function from DEFINITION. If DEFINITION is a lambda-expression, it is coerced to a function. If DEFINITION is an interpreted function, it is compiled. If DEFINITION is already a compiled function, it is used as-is. (Future versions of SBCL might try to recompile the existing definition, but this is not currently supported.) If NAME is NIL, the compiled function is returned as the primary value. Otherwise the resulting compiled function replaces existing function definition of NAME, and NAME is returned as primary value; if NAME is a symbol tha names a macro, its macro function is replaced and NAME is returned as primary value. Also returns secondary value which is true if any conditions of type WARNING occur during the compilation, and NIL otherwise. Tertiary value is true if any conditions of type ERROR, or WARNING that are not STYLE-WARNINGs occur during compilation, and NIL otherwise.

COMPILE-FILE (INPUT-FILE &KEY (OUTPUT-FILE (CFP-OUTPUT-FILE-DEFAULT INPUT-FILE)) ((VERBOSE *COMPILE-VERBOSE*) *COMPILE-VERBOSE*) ((PRINT *COMPILE-PRINT*) *COMPILE-PRINT*) (EXTERNAL-FORMAT DEFAULT) (TRACE-FILE NIL) ((BLOCK-COMPILE *BLOCK-COMPILE-ARG*) NIL) (EMIT-CFASL *EMIT-CFASL*))

Compile INPUT-FILE, producing a corresponding fasl file and returning its filename. :PRINT If true, a message per non-macroexpanded top level form is printed to *STANDARD-OUTPUT*. Top level forms that whose subforms are processed as top level forms (eg. EVAL-WHEN, MACROLET, PROGN) receive no such message, but their subforms do. As an extension to ANSI, if :PRINT is :top-level-forms, a message per top level form after macroexpansion is printed to *STANDARD-OUTPUT*. For example, compiling an IN-PACKAGE form will result in a message about a top level SETQ in addition to the message about the IN-PACKAGE form' itself. Both forms of reporting obey the SB-EXT:*COMPILER-PRINT-VARIABLE-ALIST*. :BLOCK-COMPILE Though COMPILE-FILE accepts an additional :BLOCK-COMPILE argument, it is not currently supported. (non-standard) :TRACE-FILE If given, internal data structures are dumped to the specified file, or if a value of T is given, to a file of *.trace type derived from the input file name. (non-standard) :EMIT-CFASL (Experimental). If true, outputs the toplevel compile-time effects of this file into a separate .cfasl file.

COMPILE-FILE-PATHNAME (INPUT-FILE &KEY (OUTPUT-FILE NIL OUTPUT-FILE-P) &ALLOW-OTHER-KEYS)

Return a pathname describing what file COMPILE-FILE would write to given these arguments.

COMPILED-FUNCTION-P (OBJECT)

Return true if OBJECT is a COMPILED-FUNCTION, and NIL otherwise.

COMPILER-MACRO-FUNCTION (NAME &OPTIONAL ENV)

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)

Return a new function that returns T whenever FUNCTION returns NIL and NIL whenever FUNCTION returns non-NIL.

COMPLEX (REALPART &OPTIONAL (IMAGPART 0))

Return a complex number with the specified real and imaginary components.

COMPLEXP (OBJECT)

Return true if OBJECT is a COMPLEX, and NIL otherwise.

COMPOSE (FUNCTION &REST MORE-FUNCTIONS)

Returns a function composed of FUNCTION and MORE-FUNCTIONS that applies its arguments to to each in turn, starting from the rightmost of MORE-FUNCTIONS, and then calling the next one with the primary value of the last.

COMPUTE-RESTARTS (&OPTIONAL CONDITION)

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)

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-STREAMS (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

CONJOIN (PREDICATE &REST MORE-PREDICATES)

Returns a function that applies each of PREDICATE and MORE-PREDICATE functions in turn to its arguments, returning NIL if any of the predicates returns false, without calling the remaining predicates. If none of the predicates returns false, returns the primary value of the last predicate.

CONJUGATE (NUMBER)

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

CONS (SE1 SE2)

Return a list with SE1 as the CAR and SE2 as the CDR.

CONSP (OBJECT)

Return true if OBJECT is a CONS, and NIL otherwise.

CONSTANTLY (VALUE)

Return a function that always returns VALUE.

CONSTANTP (FORM &OPTIONAL (ENVIRONMENT NIL ENVP))

True of any FORM that has a constant value: self-evaluating objects, keywords, defined constants, quote forms. Additionally the constant-foldability of some function calls special forms is recognized. If ENVIRONMENT is provided the FORM is first macroexpanded in it.

CONTINUE (&OPTIONAL CONDITION)

Transfer control to a restart named CONTINUE, or return NIL if none exists.

COPY-ALIST (ALIST)

Return a new association list which is EQUAL to ALIST.

COPY-ARRAY (ARRAY &KEY (ELEMENT-TYPE (ARRAY-ELEMENT-TYPE ARRAY)) (FILL-POINTER (AND (ARRAY-HAS-FILL-POINTER-P ARRAY) (FILL-POINTER ARRAY))) (ADJUSTABLE (ADJUSTABLE-ARRAY-P ARRAY)))

Returns an undisplaced copy of ARRAY, with same fill-pointer and adjustability (if any) as the original, unless overridden by the keyword arguments.

COPY-HASH-TABLE (TABLE &KEY KEY TEST SIZE REHASH-SIZE REHASH-THRESHOLD)

Returns a copy of hash table TABLE, with the same keys and values as the TABLE. The copy has the same properties as the original, unless overridden by the keyword arguments. Before each of the original values is set into the new hash-table, KEY is invoked on the value. As KEY defaults to CL:IDENTITY, a shallow copy is returned by default.

COPY-LIST (LIST)

Return a new list which is EQUAL to LIST. LIST may be improper.

COPY-SEQ (SEQUENCE)

Return a copy of SEQUENCE which is EQUAL to SEQUENCE but not EQ.

COPY-SEQUENCE (TYPE SEQUENCE)

Returns a fresh sequence of TYPE, which has the same elements as SEQUENCE.

COPY-STREAM (INPUT OUTPUT &KEY (ELEMENT-TYPE (STREAM-ELEMENT-TYPE INPUT)) (BUFFER-SIZE 4096) (BUFFER (MAKE-ARRAY BUFFER-SIZE ELEMENT-TYPE ELEMENT-TYPE)) (START 0) END FINISH-OUTPUT)

Reads data from INPUT and writes it to OUTPUT. Both INPUT and OUTPUT must be streams, they will be passed to READ-SEQUENCE and WRITE-SEQUENCE and must have compatible element-types.

COPY-STRUCTURE (STRUCTURE)

Return a copy of STRUCTURE with the same (EQL) slot values.

COPY-SYMBOL (SYMBOL &OPTIONAL (COPY-PROPS NIL) &AUX NEW-SYMBOL)

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 (OBJECT)

Recursively copy trees of conses.

COS (NUMBER)

Return the cosine of NUMBER.

COSH (NUMBER)

Return the hyperbolic cosine of NUMBER.

COUNT (ITEM SEQUENCE &REST ARGS &KEY FROM-END (START 0) (END NIL) (KEY NIL) (TEST #'EQL TEST-P) (TEST-NOT NIL TEST-NOT-P))

Return the number of elements in SEQUENCE satisfying a test with ITEM, which defaults to EQL.

COUNT-IF (PRED SEQUENCE &REST ARGS &KEY FROM-END (START 0) (END NIL) (KEY NIL))

Return the number of elements in SEQUENCE satisfying PRED(el).

COUNT-IF-NOT (PRED SEQUENCE &REST ARGS &KEY FROM-END (START 0) (END NIL) (KEY NIL))

Return the number of elements in SEQUENCE not satisfying TEST(el).

COUNT-PERMUTATIONS (N &OPTIONAL (K N))

Number of K element permutations for a sequence of N objects. K defaults to N

CURRY (FUNCTION &REST ARGUMENTS)

Returns a function that applies ARGUMENTS and the arguments it is called with to FUNCTION.

DECODE-FLOAT (F)

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)

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.

DELETE (ITEM SEQUENCE &REST ARGS &KEY FROM-END (TEST #'EQL) (TEST-NOT NIL) (START 0) (END NIL) (COUNT NIL) (KEY NIL))

Return a sequence formed by destructively removing the specified ITEM from the given SEQUENCE.

DELETE-DUPLICATES (SEQUENCE &REST ARGS &KEY (TEST #'EQL) (TEST-NOT NIL) (START 0) (END NIL) FROM-END (KEY NIL))

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. The :TEST-NOT argument is deprecated.

DELETE-FILE (FILE)

Delete the specified FILE. If FILE is a stream, on Windows the stream is closed immediately. On Unix plaforms the stream remains open, allowing IO to continue: the OS resources associated with the deleted file remain available till the stream is closed as per standard Unix unlink() behaviour.

DELETE-FROM-PLIST (PLIST &REST KEYS)

Just like REMOVE-FROM-PLIST, but this version may destructively modify the provided plist.

DELETE-IF (PREDICATE SEQUENCE &REST ARGS &KEY FROM-END (START 0) (KEY NIL) (END NIL) (COUNT NIL))

Return a sequence formed by destructively removing the elements satisfying the specified PREDICATE from the given SEQUENCE.

DELETE-IF-NOT (PREDICATE SEQUENCE &REST ARGS &KEY FROM-END (START 0) (END NIL) (KEY NIL) (COUNT NIL))

Return a sequence formed by destructively removing the elements not satisfying the specified PREDICATE from the given SEQUENCE.

DELETE-PACKAGE (PACKAGE-DESIGNATOR)

Delete the package designated by PACKAGE-DESIGNATOR from the package system data structures.

DENOMINATOR (NUMBER)

Return the denominator of NUMBER, which must be rational.

DEPOSIT-FIELD (NEWBYTE BYTESPEC INTEGER)

Return new integer with newbyte in specified position, newbyte is not right justified.

DESCRIBE (OBJECT &OPTIONAL (STREAM-DESIGNATOR *STANDARD-OUTPUT*))

Print a description of OBJECT to STREAM-DESIGNATOR.

DIGIT-CHAR (WEIGHT &OPTIONAL (RADIX 10))

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 10))

If char is a digit in the specified radix, returns the fixnum for which that digit stands, else returns NIL.

DIRECTORY (PATHSPEC &KEY (RESOLVE-SYMLINKS T))

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. If :RESOLVE-SYMLINKS is NIL, don't resolve symbolic links in matching filenames.

DIRECTORY-NAMESTRING (PATHNAME)

Return a string representation of the directories used in the pathname.

DISASSEMBLE (OBJECT &KEY (STREAM *STANDARD-OUTPUT*) (USE-LABELS T))

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.

DISJOIN (PREDICATE &REST MORE-PREDICATES)

Returns a function that applies each of PREDICATE and MORE-PREDICATE functions in turn to its arguments, returning the primary value of the first predicate that returns true, without calling the remaining predicates. If none of the predicates returns true, NIL is returned.

DPB (NEWBYTE BYTESPEC INTEGER)

Return new integer with newbyte in specified position, newbyte is right justified.

DRIBBLE (&OPTIONAL PATHNAME &KEY (IF-EXISTS APPEND))

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.

ECHO-STREAM-INPUT-STREAM (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

ECHO-STREAM-OUTPUT-STREAM (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

ED (&OPTIONAL X)

Starts the editor (on a file or a function if named). Functions from the list *ED-FUNCTIONS* are called in order with X as an argument until one of them returns non-NIL; these functions are responsible for signalling a FILE-ERROR to indicate failure to perform an operation on the file system.

EIGHTH (LIST)

Return the 8th object in a list or NIL if there is no 8th object.

ELT (SEQUENCE INDEX)

Return the element of SEQUENCE specified by INDEX.

EMPTYP (SEQUENCE)

Returns true if SEQUENCE is an empty sequence. Signals an error if SEQUENCE is not a sequence.

ENCODE-UNIVERSAL-TIME (SECOND MINUTE HOUR DATE MONTH YEAR &OPTIONAL TIME-ZONE)

The time values specified in decoded format are converted to universal time, which is returned.

ENDP (OBJECT)

This is the recommended way to test for the end of a proper list. It returns true if OBJECT is NIL, false if OBJECT is a CONS, and an error for any other type of OBJECT.

ENDS-WITH (OBJECT SEQUENCE &KEY (TEST #'EQL) (KEY #'IDENTITY))

Returns true if SEQUENCE is a sequence whose last element is EQL to OBJECT. Returns NIL if the SEQUENCE is not a sequence or is an empty sequence. Signals an error if SEQUENCE is an improper list.

ENDS-WITH-SUBSEQ (SUFFIX SEQUENCE &KEY (TEST #'EQL))

Test whether SEQUENCE ends with SUFFIX. In other words: return true if the last (length SUFFIX) elements of SEQUENCE are equal to SUFFIX.

ENOUGH-NAMESTRING (PATHNAME &OPTIONAL (DEFAULTS *DEFAULT-PATHNAME-DEFAULTS*))

Return an abbreviated pathname sufficent to identify the pathname relative to the defaults.

ENSURE-CAR (THING)

If THING is a CONS, its CAR is returned. Otherwise THING is returned.

ENSURE-CONS (CONS)

If CONS is a cons, it is returned. Otherwise returns a fresh cons with CONS in the car, and NIL in the cdr.

ENSURE-DIRECTORIES-EXIST (PATHSPEC &KEY VERBOSE (MODE 511))

Test whether the directories containing the specified file actually exist, and attempt to create them if they do not. The MODE argument is a CMUCL/SBCL-specific extension to control the Unix permission bits.

ENSURE-FUNCTION (FUNCTION-DESIGNATOR)

Returns the function designated by FUNCTION-DESIGNATOR: if FUNCTION-DESIGNATOR is a function, it is returned, otherwise it must be a function name and its FDEFINITION is returned.

ENSURE-LIST (LIST)

If LIST is a list, it is returned. Otherwise returns the list designated by LIST.

ENSURE-SYMBOL (NAME &OPTIONAL (PACKAGE *PACKAGE*))

Returns a symbol with name designated by NAME, accessible in package designated by PACKAGE. If symbol is not already accessible in PACKAGE, it is interned there. Returns a secondary value reflecting the status of the symbol in the package, which matches the secondary return value of INTERN. Example: (ensure-symbol :cons :cl) => cl:cons, :external

EQ (OBJ1 OBJ2)

Return T if OBJ1 and OBJ2 are the same object, otherwise NIL.

EQUAL (X Y)

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.

ERROR (DATUM &REST ARGUMENTS)

Invoke the signal facility on a condition formed from DATUM and ARGUMENTS. If the condition is not handled, the debugger is invoked.

EVAL (ORIGINAL-EXP)

Evaluate the argument in a null lexical environment, returning the result or results.

EVAL-WHEN (SITUATIONS &REST FORMS)

EVAL-WHEN (situation*) form* Evaluate the FORMS in the specified SITUATIONS (any of :COMPILE-TOPLEVEL, :LOAD-TOPLEVEL, or :EXECUTE, or (deprecated) COMPILE, LOAD, or EVAL).

EVENP (NUMBER)

Is this integer even?

EVERY (PRED FIRST-SEQ &REST MORE-SEQS)

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 (NUMBER)

Return e raised to the power NUMBER.

EXPORT (SYMBOLS &OPTIONAL (PACKAGE (SANE-PACKAGE)))

Exports SYMBOLS from PACKAGE, checking that no name conflicts result.

EXPT (BASE POWER)

Return BASE raised to the POWER.

EXTREMUM (SEQUENCE PREDICATE &KEY KEY (START 0) END)

Returns the element of SEQUENCE that would appear first if the subsequence bounded by START and END was sorted using PREDICATE and KEY. EXTREMUM determines the relationship between two elements of SEQUENCE by using the PREDICATE function. PREDICATE should return true if and only if the first argument is strictly less than the second one (in some appropriate sense). Two arguments X and Y are considered to be equal if (FUNCALL PREDICATE X Y) and (FUNCALL PREDICATE Y X) are both false. The arguments to the PREDICATE function are computed from elements of SEQUENCE using the KEY function, if supplied. If KEY is not supplied or is NIL, the sequence element itself is used. If SEQUENCE is empty, NIL is returned.

FACTORIAL (N)

Factorial of non-negative integer N.

FBOUNDP (NAME)

Return true if name has a global function definition.

FCEILING (NUMBER &OPTIONAL (DIVISOR 1))

Same as CEILING, but returns first value as a float.

FDEFINITION (NAME)

Return name's global function definition taking care to respect any encapsulations and to return the innermost encapsulated definition. This is SETF'able.

FEATUREP (FEATURE-EXPRESSION)

Returns T if the argument matches the state of the *FEATURES* list and NIL if it does not. FEATURE-EXPRESSION can be any atom or list acceptable to the reader macros #+ and #-.

FFLOOR (NUMBER &OPTIONAL (DIVISOR 1))

Same as FLOOR, but returns first value as a float.

FIFTH (LIST)

Return the 5th object in a list or NIL if there is no 5th object.

FILE-AUTHOR (PATHSPEC)

Return the author of the file specified by PATHSPEC. Signal an error of type FILE-ERROR if no such file exists, or if PATHSPEC is a wild pathname.

FILE-ERROR-PATHNAME (CONDITION)

Return the offending thread that the THREAD-ERROR pertains to.

FILE-NAMESTRING (PATHNAME)

Return a string representation of the name used in the pathname.

FILE-WRITE-DATE (PATHSPEC)

Return the write date of the file specified by PATHSPEC. An error of type FILE-ERROR is signaled if no such file exists, or if PATHSPEC is a wild pathname.

FILL (SEQUENCE ITEM &KEY (START 0) END)

Replace the specified elements of SEQUENCE with ITEM.

FILL-POINTER (VECTOR)

Return the FILL-POINTER of the given VECTOR.

FIND-ALL-SYMBOLS (STRING-OR-SYMBOL)

Return a list of all symbols in the system having the specified name.

FIND-RESTART (IDENTIFIER &OPTIONAL CONDITION)

Return the first restart identified by IDENTIFIER. If IDENTIFIER is a symbol, then the innermost applicable restart with that name is returned. If IDENTIFIER is a restart, it is returned if it is currently active. Otherwise NIL is returned. If CONDITION is specified and not NIL, then only restarts associated with that condition (or with no condition) will be returned.

FIND-SYMBOL (NAME &OPTIONAL (PACKAGE (SANE-PACKAGE)))

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.

FIRST (LIST)

Return the 1st object in a list or NIL if the list is empty.

FIRST-ELT (SEQUENCE)

Returns the first element of SEQUENCE. Signals a type-error if SEQUENCE is not a sequence, or is an empty sequence.

SETFFIRST-ELT (OBJECT SEQUENCE)

Sets the first element of SEQUENCE. Signals a type-error if SEQUENCE is not a sequence, is an empty sequence, or if OBJECT cannot be stored in SEQUENCE.

FLATTEN (TREE)

Traverses the tree in order, collecting non-null leaves into a list.

FLET (DEFINITIONS &BODY BODY)

FLET ({(name lambda-list declaration* form*)}*) declaration* body-form* Evaluate the BODY-FORMS with local function definitions. The bindings do not enclose the definitions; any use of NAME in the FORMS will refer to the lexically apparent function definition in the enclosing environment.

FLOAT (NUMBER &OPTIONAL (OTHER NIL OTHERP))

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-PRECISION (F)

Return a non-negative number of significant digits in its float argument. Will be less than FLOAT-DIGITS if denormalized or zero.

FLOAT-RADIX (X)

Return (as an integer) the radix b of its floating-point argument.

FLOAT-SIGN (FLOAT1 &OPTIONAL (FLOAT2 (FLOAT 1 FLOAT1)))

Return a floating-point number that has the same sign as FLOAT1 and, if FLOAT2 is given, has the same absolute value as FLOAT2.

FLOATP (OBJECT)

Return true if OBJECT is a FLOAT, and NIL otherwise.

FLOOR (NUMBER &OPTIONAL (DIVISOR 1))

Return the greatest integer not greater than number, or number/divisor. The second returned value is (mod number divisor).

FMAKUNBOUND (NAME)

Make NAME have no global function definition.

FORMAT (DESTINATION CONTROL-STRING &REST FORMAT-ARGUMENTS)

Provides various facilities for formatting output. CONTROL-STRING contains a string to be output, possibly with embedded directives, which are flagged with the escape character "~". Directives generally expand into additional text to be output, usually consuming one or more of the FORMAT-ARGUMENTS in the process. A few useful directives are: ~A or ~nA Prints one argument as if by PRINC ~S or ~nS Prints one argument as if by PRIN1 ~D or ~nD Prints one argument as a decimal integer ~% Does a TERPRI ~& Does a FRESH-LINE where n is the width of the field in which the object is printed. DESTINATION controls where the result will go. If DESTINATION is T, then the output is sent to the standard output stream. If it is NIL, then the output is returned in a string as the value of the call. Otherwise, DESTINATION must be a stream to which the output will be sent. Example: (FORMAT NIL "The answer is ~D." 10) => "The answer is 10." FORMAT has many additional capabilities not described here. Consult the manual for details.

FORMAT-SYMBOL (PACKAGE CONTROL &REST ARGUMENTS)

Constructs a string by applying ARGUMENTS to string designator CONTROL as if by FORMAT within WITH-STANDARD-IO-SYNTAX, and then creates a symbol named by that string. If PACKAGE is NIL, returns an uninterned symbol, if package is T, returns a symbol interned in the current package, and otherwise returns a symbol interned in the package designated by PACKAGE.

FOURTH (LIST)

Return the 4th object in a list or NIL if there is no 4th object.

FROUND (NUMBER &OPTIONAL (DIVISOR 1))

Same as ROUND, but returns first value as a float.

FTRUNCATE (NUMBER &OPTIONAL (DIVISOR 1))

Same as TRUNCATE, but returns first value as a float.

FUNCALL (FUNCTION &REST ARGUMENTS)

Call FUNCTION with the given ARGUMENTS.

FUNCTION (THING)

FUNCTION name Return the lexically apparent definition of the function NAME. NAME may also be a lambda expression.

FUNCTION-LAMBDA-EXPRESSION (FUN)

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.

FUNCTION-NAME-P (FUNCTION-NAME)

Returns T if FUNCTION-NAME is a legal function name: a symbol or a list (CL:SETF symbol).

FUNCTIONP (OBJECT)

Return true if OBJECT is a FUNCTION, and NIL otherwise.

GAUSSIAN-RANDOM (&OPTIONAL MIN MAX)

Returns two gaussian random double floats as the primary and secondary value, optionally constrained by MIN and MAX. Gaussian random numbers form a standard normal distribution around 0.0d0. Sufficiently positive MIN or negative MAX will cause the algorithm used to take a very long time. If MIN is positive it should be close to zero, and similarly if MAX is negative it should be close to zero.

GCD (&REST INTEGERS)

Return the greatest common divisor of the arguments, which must be integers. Gcd with no arguments is defined to be 0.

GENSYM (&OPTIONAL (THING G))

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 T) (PACKAGE (SANE-PACKAGE)))

Creates a new symbol interned in package PACKAGE with the given PREFIX.

GET (SYMBOL INDICATOR &OPTIONAL (DEFAULT NIL))

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

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-CHAR SUB-CHAR &OPTIONAL (RT-DESIGNATOR *READTABLE*))

Return the macro character function for SUB-CHAR under DISP-CHAR or NIL if there is no associated function.

GET-INTERNAL-REAL-TIME

Return the real time ("wallclock time") since startup in the internal time format. (See INTERNAL-TIME-UNITS-PER-SECOND.)

GET-INTERNAL-RUN-TIME

Return the run time used by the process in the internal time format. (See INTERNAL-TIME-UNITS-PER-SECOND.) This is useful for finding CPU usage. Includes both "system" and "user" time.

GET-MACRO-CHARACTER (CHAR &OPTIONAL (RT-DESIGNATOR *READTABLE*))

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-PROPERTIES (PLACE INDICATOR-LIST)

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 ENVIRONMENT)

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

Return a single integer for the current time of day in universal time format.

GETF (PLACE INDICATOR &OPTIONAL (DEFAULT NIL))

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-TABLE &OPTIONAL DEFAULT)

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 (TAG)

GO tag Transfer control to the named TAG in the lexically enclosing TAGBODY. This is constrained to be used only within the dynamic extent of the TAGBODY.

GRAPHIC-CHAR-P (CHAR)

The argument must be a character object. GRAPHIC-CHAR-P returns T if the argument is a printing character (space through ~ in ASCII), otherwise returns NIL.

HASH-TABLE-ALIST (TABLE)

Returns an association list containing the keys and values of hash table TABLE.

HASH-TABLE-COUNT (HASH-TABLE)

Return the number of entries in the given HASH-TABLE.

HASH-TABLE-KEYS (TABLE)

Returns a list containing the keys of hash table TABLE.

HASH-TABLE-PLIST (TABLE)

Returns a property list containing the keys and values of hash table TABLE.

HASH-TABLE-REHASH-SIZE (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

HASH-TABLE-REHASH-THRESHOLD (INSTANCE)

Return the rehash-threshold HASH-TABLE was created with.

HASH-TABLE-SIZE (HASH-TABLE)

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 (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

HASH-TABLE-VALUES (TABLE)

Returns a list containing the values of hash table TABLE.

HOST-NAMESTRING (PATHNAME)

Return a string representation of the name of the host in the pathname.

IDENTITY (THING)

This function simply returns what was passed to it.

IF (TEST THEN &OPTIONAL ELSE)

IF predicate then [else] If PREDICATE evaluates to true, evaluate THEN and return its values, otherwise evaluate ELSE and return its values. ELSE defaults to NIL.

IMAGPART (NUMBER)

Extract the imaginary part of a number.

IMPORT (SYMBOLS &OPTIONAL (PACKAGE (SANE-PACKAGE)))

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.

INTEGER-DECODE-FLOAT (X)

Return 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)

Return the number of non-sign bits in the twos-complement representation of INTEGER.

INTEGERP (OBJECT)

Return true if OBJECT is an INTEGER, and NIL otherwise.

INTERN (NAME &OPTIONAL (PACKAGE (SANE-PACKAGE)))

Return a symbol in PACKAGE having the specified NAME, creating it if necessary.

INTERSECTION (LIST1 LIST2 &KEY KEY (TEST #'EQL TESTP) (TEST-NOT NIL NOTP))

Return the intersection of LIST1 and LIST2.

INVOKE-DEBUGGER (CONDITION)

Enter the debugger.

INVOKE-RESTART (RESTART &REST VALUES)

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)

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.

IOTA (N &KEY (START 0) (STEP 1))

Return a list of n numbers, starting from START (with numeric contagion from STEP applied), each consequtive number being the sum of the previous one and STEP. START defaults to 0 and STEP to 1. Examples: (iota 4) => (0 1 2 3) (iota 3 :start 1 :step 1.0) => (1.0 2.0 3.0) (iota 3 :start -1 :step -1/2) => (-1 -3/2 -2)

ISQRT (N)

Return the greatest integer less than or equal to the square root of N.

KEYWORDP (OBJECT)

Return true if Object is a symbol in the "KEYWORD" package.

LABELS (DEFINITIONS &BODY BODY)

LABELS ({(name lambda-list declaration* form*)}*) declaration* body-form* Evaluate the BODY-FORMS with local function definitions. The bindings enclose the new definitions, so the defined functions can call themselves or each other.

LAST (LIST &OPTIONAL (N 1))

Return the last N conses (not the last element!) of a list.

LAST-ELT (SEQUENCE)

Returns the last element of SEQUENCE. Signals a type-error if SEQUENCE is not a proper sequence, or is an empty sequence.

SETFLAST-ELT (OBJECT SEQUENCE)

Sets the last element of SEQUENCE. Signals a type-error if SEQUENCE is not a proper sequence, is an empty sequence, or if OBJECT cannot be stored in SEQUENCE.

LASTCAR (LIST)

Returns the last element of LIST. Signals a type-error if LIST is not a proper list.

SETFLASTCAR (OBJECT LIST)

Sets the last element of LIST. Signals a type-error if LIST is not a proper list.

LCM (&REST INTEGERS)

Return the least common multiple of one or more integers. LCM of no arguments is defined to be 1.

LDB (BYTESPEC INTEGER)

Extract the specified byte from integer, and right justify result.

LDB-TEST (BYTESPEC INTEGER)

Return T if any of the specified bits in integer are 1's.

LDIFF (LIST OBJECT)

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.

LENGTH (SEQUENCE)

Return an integer that is the length of SEQUENCE.

LENGTH= (&REST SEQUENCES)

Takes any number of sequences or integers in any order. Returns true iff the length of all the sequences and the integers are equal. Hint: there's a compiler macro that expands into more efficient code if the first argument is a literal integer.

LERP (V A B)

Returns the result of linear interpolation between A and B, using the interpolation coefficient V.

LET (BINDINGS &BODY BODY)

LET ({(var [value]) | var}*) declaration* form* During evaluation of the FORMS, bind the VARS to the result of evaluating the VALUE forms. The variables are bound in parallel after all of the VALUES forms have been evaluated.

LET* (BINDINGS &BODY BODY)

LET* ({(var [value]) | var}*) declaration* form* Similar to LET, but the variables are bound sequentially, allowing each VALUE form to reference any of the previous VARS.

LIST (&REST ARGS)

Return constructs and returns a list of its arguments.

LIST* (ARG &REST OTHERS)

Return a list of the arguments with last cons a dotted pair.

LIST-ALL-PACKAGES

Return a list of all existing packages.

LIST-LENGTH (LIST)

Return the length of the given List, or Nil if the List is circular.

LISTP (OBJECT)

Return true if OBJECT is a LIST, and NIL otherwise.

LOAD (PATHSPEC &KEY (VERBOSE *LOAD-VERBOSE*) (PRINT *LOAD-PRINT*) (IF-DOES-NOT-EXIST T) (EXTERNAL-FORMAT DEFAULT))

Load the file given by FILESPEC into the Lisp environment, returning T on success.

LOAD-LOGICAL-PATHNAME-TRANSLATIONS (HOST)

Reads logical pathname translations from SYS:SITE;HOST.TRANSLATIONS.NEWEST, with HOST replaced by the supplied parameter. Returns T on success. If HOST is already defined as logical pathname host, no file is loaded and NIL is returned. The file should contain a single form, suitable for use with (SETF LOGICAL-PATHNAME-TRANSLATIONS). Note: behaviour of this function is higly implementation dependent, and historically it used to be a no-op in SBcL -- the current approach is somewhat experimental and subject to change.

LOAD-TIME-VALUE (FORM &OPTIONAL READ-ONLY-P)

Arrange for FORM to be evaluated at load-time and use the value produced as if it were a constant. If READ-ONLY-P is non-NIL, then the resultant object is guaranteed to never be modified, so it can be put in read-only storage.

LOCALLY (&BODY BODY)

LOCALLY declaration* form* Sequentially evaluate the FORMS in a lexical environment where the DECLARATIONS have effect. If LOCALLY is a top level form, then the FORMS are also processed as top level forms.

LOG (NUMBER &OPTIONAL (BASE NIL BASE-P))

Return the logarithm of NUMBER in the base BASE, which defaults to e.

LOGAND (&REST INTEGERS)

Return the bit-wise and of its arguments. Args must be integers.

LOGANDC1 (INTEGER1 INTEGER2)

Bitwise AND (LOGNOT INTEGER1) with INTEGER2.

LOGANDC2 (INTEGER1 INTEGER2)

Bitwise AND INTEGER1 with (LOGNOT INTEGER2).

LOGBITP (INDEX INTEGER)

Predicate returns T if bit index of integer is a 1.

LOGCOUNT (INTEGER)

Count the number of 1 bits if INTEGER is positive, and the number of 0 bits if INTEGER is negative.

LOGEQV (&REST INTEGERS)

Return the bit-wise equivalence of its arguments. Args must be integers.

LOGICAL-PATHNAME (PATHSPEC)

Converts the pathspec argument to a logical-pathname and returns it.

LOGICAL-PATHNAME-TRANSLATIONS (HOST)

Return the (logical) host object argument's list of translations.

SETFLOGICAL-PATHNAME-TRANSLATIONS (TRANSLATIONS HOST)

Set the translations list for the logical host argument.

LOGIOR (&REST INTEGERS)

Return the bit-wise or of its arguments. Args must be integers.

LOGNAND (INTEGER1 INTEGER2)

Complement the logical AND of INTEGER1 and INTEGER2.

LOGNOR (INTEGER1 INTEGER2)

Complement the logical AND of INTEGER1 and INTEGER2.

LOGNOT (NUMBER)

Return the bit-wise logical not of integer.

LOGORC1 (INTEGER1 INTEGER2)

Bitwise OR (LOGNOT INTEGER1) with INTEGER2.

LOGORC2 (INTEGER1 INTEGER2)

Bitwise OR INTEGER1 with (LOGNOT INTEGER2).

LOGTEST (INTEGER1 INTEGER2)

Predicate which returns T if logand of integer1 and integer2 is not zero.

LOGXOR (&REST INTEGERS)

Return the bit-wise exclusive or of its arguments. Args must be integers.

LONG-SITE-NAME

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

LOWER-CASE-P (CHAR)

The argument must be a character object; LOWER-CASE-P returns T if the argument is a lower-case character, NIL otherwise.

MACHINE-INSTANCE

Return a string giving the name of the local machine.

MACHINE-TYPE

Return a string describing the type of the local machine.

MACHINE-VERSION

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 (SYMBOL &OPTIONAL ENV)

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)

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)

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 (DEFINITIONS &REST BODY)

MACROLET ({(name lambda-list form*)}*) body-form* Evaluate the BODY-FORMS in an environment with the specified local macros defined. NAME is the local macro name, LAMBDA-LIST is a DEFMACRO style destructuring lambda list, and the FORMS evaluate to the expansion.

MAKE-CIRCULAR-LIST (LENGTH &KEY INITIAL-ELEMENT)

Creates a circular list of LENGTH with the given INITIAL-ELEMENT.

MAKE-CONCATENATED-STREAM (&REST STREAMS)

Return a stream which takes its input from each of the streams in turn, going on to the next at EOF.

MAKE-CONDITION (TYPE &REST ARGS)

Make an instance of a condition object using the specified initargs.

MAKE-DISPATCH-MACRO-CHARACTER (CHAR &OPTIONAL (NON-TERMINATING-P NIL) (RT *READTABLE*))

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)

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-GENSYM (NAME)

If NAME is a non-negative integer, calls GENSYM using it. Otherwise NAME must be a string designator, in which case calls GENSYM using the designated string as the argument.

MAKE-GENSYM-LIST (LENGTH &OPTIONAL (X G))

Returns a list of LENGTH gensyms, each generated as if with a call to MAKE-GENSYM, using the second (optional, defaulting to "G") argument.

MAKE-HASH-TABLE (&KEY (TEST 'EQL) (SIZE +MIN-HASH-TABLE-SIZE+) (REHASH-SIZE 1.5) (REHASH-THRESHOLD 1) (HASH-FUNCTION NIL) (WEAKNESS NIL) (SYNCHRONIZED))

Create and return a new hash table. The keywords are as follows: :TEST Determines how keys are compared. Must a designator for one of the standard hash table tests, or a hash table test defined using SB-EXT:DEFINE-HASH-TABLE-TEST. Additionally, when an explicit HASH-FUNCTION is provided (see below), any two argument equivalence predicate can be used as the TEST. :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. :HASH-FUNCTION If NIL (the default), a hash function based on the TEST argument is used, which then must be one of the standardized hash table test functions, or one for which a default hash function has been defined using SB-EXT:DEFINE-HASH-TABLE-TEST. If HASH-FUNCTION is specified, the TEST argument can be any two argument predicate consistent with it. The HASH-FUNCTION is expected to return a non-negative fixnum hash code. :WEAKNESS When :WEAKNESS is not NIL, garbage collection may remove entries from the hash table. The value of :WEAKNESS specifies how the presence of a key or value in the hash table preserves their entries from garbage collection. Valid values are: :KEY means that the key of an entry must be live to guarantee that the entry is preserved. :VALUE means that the value of an entry must be live to guarantee that the entry is preserved. :KEY-AND-VALUE means that both the key and the value must be live to guarantee that the entry is preserved. :KEY-OR-VALUE means that either the key or the value must be live to guarantee that the entry is preserved. NIL (the default) means that entries are always preserved. :SYNCHRONIZED If NIL (the default), the hash-table may have multiple concurrent readers, but results are undefined if a thread writes to the hash-table concurrently with another reader or writer. If T, all concurrent accesses are safe, but note that CLHS 3.6 (Traversal Rules and Side Effects) remains in force. See also: SB-EXT:WITH-LOCKED-HASH-TABLE. This keyword argument is experimental, and may change incompatibly or be removed in the future.

MAKE-KEYWORD (NAME)

Interns the string designated by NAME in the KEYWORD package.

MAKE-LIST (SIZE &KEY INITIAL-ELEMENT)

Constructs a list with size elements each set to value

MAKE-PACKAGE (NAME &KEY (USE 'NIL) NICKNAMES (INTERNAL-SYMBOLS 10) (EXTERNAL-SYMBOLS 10))

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 NIL DEVP) (DIRECTORY NIL DIRP) (NAME NIL NAMEP) (TYPE NIL TYPEP) (VERSION NIL VERSIONP) DEFAULTS (CASE LOCAL))

Makes a new pathname from the component arguments. Note that host is a host-structure or string.

MAKE-RANDOM-STATE (&OPTIONAL STATE)

Make a random state object. The optional STATE argument specifies a seed for deterministic pseudo-random number generation. As per the Common Lisp standard, - If STATE is NIL or not supplied, return a copy of the default *RANDOM-STATE*. - If STATE is a random state, return a copy of it. - If STATE is T, return a randomly initialized state (using operating-system provided randomness where available, otherwise a poor substitute based on internal time and pid). See SB-EXT:SEED-RANDOM-STATE for a SBCL extension to this functionality.

MAKE-SEQUENCE (TYPE LENGTH &KEY (INITIAL-ELEMENT NIL IEP))

Return a sequence of the given TYPE and LENGTH, with elements initialized to INITIAL-ELEMENT.

MAKE-STRING (COUNT &KEY (ELEMENT-TYPE 'CHARACTER) ((INITIAL-ELEMENT FILL-CHAR)))

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 0) END)

Return an input stream which will supply the characters of STRING between START and END in order.

MAKE-STRING-OUTPUT-STREAM (&KEY (ELEMENT-TYPE 'CHARACTER) &AUX (BUFFER (MAKE-STRING *STRING-OUTPUT-STREAM-BUFFER-INITIAL-SIZE*)))

Return an output stream which will accumulate all output given it for the benefit of the function GET-OUTPUT-STREAM-STRING.

MAKE-SYMBOL (STRING)

Make and return a new symbol with the STRING as its print name.

MAKE-TWO-WAY-STREAM (INPUT-STREAM OUTPUT-STREAM)

Return a bidirectional stream which gets its input from INPUT-STREAM and sends its output to OUTPUT-STREAM.

MAKUNBOUND (SYMBOL)

Make SYMBOL unbound, removing any value it may currently have.

MAP-COMBINATIONS (FUNCTION SEQUENCE &KEY (START 0) END LENGTH (COPY T))

Calls FUNCTION with each combination of LENGTH constructable from the elements of the subsequence of SEQUENCE delimited by START and END. START defaults to 0, END to length of SEQUENCE, and LENGTH to the length of the delimited subsequence. (So unless LENGTH is specified there is only a single combination, which has the same elements as the delimited subsequence.) If COPY is true (the default) each combination is freshly allocated. If COPY is false all combinations are EQ to each other, in which case consequences are specified if a combination is modified by FUNCTION.

MAP-DERANGEMENTS (FUNCTION SEQUENCE &KEY (START 0) END (COPY T))

Calls FUNCTION with each derangement of the subsequence of SEQUENCE denoted by the bounding index designators START and END. Derangement is a permutation of the sequence where no element remains in place. SEQUENCE is not modified, but individual derangements are EQ to each other. Consequences are unspecified if calling FUNCTION modifies either the derangement or SEQUENCE.

MAP-IOTA (FUNCTION N &KEY (START 0) (STEP 1))

Calls FUNCTION with N numbers, starting from START (with numeric contagion from STEP applied), each consequtive number being the sum of the previous one and STEP. START defaults to 0 and STEP to 1. Returns N. Examples: (map-iota #'print 3 :start 1 :step 1.0) => 3 ;;; 1.0 ;;; 2.0 ;;; 3.0

MAP-PERMUTATIONS (FUNCTION SEQUENCE &KEY (START 0) END LENGTH (COPY T))

Calls function with each permutation of LENGTH constructable from the subsequence of SEQUENCE delimited by START and END. START defaults to 0, END to length of the sequence, and LENGTH to the length of the delimited subsequence.

MAP-PRODUCT (FUNCTION LIST &REST MORE-LISTS)

Returns a list containing the results of calling FUNCTION with one argument from LIST, and one from each of MORE-LISTS for each combination of arguments. In other words, returns the product of LIST and MORE-LISTS using FUNCTION. Example: (map-product 'list '(1 2) '(3 4) '(5 6)) => ((1 3 5) (1 3 6) (1 4 5) (1 4 6) (2 3 5) (2 3 6) (2 4 5) (2 4 6))

MAPC (FUNCTION LIST &REST MORE-LISTS)

Apply FUNCTION to successive elements of lists. Return the second argument.

MAPCAN (FUNCTION LIST &REST MORE-LISTS)

Apply FUNCTION to successive elements of LIST. Return NCONC of FUNCTION results.

MAPCAR (FUNCTION LIST &REST MORE-LISTS)

Apply FUNCTION to successive elements of LIST. Return list of FUNCTION return values.

MAPCON (FUNCTION LIST &REST MORE-LISTS)

Apply FUNCTION to successive CDRs of lists. Return NCONC of results.

MAPHASH (FUNCTION-DESIGNATOR HASH-TABLE)

For each entry in HASH-TABLE, call the designated two-argument function on the key and value of the entry. Return NIL. Consequences are undefined if HASH-TABLE is mutated during the call to MAPHASH, except for changing or removing elements corresponding to the current key. The applies to all threads, not just the current one -- even for synchronized hash-tables. If the table may be mutated by another thread during iteration, use eg. SB-EXT:WITH-LOCKED-HASH-TABLE to protect the MAPHASH call.

MAPHASH-KEYS (FUNCTION TABLE)

Like MAPHASH, but calls FUNCTION with each key in the hash table TABLE.

MAPHASH-VALUES (FUNCTION TABLE)

Like MAPHASH, but calls FUNCTION with each value in the hash table TABLE.

MAPL (FUNCTION LIST &REST MORE-LISTS)

Apply FUNCTION to successive CDRs of list. Return NIL.

MAPLIST (FUNCTION LIST &REST MORE-LISTS)

Apply FUNCTION to successive CDRs of list. Return list of results.

MAPPEND (FUNCTION &REST LISTS)

Applies FUNCTION to respective element(s) of each LIST, appending all the all the result list to a single list. FUNCTION must return a list.

MASK-FIELD (BYTESPEC INTEGER)

Extract the specified byte from integer, but do not right justify result.

MAX (NUMBER &REST MORE-NUMBERS)

Return the greatest of its arguments; among EQUALP greatest, return the first.

MEAN (SAMPLE)

Returns the mean of SAMPLE. SAMPLE must be a sequence of numbers.

MEDIAN (SAMPLE)

Returns median of SAMPLE. SAMPLE must be a sequence of real numbers.

MEMBER (ITEM LIST &KEY KEY (TEST NIL TESTP) (TEST-NOT NIL NOTP))

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)

Return tail of LIST beginning with first element satisfying TEST.

MEMBER-IF-NOT (TEST LIST &KEY KEY)

Return tail of LIST beginning with first element not satisfying TEST.

MERGE (RESULT-TYPE SEQUENCE1 SEQUENCE2 PREDICATE &KEY KEY)

Merge the sequences SEQUENCE1 and SEQUENCE2 destructively into a sequence of type RESULT-TYPE using PREDICATE to order the elements.

MERGE-PATHNAMES (PATHNAME &OPTIONAL (DEFAULTS *DEFAULT-PATHNAME-DEFAULTS*) (DEFAULT-VERSION NEWEST))

Construct a filled in pathname by completing the unspecified components from the defaults.

MIN (NUMBER &REST MORE-NUMBERS)

Return the least of its arguments; among EQUALP least, return the first.

MINUSP (NUMBER)

Is this real number strictly negative?

MISMATCH (SEQUENCE1 SEQUENCE2 &REST ARGS &KEY FROM-END (TEST #'EQL) (TEST-NOT NIL) (START1 0) (END1 NIL) (START2 0) (END2 NIL) (KEY NIL))

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)

Return second result of FLOOR.

MUFFLE-WARNING (&OPTIONAL CONDITION)

Transfer control to a restart named MUFFLE-WARNING, signalling a CONTROL-ERROR if none exists.

MULTIPLE-VALUE-CALL (FUN &REST ARGS)

MULTIPLE-VALUE-CALL function values-form* Call FUNCTION, passing all the values of each VALUES-FORM as arguments, values from the first VALUES-FORM making up the first argument, etc.

MULTIPLE-VALUE-COMPOSE (FUNCTION &REST MORE-FUNCTIONS)

Returns a function composed of FUNCTION and MORE-FUNCTIONS that applies its arguments to each in turn, starting from the rightmost of MORE-FUNCTIONS, and then calling the next one with all the return values of the last.

MULTIPLE-VALUE-PROG1 (VALUES-FORM &REST FORMS)

MULTIPLE-VALUE-PROG1 values-form form* Evaluate VALUES-FORM and then the FORMS, but return all the values of VALUES-FORM.

NAME-CHAR (NAME)

Given an argument acceptable to STRING, NAME-CHAR returns a character whose name is that string, if one exists. Otherwise, NIL is returned.

NAMESTRING (PATHNAME)

Construct the full (name)string form of the pathname.

NCONC (&REST LISTS)

Concatenates the lists given as arguments (by changing them)

NINTERSECTION (LIST1 LIST2 &KEY KEY (TEST #'EQL TESTP) (TEST-NOT NIL NOTP))

Destructively return the intersection of LIST1 and LIST2.

NINTH (LIST)

Return the 9th object in a list or NIL if there is no 9th object.

NOT (OBJECT)

Return T if X is NIL, otherwise return NIL.

NOTANY (PRED FIRST-SEQ &REST MORE-SEQS)

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 (PRED FIRST-SEQ &REST MORE-SEQS)

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)

Return (NCONC (NREVERSE X) Y).

NREVERSE (SEQUENCE)

Return a sequence of the same elements in reverse order; the argument is destroyed.

NSET-DIFFERENCE (LIST1 LIST2 &KEY KEY (TEST #'EQL TESTP) (TEST-NOT NIL NOTP))

Destructively return the elements of LIST1 which are not in LIST2.

NSET-EXCLUSIVE-OR (LIST1 LIST2 &KEY KEY (TEST #'EQL TESTP) (TEST-NOT #'EQL NOTP))

Destructively return a list with elements which appear but once in LIST1 and LIST2.

NSUBLIS (ALIST TREE &KEY KEY (TEST #'EQL TESTP) (TEST-NOT #'EQL NOTP))

Substitute from ALIST into TRUE destructively.

NSUBST (NEW OLD TREE &KEY KEY (TEST #'EQL TESTP) (TEST-NOT #'EQL NOTP))

Substitute NEW for subtrees matching OLD.

NSUBST-IF (NEW TEST TREE &KEY KEY)

Substitute NEW for subtrees of TREE for which TEST is true.

NSUBST-IF-NOT (NEW TEST TREE &KEY KEY)

Substitute NEW for subtrees of TREE for which TEST is false.

NSUBSTITUTE (NEW OLD SEQUENCE &REST ARGS &KEY FROM-END (TEST #'EQL) (TEST-NOT NIL) (END NIL) (COUNT NIL) (KEY NIL) (START 0))

Return a sequence of the same kind as SEQUENCE with the same elements except that all elements equal to OLD are replaced with NEW. SEQUENCE may be destructively modified.

NSUBSTITUTE-IF (NEW PREDICATE SEQUENCE &REST ARGS &KEY FROM-END (START 0) (END NIL) (COUNT NIL) (KEY NIL))

Return a sequence of the same kind as SEQUENCE with the same elements except that all elements satisfying PREDICATE are replaced with NEW. SEQUENCE may be destructively modified.

NSUBSTITUTE-IF-NOT (NEW PREDICATE SEQUENCE &REST ARGS &KEY FROM-END (START 0) (END NIL) (COUNT NIL) (KEY NIL))

Return a sequence of the same kind as SEQUENCE with the same elements except that all elements not satisfying PREDICATE are replaced with NEW. SEQUENCE may be destructively modified.

NTH (N LIST)

Return the nth object in a list where the car is the zero-th element.

NTHCDR (N LIST)

Performs the cdr function n times on a list.

NULL (OBJECT)

Return true if OBJECT is a NULL, and NIL otherwise.

NUMBERP (OBJECT)

Return true if OBJECT is a NUMBER, and NIL otherwise.

NUMERATOR (NUMBER)

Return the numerator of NUMBER, which must be rational.

NUNION (LIST1 LIST2 &KEY KEY (TEST #'EQL TESTP) (TEST-NOT NIL NOTP))

Destructively return the union of LIST1 and LIST2.

ODDP (NUMBER)

Is this integer odd?

OF-TYPE (TYPE)

Returns a function of one argument, which returns true when its argument is of TYPE.

OPEN (FILENAME &KEY (DIRECTION INPUT) (ELEMENT-TYPE 'BASE-CHAR) (IF-EXISTS NIL IF-EXISTS-GIVEN) (IF-DOES-NOT-EXIST NIL IF-DOES-NOT-EXIST-GIVEN) (EXTERNAL-FORMAT DEFAULT) &AUX (DIRECTION DIRECTION) (IF-DOES-NOT-EXIST IF-DOES-NOT-EXIST) (IF-EXISTS IF-EXISTS))

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.

PACKAGE-ERROR-PACKAGE (CONDITION)

Return the offending thread that the THREAD-ERROR pertains to.

PAIRLIS (KEYS DATA &OPTIONAL (ALIST 'NIL))

Construct an association list from KEYS and DATA (adding to ALIST).

PARSE-BODY (BODY &KEY DOCUMENTATION WHOLE)

Parses BODY into (values remaining-forms declarations doc-string). Documentation strings are recognized only if DOCUMENTATION is true. Syntax errors in body are signalled and WHOLE is used in the signal arguments when given.

PARSE-INTEGER (STRING &KEY (START 0) END (RADIX 10) JUNK-ALLOWED)

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-ORDINARY-LAMBDA-LIST (LAMBDA-LIST &KEY (NORMALIZE T) ALLOW-SPECIALIZERS (NORMALIZE-OPTIONAL NORMALIZE) (NORMALIZE-KEYWORD NORMALIZE) (NORMALIZE-AUXILARY NORMALIZE))

Parses an ordinary lambda-list, returning as multiple values: 1. Required parameters. 2. Optional parameter specifications, normalized into form: (name init suppliedp) 3. Name of the rest parameter, or NIL. 4. Keyword parameter specifications, normalized into form: ((keyword-name name) init suppliedp) 5. Boolean indicating &ALLOW-OTHER-KEYS presence. 6. &AUX parameter specifications, normalized into form (name init). 7. Existence of &KEY in the lambda-list. Signals a PROGRAM-ERROR is the lambda-list is malformed.

PATHNAME (PATHSPEC)

Convert PATHSPEC (a pathname designator) into a pathname.

PATHNAME-DEVICE (PATHNAME &KEY (CASE LOCAL))

Return PATHNAME's device.

PATHNAME-DIRECTORY (PATHNAME &KEY (CASE LOCAL))

Return PATHNAME's directory.

PATHNAME-HOST (PATHNAME &KEY (CASE LOCAL))

Return PATHNAME's host.

PATHNAME-MATCH-P (IN-PATHNAME IN-WILDNAME)

Pathname matches the wildname template?

PATHNAME-NAME (PATHNAME &KEY (CASE LOCAL))

Return PATHNAME's name.

PATHNAME-TYPE (PATHNAME &KEY (CASE LOCAL))

Return PATHNAME's type.

PATHNAME-VERSION (PATHNAME)

Return PATHNAME's version.

PHASE (NUMBER)

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.

PLIST-ALIST (PLIST)

Returns an association list containing the same keys and values as the property list PLIST in the same order.

PLIST-HASH-TABLE (PLIST &REST HASH-TABLE-INITARGS)

Returns a hash table containing the keys and values of the property list PLIST. Hash table is initialized using the HASH-TABLE-INITARGS.

PLUSP (NUMBER)

Is this real number strictly positive?

PPRINT (OBJECT &OPTIONAL STREAM)

Prettily output OBJECT preceded by a newline.

PPRINT-FILL (STREAM LIST &OPTIONAL (COLON? T) ATSIGN?)

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)

Specify the indentation to use in the current logical block if STREAM (which defaults to *STANDARD-OUTPUT*) 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 (STREAM LIST &OPTIONAL (COLON? T) ATSIGN?)

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-NEWLINE (KIND &OPTIONAL STREAM)

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)

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 (STREAM LIST &OPTIONAL (COLON? T) ATSIGN? TABSIZE)

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)

Output a mostly READable printed representation of OBJECT on the specified STREAM.

PRIN1-TO-STRING (OBJECT)

Return the printed representation of OBJECT as a string with slashification on.

PRINC (OBJECT &OPTIONAL STREAM)

Output an aesthetic but not necessarily READable printed representation of OBJECT on the specified STREAM.

PRINC-TO-STRING (OBJECT)

Return the printed representation of OBJECT as a string with slashification off.

PRINT (OBJECT &OPTIONAL STREAM)

Output a newline, the mostly READable printed representation of OBJECT, and space to the specified STREAM.

PROBE-FILE (PATHSPEC)

Return the truename of PATHSPEC if the truename can be found, or NIL otherwise. See TRUENAME for more information.

PROGN (&REST FORMS)

PROGN form* Evaluates each FORM in order, returning the values of the last form. With no forms, returns NIL.

PROPER-LIST-LENGTH (LIST)

Returns length of LIST, signalling an error if it is not a proper list.

PROPER-LIST-P (OBJECT)

Returns true if OBJECT is a proper list.

PROVIDE (MODULE-NAME)

Adds a new module name to *MODULES* indicating that it has been loaded. Module-name is a string designator

QUOTE (THING)

QUOTE value Return VALUE without evaluating it.

RANDOM-ELT (SEQUENCE &KEY (START 0) END)

Returns a random element from SEQUENCE bounded by START and END. Signals an error if the SEQUENCE is not a proper non-empty sequence, or if END and START are not proper bounding index designators for SEQUENCE.

RASSOC (ITEM ALIST &KEY KEY (TEST NIL TESTP) (TEST-NOT NIL NOTP))

Return the cons in ALIST whose CDR is equal (by a given test or EQL) to the ITEM.

RASSOC-IF (PREDICATE ALIST &KEY KEY)

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)

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.

RASSOC-VALUE (ALIST KEY &KEY (TEST 'EQL))

RASSOC-VALUE is an alist accessor very much like RASSOC, but it can be used with SETF.

RATIONAL (X)

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 (X)

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 (OBJECT)

Return true if OBJECT is a RATIONAL, and NIL otherwise.

RCURRY (FUNCTION &REST ARGUMENTS)

Returns a function that applies the arguments it is called with and ARGUMENTS to FUNCTION.

READ (&OPTIONAL (STREAM *STANDARD-INPUT*) (EOF-ERROR-P T) (EOF-VALUE NIL) (RECURSIVE-P NIL))

Read the next Lisp value from STREAM, and return it.

READ-DELIMITED-LIST (ENDCHAR &OPTIONAL (INPUT-STREAM *STANDARD-INPUT*) RECURSIVE-P)

Read Lisp values from INPUT-STREAM until the next character after a value's representation is ENDCHAR, and return the objects as a list.

READ-FILE-INTO-BYTE-VECTOR (PATHNAME)

Read PATHNAME into a freshly allocated (unsigned-byte 8) vector.

READ-FILE-INTO-STRING (PATHNAME &KEY (BUFFER-SIZE 4096) EXTERNAL-FORMAT)

Return the contents of the file denoted by PATHNAME as a fresh string. The EXTERNAL-FORMAT parameter will be passed directly to WITH-OPEN-FILE unless it's NIL, which means the system default.

READ-FROM-STRING (STRING &OPTIONAL (EOF-ERROR-P T) EOF-VALUE &KEY (START 0) END PRESERVE-WHITESPACE)

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-PRESERVING-WHITESPACE (&OPTIONAL (STREAM *STANDARD-INPUT*) (EOF-ERROR-P T) (EOF-VALUE NIL) (RECURSIVE-P NIL))

Read from STREAM and return the value read, preserving any whitespace that followed the object.

READ-SEQUENCE (SEQ STREAM &KEY (START 0) END)

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.

REALP (OBJECT)

Return true if OBJECT is a REAL, and NIL otherwise.

REALPART (NUMBER)

Extract the real part of a number.

REM (NUMBER DIVISOR)

Return second result of TRUNCATE.

REMHASH (KEY HASH-TABLE)

Remove the entry in HASH-TABLE associated with KEY. Return T if there was such an entry, or NIL if not.

REMOVE (ITEM SEQUENCE &REST ARGS &KEY FROM-END (TEST #'EQL) (TEST-NOT NIL) (START 0) (END NIL) (COUNT NIL) (KEY NIL))

Return a copy of SEQUENCE with elements satisfying the test (default is EQL) with ITEM removed.

REMOVE-DUPLICATES (SEQUENCE &REST ARGS &KEY (TEST #'EQL) (TEST-NOT NIL) (START 0) (END NIL) FROM-END (KEY NIL))

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-FROM-PLIST (PLIST &REST KEYS)

Returns a propery-list with same keys and values as PLIST, except that keys in the list designated by KEYS and values corresponding to them are removed. The returned property-list may share structure with the PLIST, but PLIST is not destructively modified. Keys are compared using EQ.

REMOVE-IF (PREDICATE SEQUENCE &REST ARGS &KEY FROM-END (START 0) (END NIL) (COUNT NIL) (KEY NIL))

Return a copy of sequence with elements satisfying PREDICATE removed.

REMOVE-IF-NOT (PREDICATE SEQUENCE &REST ARGS &KEY FROM-END (START 0) (END NIL) (COUNT NIL) (KEY NIL))

Return a copy of sequence with elements not satisfying PREDICATE removed.

REMPROP (SYMBOL INDICATOR)

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)

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-DESIGNATOR NAME &OPTIONAL (NICKNAMES NIL))

Changes the name and nicknames for a package.

REPLACE (SEQUENCE1 SEQUENCE2 &REST ARGS &KEY (START1 0) (END1 NIL) (START2 0) (END2 NIL))

Destructively modifies SEQUENCE1 by copying successive elements into it from the SEQUENCE2. Elements are copied to the subseqeuence bounded by START1 and END1, from the subsequence bounded by START2 and END2. If these subsequences are not of the same length, then the shorter length determines how many elements are copied.

REQUIRE (MODULE-NAME &OPTIONAL PATHNAMES)

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.

REQUIRED-ARGUMENT (&OPTIONAL NAME)

Signals an error for a missing argument of NAME. Intended for use as an initialization form for structure and class-slots, and a default value for required keyword arguments.

REST (LIST)

Means the same as the cdr of a list.

RESTART-NAME (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

RETURN-FROM (NAME &OPTIONAL VALUE)

RETURN-FROM block-name value-form Evaluate the VALUE-FORM, returning its values from the lexically enclosing block BLOCK-NAME. This is constrained to be used only within the dynamic extent of the block.

REVAPPEND (X Y)

Return (append (reverse x) y).

REVERSE (SEQUENCE)

Return a new sequence containing the same elements but in reverse order.

ROOM (&OPTIONAL (VERBOSITY DEFAULT))

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.

ROTATE (SEQUENCE &OPTIONAL (N 1))

Returns a sequence of the same type as SEQUENCE, with the elements of SEQUENCE rotated by N: N elements are moved from the end of the sequence to the front if N is positive, and -N elements moved from the front to the end if N is negative. SEQUENCE must be a proper sequence. N must be an integer, defaulting to 1. If absolute value of N is greater then the length of the sequence, the results are identical to calling ROTATE with (* (signum n) (mod n (length sequence))). Note: the original sequence may be destructively altered, and result sequence may share structure with it.

ROUND (NUMBER &OPTIONAL (DIVISOR 1))

Rounds number (or number/divisor) to nearest integer. The second returned value is the remainder.

ROW-MAJOR-AREF (ARRAY INDEX)

Return the element of array corressponding to the row-major index. This is SETF'able.

RPLACA (CONS X)

Change the CAR of CONS to X and return the CONS.

RPLACD (CONS X)

Change the CDR of CONS to X and return the CONS.

SBIT (SIMPLE-BIT-ARRAY &REST SUBSCRIPTS)

Return the bit from SIMPLE-BIT-ARRAY at the specified SUBSCRIPTS.

SCALE-FLOAT (F EX)

Return the value (* f (expt (float 2 f) ex)), but with no unnecessary loss of precision or overflow.

SCHAR (STRING INDEX)

SCHAR returns the character object at an indexed position in a string just as CHAR does, except the string must be a simple-string.

SECOND (LIST)

Return the 2nd object in a list or NIL if there is no 2nd object.

SEQUENCE-OF-LENGTH-P (SEQUENCE LENGTH)

Return true if SEQUENCE is a sequence of length LENGTH. Signals an error if SEQUENCE is not a sequence. Returns FALSE for circular lists.

SET (SYMBOL NEW-VALUE)

Set SYMBOL's value cell to NEW-VALUE.

SET-DIFFERENCE (LIST1 LIST2 &KEY KEY (TEST #'EQL TESTP) (TEST-NOT NIL NOTP))

Return the elements of LIST1 which are not in LIST2.

SET-DISPATCH-MACRO-CHARACTER (DISP-CHAR SUB-CHAR FUNCTION &OPTIONAL (RT-DESIGNATOR *READTABLE*))

Cause FUNCTION to be called whenever the reader reads DISP-CHAR followed by SUB-CHAR.

SET-EQUAL (LIST1 LIST2 &KEY (TEST #'EQL) (KEY NIL KEYP))

Returns true if every element of LIST1 matches some element of LIST2 and every element of LIST2 matches some element of LIST1. Otherwise returns false.

SET-EXCLUSIVE-OR (LIST1 LIST2 &KEY KEY (TEST #'EQL TESTP) (TEST-NOT #'EQL NOTP))

Return new list of elements appearing exactly once in LIST1 and LIST2.

SET-MACRO-CHARACTER (CHAR FUNCTION &OPTIONAL (NON-TERMINATINGP NIL) (RT-DESIGNATOR *READTABLE*))

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-SYNTAX-FROM-CHAR (TO-CHAR FROM-CHAR &OPTIONAL (TO-READTABLE *READTABLE*) (FROM-READTABLE NIL))

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.

SETP (OBJECT &KEY (TEST #'EQL) (KEY #'IDENTITY))

Returns true if OBJECT is a list that denotes a set, NIL otherwise. A list denotes a set if each element of the list is unique under KEY and TEST.

SEVENTH (LIST)

Return the 7th object in a list or NIL if there is no 7th object.

SHADOW (SYMBOLS &OPTIONAL (PACKAGE (SANE-PACKAGE)))

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 (SYMBOLS &OPTIONAL (PACKAGE (SANE-PACKAGE)))

Import SYMBOLS into package, disregarding any name conflict. If a symbol of the same name is present, then it is uninterned.

SHORT-SITE-NAME

Return a string with the abbreviated site name, or NIL if not known.

SHUFFLE (SEQUENCE &KEY (START 0) END)

Returns a random permutation of SEQUENCE bounded by START and END. Original sequece may be destructively modified, and share storage with the original one. Signals an error if SEQUENCE is not a proper sequence.

SIGNAL (DATUM &REST ARGUMENTS)

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.

SIGNUM (NUMBER)

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

SIMPLE-BIT-VECTOR-P (OBJECT)

Return true if OBJECT is a SIMPLE-BIT-VECTOR, and NIL otherwise.

SIMPLE-CONDITION-FORMAT-ARGUMENTS (CONDITION)

Return the offending thread that the THREAD-ERROR pertains to.

SIMPLE-CONDITION-FORMAT-CONTROL (CONDITION)

Return the offending thread that the THREAD-ERROR pertains to.

SIMPLE-STRING-P (OBJECT)

Return true if OBJECT is a SIMPLE-STRING, and NIL otherwise.

SIMPLE-VECTOR-P (OBJECT)

Return true if OBJECT is a SIMPLE-VECTOR, and NIL otherwise.

SIN (NUMBER)

Return the sine of NUMBER.

SINH (NUMBER)

Return the hyperbolic sine of NUMBER.

SIXTH (LIST)

Return the 6th object in a list or NIL if there is no 6th object.

SLEEP (SECONDS)

This function causes execution to be suspended for SECONDS. SECONDS may be any non-negative real number.

SOFTWARE-TYPE

Return a string describing the supporting software.

SOFTWARE-VERSION

Return a string describing version of the supporting software, or NIL if not available.

SOME (PRED FIRST-SEQ &REST MORE-SEQS)

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 &REST ARGS &KEY KEY)

Destructively sort SEQUENCE. PREDICATE should return non-NIL if ARG1 is to precede ARG2.

SPECIAL-OPERATOR-P (SYMBOL)

If the symbol globally names a special form, return T, otherwise NIL.

SPLIT-SEQUENCE (DELIMITER SEQUENCE &KEY (START 0) (END NIL) (FROM-END NIL) (COUNT NIL) (REMOVE-EMPTY-SUBSEQS NIL) (TEST #'EQL) (TEST-NOT NIL) (KEY #'IDENTITY))

Return a list of subsequences in seq delimited by delimiter. If :remove-empty-subseqs is NIL, empty subsequences will be included in the result; otherwise they will be discarded. All other keywords work analogously to those for CL:SUBSTITUTE. In particular, the behaviour of :from-end is possibly different from other versions of this function; :from-end values of NIL and T are equivalent unless :count is supplied. The second return value is an index suitable as an argument to CL:SUBSEQ into the sequence indicating where processing stopped.

SPLIT-SEQUENCE-IF (PREDICATE SEQUENCE &KEY (START 0) (END NIL) (FROM-END NIL) (COUNT NIL) (REMOVE-EMPTY-SUBSEQS NIL) (KEY #'IDENTITY))

Return a list of subsequences in seq delimited by items satisfying predicate. If :remove-empty-subseqs is NIL, empty subsequences will be included in the result; otherwise they will be discarded. All other keywords work analogously to those for CL:SUBSTITUTE-IF. In particular, the behaviour of :from-end is possibly different from other versions of this function; :from-end values of NIL and T are equivalent unless :count is supplied. The second return value is an index suitable as an argument to CL:SUBSEQ into the sequence indicating where processing stopped.

SPLIT-SEQUENCE-IF-NOT (PREDICATE SEQUENCE &KEY (COUNT NIL) (REMOVE-EMPTY-SUBSEQS NIL) (FROM-END NIL) (START 0) (END NIL) (KEY #'IDENTITY))

Return a list of subsequences in seq delimited by items satisfying (CL:COMPLEMENT predicate). If :remove-empty-subseqs is NIL, empty subsequences will be included in the result; otherwise they will be discarded. All other keywords work analogously to those for CL:SUBSTITUTE-IF-NOT. In particular, the behaviour of :from-end is possibly different from other versions of this function; :from-end values of NIL and T are equivalent unless :count is supplied. The second return value is an index suitable as an argument to CL:SUBSEQ into the sequence indicating where processing stopped.

SQRT (NUMBER)

Return the square root of NUMBER.

STABLE-SORT (SEQUENCE PREDICATE &REST ARGS &KEY KEY)

Destructively sort SEQUENCE. PREDICATE should return non-NIL if ARG1 is to precede ARG2.

STANDARD-CHAR-P (CHAR)

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-DEVIATION (SAMPLE &KEY (BIASED T))

Standard deviation of SAMPLE. Returns the biased standard deviation if BIASED is true (the default), and the square root of the unbiased estimator for variance if BIASED is false (which is not the same as the unbiased estimator for standard deviation). SAMPLE must be a sequence of numbers.

STARTS-WITH (OBJECT SEQUENCE &KEY (TEST #'EQL) (KEY #'IDENTITY))

Returns true if SEQUENCE is a sequence whose first element is EQL to OBJECT. Returns NIL if the SEQUENCE is not a sequence or is an empty sequence.

STARTS-WITH-SUBSEQ (PREFIX SEQUENCE &REST ARGS &KEY (RETURN-SUFFIX NIL) &ALLOW-OTHER-KEYS)

Test whether the first elements of SEQUENCE are the same (as per TEST) as the elements of PREFIX. If RETURN-SUFFIX is T the functions returns, as a second value, a displaced array pointing to the sequence after PREFIX.

STORE-VALUE (VALUE &OPTIONAL CONDITION)

Transfer control and VALUE to a restart named STORE-VALUE, or return NIL if none exists.

STREAM-ERROR-STREAM (CONDITION)

Return the offending thread that the THREAD-ERROR pertains to.

STRING (X)

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-EQUAL (STRING1 STRING2 &KEY (START1 0) END1 (START2 0) END2)

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 0) END1 (START2 0) END2)

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-LESSP (STRING1 STRING2 &KEY (START1 0) END1 (START2 0) END2)

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 0) END1 (START2 0) END2)

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 0) END1 (START2 0) END2)

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 0) END1 (START2 0) END2)

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/= (STRING1 STRING2 &KEY (START1 0) END1 (START2 0) END2)

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 0) END1 (START2 0) END2)

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 0) END1 (START2 0) END2)

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 0) END1 (START2 0) END2)

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 0) END1 (START2 0) END2)

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 0) END1 (START2 0) END2)

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 (OBJECT)

Return true if OBJECT is a STRING, and NIL otherwise.

SUBFACTORIAL (N)

Subfactorial of the non-negative integer N.

SUBLIS (ALIST TREE &KEY KEY (TEST #'EQL TESTP) (TEST-NOT #'EQL NOTP))

Substitute from ALIST into TREE nondestructively.

SUBSEQ (SEQUENCE START &OPTIONAL END)

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 #'EQL TESTP) (TEST-NOT NIL NOTP))

Return T if every element in LIST1 is also in LIST2.

SUBST (NEW OLD TREE &KEY KEY (TEST #'EQL TESTP) (TEST-NOT #'EQL NOTP))

Substitutes new for subtrees matching old.

SUBST-IF (NEW TEST TREE &KEY KEY)

Substitutes new for subtrees for which test is true.

SUBST-IF-NOT (NEW TEST TREE &KEY KEY)

Substitutes new for subtrees for which test is false.

SUBSTITUTE (NEW OLD SEQUENCE &REST ARGS &KEY FROM-END (TEST #'EQL) (TEST-NOT NIL) (START 0) (COUNT NIL) (END NIL) (KEY NIL))

Return a sequence of the same kind as SEQUENCE with the same elements, except that all elements equal to OLD are replaced with NEW.

SUBSTITUTE-IF (NEW PREDICATE SEQUENCE &REST ARGS &KEY FROM-END (START 0) (END NIL) (COUNT NIL) (KEY NIL))

Return a sequence of the same kind as SEQUENCE with the same elements except that all elements satisfying the PRED are replaced with NEW.

SUBSTITUTE-IF-NOT (NEW PREDICATE SEQUENCE &REST ARGS &KEY FROM-END (START 0) (END NIL) (COUNT NIL) (KEY NIL))

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.

SUBTYPEP (TYPE1 TYPE2 &OPTIONAL ENVIRONMENT)

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 (SIMPLE-VECTOR INDEX)

Return the INDEX'th element of the given Simple-Vector.

SYMBOL-FUNCTION (SYMBOL)

Return SYMBOL's current function definition. Settable with SETF.

SYMBOL-MACROLET (MACROBINDINGS &BODY BODY)

SYMBOL-MACROLET ({(name expansion)}*) decl* form* Define the NAMES as symbol macros with the given EXPANSIONS. Within the body, references to a NAME will effectively be replaced with the EXPANSION.

SYMBOL-NAME (SYMBOL)

Return SYMBOL's name as a string.

SYMBOL-PACKAGE (SYMBOL)

Return the package SYMBOL was interned in, or NIL if none.

SYMBOL-PLIST (SYMBOL)

Return SYMBOL's property list.

SYMBOL-VALUE (SYMBOL)

Return SYMBOL's current bound value.

SYMBOLICATE (&REST THINGS)

Concatenate together the names of some strings and symbols, producing a symbol in the current package.

SYMBOLP (OBJECT)

Return true if OBJECT is a SYMBOL, and NIL otherwise.

SYNONYM-STREAM-SYMBOL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

TAGBODY (&REST STATEMENTS)

TAGBODY {tag | statement}* Define tags for use with GO. The STATEMENTS are evaluated in order, skipping TAGS, and NIL is returned. If a statement contains a GO to a defined TAG within the lexical scope of the form, then control is transferred to the next statement following that tag. A TAG must be an integer or a symbol. A STATEMENT must be a list. Other objects are illegal within the body.

TAILP (OBJECT LIST)

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 (NUMBER)

Return the tangent of NUMBER.

TANH (NUMBER)

Return the hyperbolic tangent of NUMBER.

TENTH (LIST)

Return the 10th object in a list or NIL if there is no 10th object.

THE (VALUE-TYPE FORM)

Specifies that the values returned by FORM conform to the VALUE-TYPE. CLHS specifies that the consequences are undefined if any result is not of the declared type, but SBCL treats declarations as assertions as long as SAFETY is at least 2, in which case incorrect type information will result in a runtime type-error instead of leading to eg. heap corruption. This is however expressly non-portable: use CHECK-TYPE instead of THE to catch type-errors at runtime. THE is best considered an optimization tool to inform the compiler about types it is unable to derive from other declared types.

THIRD (LIST)

Return the 3rd object in a list or NIL if there is no 3rd object.

THROW (TAG RESULT)

THROW tag form Do a non-local exit, return the values of FORM from the CATCH whose tag is EQ to TAG.

TRANSLATE-LOGICAL-PATHNAME (PATHNAME &KEY)

Translate PATHNAME to a physical pathname, which is returned.

TRANSLATE-PATHNAME (SOURCE FROM-WILDNAME TO-WILDNAME &KEY)

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 #'EQL TESTP) (TEST-NOT NIL NOTP))

Return T if X and Y are isomorphic trees with identical leaves.

TRUENAME (PATHSPEC)

If PATHSPEC is a pathname that names an existing file, return a pathname that denotes a canonicalized name for the file. If pathspec is a stream associated with a file, return a pathname that denotes a canonicalized name for the file associated with the stream. An error of type FILE-ERROR is signalled if no such file exists or if the file system is such that a canonicalized file name cannot be determined or if the pathname is wild. Under Unix, the TRUENAME of a symlink that links to itself or to a file that doesn't exist is considered to be the name of the broken symlink itself.

TRUNCATE (NUMBER &OPTIONAL (DIVISOR 1))

Return number (or number/divisor) as an integer, rounded toward 0. The second returned value is the remainder.

TWO-WAY-STREAM-INPUT-STREAM (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

TWO-WAY-STREAM-OUTPUT-STREAM (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

TYPE-ERROR-DATUM (CONDITION)

Return the offending thread that the THREAD-ERROR pertains to.

TYPE-ERROR-EXPECTED-TYPE (CONDITION)

Return the offending thread that the THREAD-ERROR pertains to.

TYPE-OF (OBJECT)

Return the type of OBJECT.

TYPE= (TYPE1 TYPE2)

Returns a primary value of T is TYPE1 and TYPE2 are the same type, and a secondary value that is true is the type equality could be reliably determined: primary value of NIL and secondary value of T indicates that the types are not equivalent.

TYPEP (OBJECT TYPE &OPTIONAL ENVIRONMENT)

Is OBJECT of type TYPE?

UNBOUND-SLOT-INSTANCE (CONDITION)

Return the offending thread that the THREAD-ERROR pertains to.

UNEXPORT (SYMBOLS &OPTIONAL (PACKAGE (SANE-PACKAGE)))

Makes SYMBOLS no longer exported from PACKAGE.

UNINTERN (SYMBOL &OPTIONAL (PACKAGE (SANE-PACKAGE)))

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 #'EQL TESTP) (TEST-NOT NIL NOTP))

Return the union of LIST1 and LIST2.

UNUSE-PACKAGE (PACKAGES-TO-UNUSE &OPTIONAL (PACKAGE (SANE-PACKAGE)))

Remove PACKAGES-TO-UNUSE from the USE list for PACKAGE.

UNWIND-PROTECT (PROTECTED &BODY CLEANUP)

UNWIND-PROTECT protected cleanup* Evaluate the form PROTECTED, returning its values. The CLEANUP forms are evaluated whenever the dynamic scope of the PROTECTED form is exited (either due to normal completion or a non-local exit such as THROW).

UPGRADED-ARRAY-ELEMENT-TYPE (SPEC &OPTIONAL ENVIRONMENT)

Return the element type that will actually be used to implement an array with the specifier :ELEMENT-TYPE Spec.

UPGRADED-COMPLEX-PART-TYPE (SPEC &OPTIONAL ENVIRONMENT)

Return the element type of the most specialized COMPLEX number type that can hold parts of type SPEC.

UPPER-CASE-P (CHAR)

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 (SANE-PACKAGE)))

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)

Transfer control and VALUE to a restart named USE-VALUE, or return NIL if none exists.

USER-HOMEDIR-PATHNAME (&OPTIONAL HOST)

Return the home directory of the user as a pathname. If the HOME environment variable has been specified, the directory it designates is returned; otherwise obtains the home directory from the operating system. HOST argument is ignored by SBCL.

VALUES (&REST VALUES)

Return all arguments, in order, as values.

VALUES-LIST (LIST)

Return all of the elements of LIST, in order, as values.

VARIANCE (SAMPLE &KEY (BIASED T))

Variance of SAMPLE. Returns the biased variance if BIASED is true (the default), and the unbiased estimator of variance if BIASED is false. SAMPLE must be a sequence of numbers.

VECTOR (&REST OBJECTS)

Construct a SIMPLE-VECTOR from the given objects.

VECTOR-POP (ARRAY)

Decrease the fill pointer by 1 and return the element pointed to by the new fill pointer.

VECTOR-PUSH (NEW-EL ARRAY)

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.

VECTORP (OBJECT)

Return true if OBJECT is a VECTOR, and NIL otherwise.

WARN (DATUM &REST ARGUMENTS)

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.

WILD-PATHNAME-P (PATHNAME &OPTIONAL FIELD-KEY)

Predicate for determining whether pathname contains any wildcards.

WRITE (OBJECT &KEY ((STREAM STREAM) *STANDARD-OUTPUT*) ((ESCAPE *PRINT-ESCAPE*) *PRINT-ESCAPE*) ((RADIX *PRINT-RADIX*) *PRINT-RADIX*) ((BASE *PRINT-BASE*) *PRINT-BASE*) ((CIRCLE *PRINT-CIRCLE*) *PRINT-CIRCLE*) ((PRETTY *PRINT-PRETTY*) *PRINT-PRETTY*) ((LEVEL *PRINT-LEVEL*) *PRINT-LEVEL*) ((LENGTH *PRINT-LENGTH*) *PRINT-LENGTH*) ((CASE *PRINT-CASE*) *PRINT-CASE*) ((ARRAY *PRINT-ARRAY*) *PRINT-ARRAY*) ((GENSYM *PRINT-GENSYM*) *PRINT-GENSYM*) ((READABLY *PRINT-READABLY*) *PRINT-READABLY*) ((RIGHT-MARGIN *PRINT-RIGHT-MARGIN*) *PRINT-RIGHT-MARGIN*) ((MISER-WIDTH *PRINT-MISER-WIDTH*) *PRINT-MISER-WIDTH*) ((LINES *PRINT-LINES*) *PRINT-LINES*) ((PPRINT-DISPATCH *PRINT-PPRINT-DISPATCH*) *PRINT-PPRINT-DISPATCH*) ((SUPPRESS-ERRORS *SUPPRESS-PRINT-ERRORS*) *SUPPRESS-PRINT-ERRORS*))

Output OBJECT to the specified stream, defaulting to *STANDARD-OUTPUT*.

WRITE-BYTE-VECTOR-INTO-FILE (BYTES PATHNAME &KEY (IF-EXISTS ERROR) IF-DOES-NOT-EXIST)

Write BYTES to PATHNAME.

WRITE-SEQUENCE (SEQ STREAM &KEY (START 0) (END NIL))

Write the elements of SEQ bounded by START and END to STREAM.

WRITE-STRING-INTO-FILE (STRING PATHNAME &KEY (IF-EXISTS ERROR) IF-DOES-NOT-EXIST EXTERNAL-FORMAT)

Write STRING to PATHNAME. The EXTERNAL-FORMAT parameter will be passed directly to WITH-OPEN-FILE unless it's NIL, which means the system default.

WRITE-TO-STRING (OBJECT &KEY ((ESCAPE *PRINT-ESCAPE*) *PRINT-ESCAPE*) ((RADIX *PRINT-RADIX*) *PRINT-RADIX*) ((BASE *PRINT-BASE*) *PRINT-BASE*) ((CIRCLE *PRINT-CIRCLE*) *PRINT-CIRCLE*) ((PRETTY *PRINT-PRETTY*) *PRINT-PRETTY*) ((LEVEL *PRINT-LEVEL*) *PRINT-LEVEL*) ((LENGTH *PRINT-LENGTH*) *PRINT-LENGTH*) ((CASE *PRINT-CASE*) *PRINT-CASE*) ((ARRAY *PRINT-ARRAY*) *PRINT-ARRAY*) ((GENSYM *PRINT-GENSYM*) *PRINT-GENSYM*) ((READABLY *PRINT-READABLY*) *PRINT-READABLY*) ((RIGHT-MARGIN *PRINT-RIGHT-MARGIN*) *PRINT-RIGHT-MARGIN*) ((MISER-WIDTH *PRINT-MISER-WIDTH*) *PRINT-MISER-WIDTH*) ((LINES *PRINT-LINES*) *PRINT-LINES*) ((PPRINT-DISPATCH *PRINT-PPRINT-DISPATCH*) *PRINT-PPRINT-DISPATCH*) ((SUPPRESS-ERRORS *SUPPRESS-PRINT-ERRORS*) *SUPPRESS-PRINT-ERRORS*))

Return the printed representation of OBJECT as a string.

Y-OR-N-P (&OPTIONAL FORMAT-STRING &REST ARGUMENTS)

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)

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)

Is this number zero?

Undocumented

SETFAREF (NEW-VALUE ARRAY &REST SUBSCRIPTS)

ARRAY-ROW-MAJOR-INDEX (ARRAY &REST SUBSCRIPTS)

SETFBIT (NEW-VALUE BIT-ARRAY &REST SUBSCRIPTS)

BUG (CONTROL &REST ARGS)

BUTLAST (LIST &OPTIONAL (N 1))

SETFCAAAAR (G4 G5)

SETFCAAADR (G6 G7)

SETFCAAAR (G8 G9)

SETFCAADAR (G10 G11)

SETFCAADDR (G12 G13)

SETFCAADR (G14 G15)

SETFCAAR (G16 G17)

SETFCADAAR (G18 G19)

SETFCADADR (G20 G21)

SETFCADAR (G22 G23)

SETFCADDAR (G24 G25)

SETFCADDDR (G26 G27)

SETFCADDR (G28 G29)

SETFCADR (G30 G31)

SETFCAR (G32 G33)

SETFCDAAAR (G34 G35)

SETFCDAADR (G36 G37)

SETFCDAAR (G38 G39)

SETFCDADAR (G40 G41)

SETFCDADDR (G42 G43)

SETFCDADR (G44 G45)

SETFCDAR (G46 G47)

SETFCDDAAR (G48 G49)

SETFCDDADR (G50 G51)

SETFCDDAR (G52 G53)

SETFCDDDAR (G54 G55)

SETFCDDDDR (G56 G57)

SETFCDDDR (G58 G59)

SETFCDDR (G60 G61)

SETFCDR (G62 G63)

CERROR (CONTINUE-STRING DATUM &REST ARGUMENTS)

SETFCHAR (G64 G65 G66)

CLAMP-TIMEOUT (TIMEOUT &OPTIONAL (MIN 0) (MAX MOST-POSITIVE-FIXNUM))

CLASS-OF (X)

CLEAR-INPUT (&OPTIONAL (STREAM *STANDARD-INPUT*))

CLEAR-OUTPUT (&OPTIONAL (STREAM *STANDARD-OUTPUT*))

SETFCOMPILER-MACRO-FUNCTION (FUNCTION NAME &OPTIONAL ENV)

SETFCONCATENATED-STREAM-STREAMS (NEW-VALUE INSTANCE)

COPY-FILE (FROM TO &KEY (IF-TO-EXISTS SUPERSEDE) (ELEMENT-TYPE '(UNSIGNED-BYTE 8)) FINISH-OUTPUT)

COPY-PPRINT-DISPATCH (&OPTIONAL (TABLE *PRINT-PPRINT-DISPATCH*))

COPY-READTABLE (&OPTIONAL (FROM-READTABLE *READTABLE*) TO-READTABLE)

DECODE-TIMEOUT (TIMEOUT)

SETFEIGHTH (G67 G68)

SETFELT (G69 G70 G71)

ENSURE-GENERIC-FUNCTION (FUN-NAME &REST ALL-KEYS &KEY ENVIRONMENT DEFINITION-SOURCE &ALLOW-OTHER-KEYS)

EQL (X Y)

EQUALP (X Y)

SETFFDEFINITION (G72 G73)

SETFFIFTH (G74 G75)

FILE-LENGTH (STREAM)

FILE-POSITION (STREAM &OPTIONAL POSITION)

FILE-STRING-LENGTH (STREAM OBJECT)

SETFFILL-POINTER (G76 G77)

FIND (ITEM SEQUENCE &REST ARGS &KEY FROM-END (START 0) END KEY TEST TEST-NOT)

FIND-CLASS (SYMBOL &OPTIONAL (ERRORP T) ENVIRONMENT)

SETFFIND-CLASS (NEW-VALUE NAME &OPTIONAL ERRORP ENVIRONMENT)

FIND-IF (PREDICATE SEQUENCE &REST ARGS &KEY FROM-END (START 0) END KEY)

FIND-IF-NOT (PREDICATE SEQUENCE &REST ARGS &KEY FROM-END (START 0) END KEY)

FIND-PACKAGE (PACKAGE-DESIGNATOR)

FINISH-OUTPUT (&OPTIONAL (STREAM *STANDARD-OUTPUT*))

SETFFIRST (G78 G79)

FLOAT-DIGITS (F)

FORCE-OUTPUT (&OPTIONAL (STREAM *STANDARD-OUTPUT*))

SETFFOURTH (G80 G81)

FRESH-LINE (&OPTIONAL (STREAM *STANDARD-OUTPUT*))

GET-OUTPUT-STREAM-STRING (STREAM)

SETFGETHASH (NEW-VALUE KEY TABLE &OPTIONAL DEFAULT)

HASH-TABLE-P (OBJECT)

INSPECT (OBJECT)

INVALID-METHOD-ERROR (METHOD FORMAT-CONTROL &REST FORMAT-ARGUMENTS)

JOIN (CONNECTOR &REST STRINGS)

SETFLDB (G82 G83 G84)

LISP-IMPLEMENTATION-TYPE

LISP-IMPLEMENTATION-VERSION

LISTEN (&OPTIONAL (STREAM *STANDARD-INPUT*))

SETFMACRO-FUNCTION (FUNCTION SYMBOL &OPTIONAL ENVIRONMENT)

MAKE-ARRAY (DIMENSIONS &KEY (ELEMENT-TYPE T) (INITIAL-ELEMENT NIL INITIAL-ELEMENT-P) (INITIAL-CONTENTS NIL INITIAL-CONTENTS-P) ADJUSTABLE FILL-POINTER DISPLACED-TO DISPLACED-INDEX-OFFSET)

MAKE-BROADCAST-STREAM (&REST STREAMS)

MAKE-LOAD-FORM-SAVING-SLOTS (OBJECT &KEY (SLOT-NAMES NIL SLOT-NAMES-P) ENVIRONMENT)

MAKE-SYNONYM-STREAM (SYMBOL)

MAP (RESULT-TYPE FUNCTION FIRST-SEQUENCE &REST MORE-SEQUENCES)

MAP-INTO (RESULT-SEQUENCE FUNCTION &REST SEQUENCES)

SETFMASK-FIELD (G85 G86 G87)

METHOD-COMBINATION-ERROR (FORMAT-CONTROL &REST FORMAT-ARGUMENTS)

NBUTLAST (LIST &OPTIONAL (N 1))

NEGATIVE-DOUBLE-FLOAT-P (N)

NEGATIVE-FIXNUM-P (N)

NEGATIVE-FLOAT-P (N)

NEGATIVE-INTEGER-P (N)

NEGATIVE-LONG-FLOAT-P (N)

NEGATIVE-RATIONAL-P (N)

NEGATIVE-REAL-P (N)

NEGATIVE-SHORT-FLOAT-P (N)

NEGATIVE-SINGLE-FLOAT-P (N)

SETFNINTH (G88 G89)

NON-NEGATIVE-DOUBLE-FLOAT-P (N)

NON-NEGATIVE-FIXNUM-P (N)

NON-NEGATIVE-FLOAT-P (N)

NON-NEGATIVE-INTEGER-P (N)

NON-NEGATIVE-LONG-FLOAT-P (N)

NON-NEGATIVE-RATIONAL-P (N)

NON-NEGATIVE-REAL-P (N)

NON-NEGATIVE-SHORT-FLOAT-P (N)

NON-NEGATIVE-SINGLE-FLOAT-P (N)

NON-POSITIVE-DOUBLE-FLOAT-P (N)

NON-POSITIVE-FIXNUM-P (N)

NON-POSITIVE-FLOAT-P (N)

NON-POSITIVE-INTEGER-P (N)

NON-POSITIVE-LONG-FLOAT-P (N)

NON-POSITIVE-RATIONAL-P (N)

NON-POSITIVE-REAL-P (N)

NON-POSITIVE-SHORT-FLOAT-P (N)

NON-POSITIVE-SINGLE-FLOAT-P (N)

NORMALIZE-TIMEOUT (TIMEOUT)

NSTRING-CAPITALIZE (STRING &KEY (START 0) END)

NSTRING-DOWNCASE (STRING &KEY (START 0) END)

NSTRING-UPCASE (STRING &KEY (START 0) END)

SETFNTH (G90 G91 G92)

PACKAGE-NAME (PACKAGE-DESIGNATOR)

PACKAGE-NICKNAMES (PACKAGE-DESIGNATOR)

PACKAGE-SHADOWING-SYMBOLS (PACKAGE-DESIGNATOR)

PACKAGE-USE-LIST (PACKAGE-DESIGNATOR)

PACKAGE-USED-BY-LIST (PACKAGE-DESIGNATOR)

PACKAGEP (OBJECT)

PARSE-NAMESTRING (THING &OPTIONAL HOST (DEFAULTS *DEFAULT-PATHNAME-DEFAULTS*) &KEY (START 0) END JUNK-ALLOWED)

PATHNAMEP (OBJECT)

PEEK-CHAR (&OPTIONAL (PEEK-TYPE NIL) (STREAM *STANDARD-INPUT*) (EOF-ERROR-P T) EOF-VALUE RECURSIVE-P)

POSITION (ITEM SEQUENCE &REST ARGS &KEY FROM-END (START 0) END KEY TEST TEST-NOT)

POSITION-IF (PREDICATE SEQUENCE &REST ARGS &KEY FROM-END (START 0) END KEY)

POSITION-IF-NOT (PREDICATE SEQUENCE &REST ARGS &KEY FROM-END (START 0) END KEY)

POSITIVE-DOUBLE-FLOAT-P (N)

POSITIVE-FIXNUM-P (N)

POSITIVE-FLOAT-P (N)

POSITIVE-INTEGER-P (N)

POSITIVE-LONG-FLOAT-P (N)

POSITIVE-RATIONAL-P (N)

POSITIVE-REAL-P (N)

POSITIVE-SHORT-FLOAT-P (N)

POSITIVE-SINGLE-FLOAT-P (N)

PPRINT-DISPATCH (OBJECT &OPTIONAL (TABLE *PRINT-PPRINT-DISPATCH*))

PROCLAIM (RAW-FORM)

PROGV (VARS VALS &BODY BODY)

RANDOM (ARG &OPTIONAL (STATE *RANDOM-STATE*))

RANDOM-STATE-P (OBJECT)

READ-BYTE (STREAM &OPTIONAL (EOF-ERROR-P T) EOF-VALUE)

READ-CHAR (&OPTIONAL (STREAM *STANDARD-INPUT*) (EOF-ERROR-P T) EOF-VALUE RECURSIVE-P)

READ-CHAR-NO-HANG (&OPTIONAL (STREAM *STANDARD-INPUT*) (EOF-ERROR-P T) EOF-VALUE RECURSIVE-P)

READ-LINE (&OPTIONAL (STREAM *STANDARD-INPUT*) (EOF-ERROR-P T) EOF-VALUE RECURSIVE-P)

READTABLE-CASE (READTABLE)

SETFREADTABLE-CASE (CASE READTABLE)

READTABLEP (OBJECT)

REDUCE (FUNCTION SEQUENCE &REST ARGS &KEY (KEY NIL) FROM-END (START 0) (END NIL) (INITIAL-VALUE NIL IVP))

SETFREST (G93 G94)

SETFROW-MAJOR-AREF (G95 G96 G97)

SETFSBIT (NEW-VALUE BIT-ARRAY &REST SUBSCRIPTS)

SETFSCHAR (G98 G99 G100)

SETFSECOND (G101 G102)

SET-PPRINT-DISPATCH (TYPE FUNCTION &OPTIONAL (PRIORITY 0) (TABLE *PRINT-PPRINT-DISPATCH*))

SETQ (&WHOLE SOURCE &REST THINGS)

SETFSEVENTH (G103 G104)

SIGNAL-OBSOLETE (FUNCTION-NAME REASON TYPE ACTION)

SIMPLE-PARSE-ERROR (MESSAGE &REST ARGS)

SIMPLE-PROGRAM-ERROR (MESSAGE &REST ARGS)

SIMPLE-READER-ERROR (STREAM MESSAGE &REST ARGS)

SIMPLE-STYLE-WARNING (MESSAGE &REST ARGS)

SETFSIXTH (G105 G106)

SLOT-BOUNDP (OBJECT SLOT-NAME)

SLOT-EXISTS-P (OBJECT SLOT-NAME)

SLOT-MAKUNBOUND (OBJECT SLOT-NAME)

SLOT-VALUE (OBJECT SLOT-NAME)

STREAM-EXTERNAL-FORMAT (STREAM)

STREAMP (STREAM)

STRING-CAPITALIZE (STRING &KEY (START 0) END)

STRING-DOWNCASE (STRING &KEY (START 0) END)

STRING-LEFT-TRIM (CHAR-BAG STRING)

STRING-RIGHT-TRIM (CHAR-BAG STRING)

STRING-TRIM (CHAR-BAG STRING)

STRING-UPCASE (STRING &KEY (START 0) END)

SETFSVREF (G107 G108 G109)

SXHASH (X)

SETFSYMBOL-FUNCTION (NEW-VALUE SYMBOL)

SETFSYMBOL-PLIST (G110 G111)

SETFSYMBOL-VALUE (G112 G113)

SETFTENTH (G114 G115)

TERPRI (&OPTIONAL (STREAM *STANDARD-OUTPUT*))

SETFTHIRD (G116 G117)

UNREAD-CHAR (CHARACTER &OPTIONAL (STREAM *STANDARD-INPUT*))

VECTOR-PUSH-EXTEND (NEW-ELEMENT VECTOR &OPTIONAL (MIN-EXTENSION (LET ((LENGTH (LENGTH VECTOR))) (MIN (1+ LENGTH) (- ARRAY-DIMENSION-LIMIT LENGTH)))))

WRITE-BYTE (INTEGER STREAM)

WRITE-CHAR (CHARACTER &OPTIONAL (STREAM *STANDARD-OUTPUT*))

WRITE-LINE (STRING &OPTIONAL (STREAM *STANDARD-OUTPUT*) &KEY (START 0) END)

WRITE-STRING (STRING &OPTIONAL (STREAM *STANDARD-OUTPUT*) &KEY (START 0) END)

Private

Undocumented

FIND-RIGHT-PACKAGE (PACKAGES)

FIND-RIGHT-SYMBOL (NAME &REST PACKAGES)

GET-OLD-READTABLE (SYMBOL)

READ-LITERAL-DISPATCHER (STREAM CHAR ARG)

SAVE-OLD-READTABLE (SYMBOL READTABLE)

SETF-FUNCTION-NAME-P (FUNCTION-NAME)

SPLIT-FROM-END (POSITION-FN SEQUENCE START END COUNT REMOVE-EMPTY-SUBSEQS)

SPLIT-FROM-START (POSITION-FN SEQUENCE START END COUNT REMOVE-EMPTY-SUBSEQS)

SYMBOL-WITH-NAME-OF-LENGTH-ONE (THING)

WRAP-BODY-FOR-RETURN-STAR (BODY &OPTIONAL BLOCK-NAME)

MACRO

Public

APPENDF (PLACE &REST LISTS &ENVIRONMENT ENV)

Modify-macro for APPEND. Appends LISTS to the place designated by the first argument.

ASSERT (TEST-FORM &OPTIONAL PLACES DATUM &REST ARGUMENTS)

Signals an error if the value of test-form is nil. Continuing from this error using the CONTINUE restart will allow the user to alter the value of some locations known to SETF, starting over with test-form. Returns NIL.

CASE (KEYFORM &BODY CASES)

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.

CCASE (KEYFORM &BODY CASES)

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.

CHECK-TYPE (PLACE TYPE &OPTIONAL TYPE-STRING &ENVIRONMENT ENV)

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.

COERCEF (PLACE TYPE-SPEC &ENVIRONMENT ENV)

Modify-macro for COERCE.

CSWITCH (&WHOLE WHOLE (OBJECT &KEY (TEST 'EQL) (KEY 'IDENTITY)) &BODY CLAUSES)

Like SWITCH, but signals a continuable error if no key matches.

CTYPECASE (KEYFORM &BODY CASES)

CTYPECASE 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 a correctable error is signalled.

DECF (PLACE &OPTIONAL (DELTA 1) &ENVIRONMENT ENV)

The first argument is some location holding a number. This number is decremented by the second argument, DELTA, which defaults to 1.

DECLAIM (&REST SPECS)

DECLAIM Declaration* Do a declaration or declarations for the global environment.

DEFINE-CONDITION (NAME (&REST PARENT-TYPES) (&REST SLOT-SPECS) &BODY OPTIONS)

DEFINE-CONDITION Name (Parent-Type*) (Slot-Spec*) Option* Define NAME as a condition type. This new type inherits slots and its report function from the specified PARENT-TYPEs. A slot spec is a list of: (slot-name :reader <rname> :initarg <iname> {Option Value}* The DEFINE-CLASS slot options :ALLOCATION, :INITFORM, [slot] :DOCUMENTATION and :TYPE and the overall options :DEFAULT-INITARGS and [type] :DOCUMENTATION are also allowed. The :REPORT option is peculiar to DEFINE-CONDITION. Its argument is either a string or a two-argument lambda or function name. If a function, the function is called with the condition and stream to report the condition. If a string, the string is printed. Condition types are classes, but (as allowed by ANSI and not as described in CLtL2) are neither STANDARD-OBJECTs nor STRUCTURE-OBJECTs. WITH-SLOTS and SLOT-VALUE may not be used on condition objects.

DEFINE-CONSTANT (NAME INITIAL-VALUE &KEY (TEST ''EQL) DOCUMENTATION)

Ensures that the global variable named by NAME is a constant with a value that is equal under TEST to the result of evaluating INITIAL-VALUE. TEST is a /function designator/ that defaults to EQL. If DOCUMENTATION is given, it becomes the documentation string of the constant. Signals an error if NAME is already a bound non-constant variable. Signals an error if NAME is already a constant variable whose value is not equal under TEST to result of evaluating INITIAL-VALUE.

DEFINE-MODIFY-MACRO (NAME LAMBDA-LIST FUNCTION &OPTIONAL DOC-STRING)

Creates a new read-modify-write macro like PUSH or INCF.

DEFINE-SETF-EXPANDER (ACCESS-FN LAMBDA-LIST &BODY BODY)

Syntax like DEFMACRO, but creates a setf expander function. The body of the definition must be a form that returns five appropriate values.

DEFOBSOLETE (FUNCTION-NAME REASON &KEY (TYPE function) (ACTION WARN))

Declare the function denoted by FUNCTION-NAME as obsolete. REASON must either be a string or the name of a function to be used as alternative. ACTION chooses the function used to signal the deprecation warning: if :WARN then CL:WARN will be used, if :ERROR then CL:ERROR.

DEFPACKAGE (PACKAGE &REST OPTIONS)

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 VAL &OPTIONAL (DOC NIL DOCP))

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)

Associates a SETF update function or macro with the specified access function or macro. The format is complex. See the manual for details.

DEFSTRUCT (NAME-AND-OPTIONS &REST SLOT-DESCRIPTIONS)

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 (&WHOLE FORM NAME LAMBDA-LIST &BODY BODY)

Define a new type, with syntax like DEFMACRO.

DEFVAR (VAR &OPTIONAL (VAL NIL VALP) (DOC NIL DOCP))

Define a special 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-FROM-PLISTF (PLACE &REST KEYS &ENVIRONMENT ENV)

Modify macro for DELETE-FROM-PLIST.

DELETEF (PLACE ITEM &REST REMOVE-KEYWORDS &ENVIRONMENT ENV)

Modify-macro for DELETE. Sets place designated by the first argument to the result of calling DELETE with ITEM, place, and the REMOVE-KEYWORDS.

DESTRUCTURING-BIND (LAMBDA-LIST EXPRESSION &BODY BODY)

Bind the variables in LAMBDA-LIST to the corresponding values in the tree structure resulting from the evaluation of EXPRESSION.

DESTRUCTURING-CASE (KEYFORM &BODY CLAUSES)

DESTRUCTURING-CASE, -CCASE, and -ECASE are a combination of CASE and DESTRUCTURING-BIND. KEYFORM must evaluate to a CONS. Clauses are of the form: ((CASE-KEYS . DESTRUCTURING-LAMBDA-LIST) FORM*) The clause whose CASE-KEYS matches CAR of KEY, as if by CASE, CCASE, or ECASE, is selected, and FORMs are then executed with CDR of KEY is destructured and bound by the DESTRUCTURING-LAMBDA-LIST. Example: (defun dcase (x) (destructuring-case x ((:foo a b) (format nil "foo: ~S, ~S" a b)) ((:bar &key a b) (format nil "bar, ~S, ~S" a b)) (((:alt1 :alt2) a) (format nil "alt: ~S" a)) ((t &rest rest) (format nil "unknown: ~S" rest)))) (dcase (list :foo 1 2)) ; => "foo: 1, 2" (dcase (list :bar :a 1 :b 2)) ; => "bar: 1, 2" (dcase (list :alt1 1)) ; => "alt: 1" (dcase (list :alt2 2)) ; => "alt: 2" (dcase (list :quux 1 2 3)) ; => "unknown: 1, 2, 3" (defun decase (x) (destructuring-case x ((:foo a b) (format nil "foo: ~S, ~S" a b)) ((:bar &key a b) (format nil "bar, ~S, ~S" a b)) (((:alt1 :alt2) a) (format nil "alt: ~S" a)))) (decase (list :foo 1 2)) ; => "foo: 1, 2" (decase (list :bar :a 1 :b 2)) ; => "bar: 1, 2" (decase (list :alt1 1)) ; => "alt: 1" (decase (list :alt2 2)) ; => "alt: 2" (decase (list :quux 1 2 3)) ; =| error

DESTRUCTURING-CCASE (KEYFORM &BODY CLAUSES)

DESTRUCTURING-CASE, -CCASE, and -ECASE are a combination of CASE and DESTRUCTURING-BIND. KEYFORM must evaluate to a CONS. Clauses are of the form: ((CASE-KEYS . DESTRUCTURING-LAMBDA-LIST) FORM*) The clause whose CASE-KEYS matches CAR of KEY, as if by CASE, CCASE, or ECASE, is selected, and FORMs are then executed with CDR of KEY is destructured and bound by the DESTRUCTURING-LAMBDA-LIST. Example: (defun dcase (x) (destructuring-case x ((:foo a b) (format nil "foo: ~S, ~S" a b)) ((:bar &key a b) (format nil "bar, ~S, ~S" a b)) (((:alt1 :alt2) a) (format nil "alt: ~S" a)) ((t &rest rest) (format nil "unknown: ~S" rest)))) (dcase (list :foo 1 2)) ; => "foo: 1, 2" (dcase (list :bar :a 1 :b 2)) ; => "bar: 1, 2" (dcase (list :alt1 1)) ; => "alt: 1" (dcase (list :alt2 2)) ; => "alt: 2" (dcase (list :quux 1 2 3)) ; => "unknown: 1, 2, 3" (defun decase (x) (destructuring-case x ((:foo a b) (format nil "foo: ~S, ~S" a b)) ((:bar &key a b) (format nil "bar, ~S, ~S" a b)) (((:alt1 :alt2) a) (format nil "alt: ~S" a)))) (decase (list :foo 1 2)) ; => "foo: 1, 2" (decase (list :bar :a 1 :b 2)) ; => "bar: 1, 2" (decase (list :alt1 1)) ; => "alt: 1" (decase (list :alt2 2)) ; => "alt: 2" (decase (list :quux 1 2 3)) ; =| error

DESTRUCTURING-ECASE (KEYFORM &BODY CLAUSES)

DESTRUCTURING-CASE, -CCASE, and -ECASE are a combination of CASE and DESTRUCTURING-BIND. KEYFORM must evaluate to a CONS. Clauses are of the form: ((CASE-KEYS . DESTRUCTURING-LAMBDA-LIST) FORM*) The clause whose CASE-KEYS matches CAR of KEY, as if by CASE, CCASE, or ECASE, is selected, and FORMs are then executed with CDR of KEY is destructured and bound by the DESTRUCTURING-LAMBDA-LIST. Example: (defun dcase (x) (destructuring-case x ((:foo a b) (format nil "foo: ~S, ~S" a b)) ((:bar &key a b) (format nil "bar, ~S, ~S" a b)) (((:alt1 :alt2) a) (format nil "alt: ~S" a)) ((t &rest rest) (format nil "unknown: ~S" rest)))) (dcase (list :foo 1 2)) ; => "foo: 1, 2" (dcase (list :bar :a 1 :b 2)) ; => "bar: 1, 2" (dcase (list :alt1 1)) ; => "alt: 1" (dcase (list :alt2 2)) ; => "alt: 2" (dcase (list :quux 1 2 3)) ; => "unknown: 1, 2, 3" (defun decase (x) (destructuring-case x ((:foo a b) (format nil "foo: ~S, ~S" a b)) ((:bar &key a b) (format nil "bar, ~S, ~S" a b)) (((:alt1 :alt2) a) (format nil "alt: ~S" a)))) (decase (list :foo 1 2)) ; => "foo: 1, 2" (decase (list :bar :a 1 :b 2)) ; => "bar: 1, 2" (decase (list :alt1 1)) ; => "alt: 1" (decase (list :alt2 2)) ; => "alt: 2" (decase (list :quux 1 2 3)) ; =| error

DO (VARLIST ENDLIST &BODY BODY)

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* (VARLIST ENDLIST &BODY BODY)

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 RESULT-FORM) &BODY BODY-DECLS)

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 (PACKAGE '*PACKAGE*) RESULT-FORM) &BODY BODY-DECLS)

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 (PACKAGE '*PACKAGE*) RESULT-FORM) &BODY BODY-DECLS)

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.

DOPLIST ((KEY VAL PLIST &OPTIONAL VALUES) &BODY BODY)

Iterates over elements of PLIST. BODY can be preceded by declarations, and is like a TAGBODY. RETURN may be used to terminate the iteration early. If RETURN is not used, returns VALUES.

ECASE (KEYFORM &BODY CASES)

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.

ENSURE-FUNCTIONF (&REST PLACES)

Multiple-place modify macro for ENSURE-FUNCTION: ensures that each of PLACES contains a function.

ENSURE-GETHASH (KEY HASH-TABLE &OPTIONAL DEFAULT)

Like GETHASH, but if KEY is not found in the HASH-TABLE saves the DEFAULT under key before returning it. Secondary return value is true if key was already in the table.

ESWITCH (&WHOLE WHOLE (OBJECT &KEY (TEST 'EQL) (KEY 'IDENTITY)) &BODY CLAUSES)

Like SWITCH, but signals an error if no key matches.

ETYPECASE (KEYFORM &BODY CASES)

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.

HANDLER-BIND (BINDINGS &BODY FORMS)

(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 CASES)

(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.

IF-LET (BINDINGS &BODY (THEN-FORM &OPTIONAL ELSE-FORM))

Creates new variable bindings, and conditionally executes either THEN-FORM or ELSE-FORM. ELSE-FORM defaults to NIL. BINDINGS must be either single binding of the form: (variable initial-form) or a list of bindings of the form: ((variable-1 initial-form-1) (variable-2 initial-form-2) ... (variable-n initial-form-n)) All initial-forms are executed sequentially in the specified order. Then all the variables are bound to the corresponding values. If all variables were bound to true values, the THEN-FORM is executed with the bindings in effect, otherwise the ELSE-FORM is executed with the bindings in effect.

IGNORE-ERRORS (&REST FORMS)

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.

IGNORE-SOME-CONDITIONS ((&REST CONDITIONS) &BODY BODY)

Similar to CL:IGNORE-ERRORS but the (unevaluated) CONDITIONS list determines which specific conditions are to be ignored.

INCF (PLACE &OPTIONAL (DELTA 1) &ENVIRONMENT ENV)

The first argument is some location holding a number. This number is incremented by the second argument, DELTA, which defaults to 1.

LOOP-FINISH

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.

MAXF (PLACE &REST NUMBERS &ENVIRONMENT ENV)

Modify-macro for MAX. Sets place designated by the first argument to the maximum of its original value and NUMBERS.

MINF (PLACE &REST NUMBERS &ENVIRONMENT ENV)

Modify-macro for MIN. Sets place designated by the first argument to the minimum of its original value and NUMBERS.

MULTIPLE-VALUE-PROG2 (FIRST-FORM SECOND-FORM &BODY FORMS)

Evaluates FIRST-FORM, then SECOND-FORM, and then FORMS. Yields as its value all the value returned by SECOND-FORM.

NAMED-LAMBDA (NAME LAMBDA-LIST &BODY BODY)

Expands into a lambda-expression within whose BODY NAME denotes the corresponding function.

NCONCF (PLACE &REST LISTS &ENVIRONMENT ENV)

Modify-macro for NCONC. Concatenates LISTS to place designated by the first argument.

NREVERSEF (PLACE &ENVIRONMENT ENV)

Modify-macro for NREVERSE. Reverses the list stored in the given place by destructively modifying it and saves back the result into the place.

NTH-VALUE (N FORM)

Evaluate FORM and return the Nth value (zero based). This involves no consing when N is a trivial constant integer.

NTH-VALUE-OR (NTH-VALUE &BODY FORMS)

Evaluates FORM arguments one at a time, until the NTH-VALUE returned by one of the forms is true. It then returns all the values returned by evaluating that form. If none of the forms return a true nth value, this form returns NIL.

NUNIONF (PLACE LIST &REST ARGS &ENVIRONMENT ENV)

Modify-macro for NUNION. Saves the union of LIST and the contents of the place designated by the first argument to the designated place. May modify either argument.

ONCE-ONLY (SPECS &BODY FORMS)

Evaluates FORMS with symbols specified in SPECS rebound to temporary variables, ensuring that each initform is evaluated only once. Each of SPECS must either be a symbol naming the variable to be rebound, or of the form: (symbol initform) Bare symbols in SPECS are equivalent to (symbol symbol) Example: (defmacro cons1 (x) (once-only (x) `(cons ,x ,x))) (let ((y 0)) (cons1 (incf y))) => (1 . 1)

POP (PLACE &ENVIRONMENT ENV)

The argument is a location holding a list. Pops one item off the front of the list and returns it.

PPRINT-EXIT-IF-LIST-EXHAUSTED

Cause the closest enclosing use of PPRINT-LOGICAL-BLOCK to return if its list argument is exhausted. Can only be used inside PPRINT-LOGICAL-BLOCK, and only when the LIST argument to PPRINT-LOGICAL-BLOCK is supplied.

PPRINT-LOGICAL-BLOCK ((STREAM-SYMBOL OBJECT &KEY (PREFIX NIL PREFIXP) (PER-LINE-PREFIX NIL PER-LINE-PREFIX-P) (SUFFIX SUFFIXP)) &BODY BODY)

Group some output into a logical block. STREAM-SYMBOL should be either a stream, T (for *TERMINAL-IO*), or NIL (for *STANDARD-OUTPUT*). The printer control variable *PRINT-LEVEL* is automatically handled.

PPRINT-POP

Return the next element from LIST argument to the closest enclosing use of PPRINT-LOGICAL-BLOCK, automatically handling *PRINT-LENGTH* and *PRINT-CIRCLE*. Can only be used inside PPRINT-LOGICAL-BLOCK. If the LIST argument to PPRINT-LOGICAL-BLOCK was NIL, then nothing is popped, but the *PRINT-LENGTH* testing still happens.

PSETF (&REST ARGS &ENVIRONMENT ENV)

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 (&REST PAIRS)

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 (OBJ PLACE &ENVIRONMENT ENV)

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 (OBJ PLACE &REST KEYS &KEY KEY TEST TEST-NOT &ENVIRONMENT ENV)

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.

REMF (PLACE INDICATOR &ENVIRONMENT ENV)

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.

REMOVE-FROM-PLISTF (PLACE &REST KEYS &ENVIRONMENT ENV)

Modify macro for REMOVE-FROM-PLIST.

REMOVEF (PLACE ITEM &REST REMOVE-KEYWORDS &ENVIRONMENT ENV)

Modify-macro for REMOVE. Sets place designated by the first argument to the result of calling REMOVE with ITEM, place, and the REMOVE-KEYWORDS.

RESTART-BIND (BINDINGS &BODY FORMS)

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 (EXPRESSION &BODY CLAUSES &ENVIRONMENT ENV)

(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.

REVERSEF (PLACE &ENVIRONMENT ENV)

Modify-macro for REVERSE. Copies and reverses the list stored in the given place and saves back the result into the place.

ROTATEF (&REST ARGS &ENVIRONMENT ENV)

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.

SETF (&REST ARGS &ENVIRONMENT ENV)

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.

SHIFTF (&WHOLE FORM &REST ARGS &ENVIRONMENT ENV)

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.

STEP (FORM)

The form is evaluated with single stepping enabled. Function calls outside the lexical scope of the form can be stepped into only if the functions in question have been compiled with sufficient DEBUG policy to be at least partially steppable.

SWITCH (&WHOLE WHOLE (OBJECT &KEY (TEST 'EQL) (KEY 'IDENTITY)) &BODY CLAUSES)

Evaluates first matching clause, returning its values, or evaluates and returns the values of DEFAULT if no keys match.

TIME (FORM)

Execute FORM and print timing information on *TRACE-OUTPUT*. On some hardware platforms estimated processor cycle counts are included in this output; this number is slightly inflated, since it includes the pipeline involved in reading the cycle counter -- executing (TIME NIL) a few times will give you an idea of the overhead, and its variance. The cycle counters are also per processor, not per thread: if multiple threads are running on the same processor, the reported counts will include cycles taken up by all threads running on the processor where TIME was executed. Furthermore, if the operating system migrates the thread to another processor between reads of the cycle counter, the results will be completely bogus. Finally, the counter is cycle counter, incremented by the hardware even when the process is halted -- which is to say that cycles pass normally during operations like SLEEP.

TRACE (&REST SPECS)

TRACE {Option Global-Value}* {Name {Option Value}*}* TRACE is a debugging tool that provides information when specified functions are called. In its simplest form: (TRACE NAME-1 NAME-2 ...) The NAMEs are not evaluated. Each may be a symbol, denoting an individual function, or a string, denoting all functions fbound to symbols whose home package is the package with the given name. Options allow modification of the default behavior. Each option is a pair of an option keyword and a value form. Global options are specified before the first name, and affect all functions traced by a given use of TRACE. Options may also be interspersed with function names, in which case they act as local options, only affecting tracing of the immediately preceding function name. Local options override global options. By default, TRACE causes a printout on *TRACE-OUTPUT* each time that one of the named functions is entered or returns. (This is the basic, ANSI Common Lisp behavior of TRACE.) As an SBCL extension, the :REPORT SB-EXT:PROFILE option can be used to instead cause information to be silently recorded to be inspected later using the SB-EXT:PROFILE function. The following options are defined: :REPORT Report-Type If Report-Type is TRACE (the default) then information is reported by printing immediately. If Report-Type is SB-EXT:PROFILE, information is recorded for later summary by calls to SB-EXT:PROFILE. If Report-Type is NIL, then the only effect of the trace is to execute other options (e.g. PRINT or BREAK). :CONDITION Form :CONDITION-AFTER Form :CONDITION-ALL Form If :CONDITION is specified, then TRACE does nothing unless Form evaluates to true at the time of the call. :CONDITION-AFTER is similar, but suppresses the initial printout, and is tested when the function returns. :CONDITION-ALL tries both before and after. This option is not supported with :REPORT PROFILE. :BREAK Form :BREAK-AFTER Form :BREAK-ALL Form If specified, and Form evaluates to true, then the debugger is invoked at the start of the function, at the end of the function, or both, according to the respective option. :PRINT Form :PRINT-AFTER Form :PRINT-ALL Form In addition to the usual printout, the result of evaluating Form is printed at the start of the function, at the end of the function, or both, according to the respective option. Multiple print options cause multiple values to be printed. :WHEREIN Names If specified, Names is a function name or list of names. TRACE does nothing unless a call to one of those functions encloses the call to this function (i.e. it would appear in a backtrace.) Anonymous functions have string names like "DEFUN FOO". This option is not supported with :REPORT PROFILE. :ENCAPSULATE {:DEFAULT | T | NIL} If T, the tracing is done via encapsulation (redefining the function name) rather than by modifying the function. :DEFAULT is the default, and means to use encapsulation for interpreted functions and funcallable instances, breakpoints otherwise. When encapsulation is used, forms are *not* evaluated in the function's lexical environment, but SB-DEBUG:ARG can still be used. :METHODS {T | NIL} If T, any function argument naming a generic function will have its methods traced in addition to the generic function itself. :FUNCTION Function-Form This is a not really an option, but rather another way of specifying what function to trace. The Function-Form is evaluated immediately, and the resulting function is instrumented, i.e. traced or profiled as specified in REPORT. :CONDITION, :BREAK and :PRINT forms are evaluated in a context which mocks up the lexical environment of the called function, so that SB-DEBUG:VAR and SB-DEBUG:ARG can be used. The -AFTER and -ALL forms are evaluated in the null environment.

TYPECASE (KEYFORM &BODY CASES)

TYPECASE Keyform {(Type Form*)}* Evaluates the Forms in the first clause for which TYPEP of Keyform and Type is true.

UNIONF (PLACE LIST &REST ARGS &ENVIRONMENT ENV)

Modify-macro for UNION. Saves the union of LIST and the contents of the place designated by the first argument to the designated place.

UNLESS (TEST &BODY FORMS)

If the first argument is not true, the rest of the forms are evaluated as a PROGN.

UNTRACE (&REST SPECS)

Remove tracing from the specified functions. Untraces all functions when called with no arguments.

UNWIND-PROTECT-CASE ((&OPTIONAL ABORT-FLAG) PROTECTED-FORM &BODY CLAUSES)

Like CL:UNWIND-PROTECT, but you can specify the circumstances that the cleanup CLAUSES are run. clauses ::= (:NORMAL form*)* | (:ABORT form*)* | (:ALWAYS form*)* Clauses can be given in any order, and more than one clause can be given for each circumstance. The clauses whose denoted circumstance occured, are executed in the order the clauses appear. ABORT-FLAG is the name of a variable that will be bound to T in CLAUSES if the PROTECTED-FORM aborted preemptively, and to NIL otherwise. Examples: (unwind-protect-case () (protected-form) (:normal (format t "This is only evaluated if PROTECTED-FORM executed normally.~%")) (:abort (format t "This is only evaluated if PROTECTED-FORM aborted preemptively.~%")) (:always (format t "This is evaluated in either case.~%"))) (unwind-protect-case (aborted-p) (protected-form) (:always (perform-cleanup-if aborted-p)))

WHEN (TEST &BODY FORMS)

If the first argument is true, the rest of the forms are evaluated as a PROGN.

WHEN-LET (BINDINGS &BODY FORMS)

Creates new variable bindings, and conditionally executes FORMS. BINDINGS must be either single binding of the form: (variable initial-form) or a list of bindings of the form: ((variable-1 initial-form-1) (variable-2 initial-form-2) ... (variable-n initial-form-n)) All initial-forms are executed sequentially in the specified order. Then all the variables are bound to the corresponding values. If all variables were bound to true values, then FORMS are executed as an implicit PROGN.

WHEN-LET* (BINDINGS &BODY FORMS)

Creates new variable bindings, and conditionally executes FORMS. BINDINGS must be either single binding of the form: (variable initial-form) or a list of bindings of the form: ((variable-1 initial-form-1) (variable-2 initial-form-2) ... (variable-n initial-form-n)) Each initial-form is executed in turn, and the variable bound to the corresponding value. Initial-form expressions can refer to variables previously bound by the WHEN-LET*. Execution of WHEN-LET* stops immediately if any initial-form evaluates to NIL. If all initial-forms evaluate to true, then FORMS are executed as an implicit PROGN.

WHICHEVER (&REST POSSIBILITIES &ENVIRONMENT ENV)

Evaluates exactly one of POSSIBILITIES, chosen at random.

WITH-COMPILATION-UNIT (OPTIONS &BODY BODY)

Affects compilations that take place within its dynamic extent. It is intended to be eg. wrapped around the compilation of all files in the same system. Following options 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. :POLICY Optimize-Declaration-Form Provides dynamic scoping for global compiler optimization qualities and restrictions, limiting effects of subsequent OPTIMIZE proclamations and calls to SB-EXT:RESTRICT-COMPILER-POLICY to the dynamic scope of BODY. If OVERRIDE is false, specified POLICY is merged with current global policy. If OVERRIDE is true, current global policy, including any restrictions, is discarded in favor of the specified POLICY. Supplying POLICY NIL is equivalent to the option not being supplied at all, ie. dynamic scoping of policy does not take place. This option is an SBCL-specific experimental extension: Interface subject to change. :SOURCE-NAMESTRING Namestring-Form Attaches the value returned by the Namestring-Form to the internal debug-source information as the namestring of the source file. Normally the namestring of the input-file for COMPILE-FILE is used: this option can be used to provide source-file information for functions compiled using COMPILE, or to override the input-file of COMPILE-FILE. If both an outer and an inner WITH-COMPILATION-UNIT provide a SOURCE-NAMESTRING, the inner one takes precedence. Unaffected by :OVERRIDE. This is an SBCL-specific extension. :SOURCE-PLIST Plist-Form Attaches the value returned by the Plist-Form to internal debug-source information of functions compiled in within the dynamic extent of BODY. Primarily for use by development environments, in order to eg. associate function definitions with editor-buffers. Can be accessed using SB-INTROSPECT:DEFINITION-SOURCE-PLIST. If an outer WITH-COMPILATION-UNIT form also provide a SOURCE-PLIST, it is appended to the end of the provided SOURCE-PLIST. Unaffected by :OVERRIDE. This is an SBCL-specific extension. Examples: ;; Prevent proclamations from the file leaking, and restrict ;; SAFETY to 3 -- otherwise uses the current global policy. (with-compilation-unit (:policy '(optimize)) (restrict-compiler-policy 'safety 3) (load "foo.lisp")) ;; Using default policy instead of the current global one, ;; except for DEBUG 3. (with-compilation-unit (:policy '(optimize debug) :override t) (load "foo.lisp")) ;; Same as if :POLICY had not been specified at all: SAFETY 3 ;; proclamation leaks out from WITH-COMPILATION-UNIT. (with-compilation-unit (:policy nil) (declaim (optimize safety)) (load "foo.lisp"))

WITH-CONDITION-RESTARTS (CONDITION-FORM RESTARTS-FORM &BODY BODY)

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-GENSYMS (NAMES &BODY FORMS)

Binds each variable named by a symbol in NAMES to a unique symbol around FORMS. Each of NAMES must either be either a symbol, or of the form: (symbol string-designator) Bare symbols appearing in NAMES are equivalent to: (symbol symbol) The string-designator is used as the argument to GENSYM when constructing the unique symbol the named variable will be bound to.

WITH-HASH-TABLE-ITERATOR ((NAME HASH-TABLE) &BODY BODY)

WITH-HASH-TABLE-ITERATOR ((name hash-table) &body body) Provides a method of manually looping over the elements of a hash-table. NAME 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. Consequences are undefined if HASH-TABLE is mutated during execution of BODY, except for changing or removing elements corresponding to the current key. The applies to all threads, not just the curren one -- even for synchronized hash-tables. If the table may be mutated by another thread during iteration, use eg. SB-EXT:WITH-LOCKED-HASH-TABLE to protect the WITH-HASH-TABLE-ITERATOR for.

WITH-INPUT-FROM-FILE ((STREAM-NAME FILE-NAME &REST ARGS &KEY (DIRECTION NIL DIRECTION-P) &ALLOW-OTHER-KEYS) &BODY BODY)

Evaluate BODY with STREAM-NAME to an input stream on the file FILE-NAME. ARGS is sent as is to the call to OPEN except EXTERNAL-FORMAT, which is only sent to WITH-OPEN-FILE when it's not NIL.

WITH-OUTPUT-TO-FILE ((STREAM-NAME FILE-NAME &REST ARGS &KEY (DIRECTION NIL DIRECTION-P) &ALLOW-OTHER-KEYS) &BODY BODY)

Evaluate BODY with STREAM-NAME to an output stream on the file FILE-NAME. ARGS is sent as is to the call to OPEN except EXTERNAL-FORMAT, which is only sent to WITH-OPEN-FILE when it's not NIL.

WITH-PACKAGE-ITERATOR ((MNAME PACKAGE-LIST &REST SYMBOL-TYPES) &BODY BODY)

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-ARGUMENTS) &BODY FORMS)

(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-STANDARD-IO-SYNTAX (&BODY BODY)

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-PPRINT-DISPATCH* the standard pprint dispatch table *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 SB-EXT:*SUPPRESS-PRINT-ERRORS* NIL

WITH-UNIQUE-NAMES (NAMES &BODY FORMS)

Alias for WITH-GENSYMS.

XOR (&REST DATUMS)

Evaluates its arguments one at a time, from left to right. If more then one argument evaluates to a true value no further DATUMS are evaluated, and NIL is returned as both primary and secondary value. If exactly one argument evaluates to true, its value is returned as the primary value after all the arguments have been evaluated, and T is returned as the secondary value. If no arguments evaluate to true NIL is retuned as primary, and T as secondary value.

Undocumented

AND (&REST FORMS)

CALL-METHOD (&REST ARGS)

CHECK-BOUNDS (SEQUENCE START END)

COND (&REST CLAUSES)

DEBUG-ONLY (&BODY BODY)

DEBUG-ONLY* (&BODY BODY)

DEFCLASS (&ENVIRONMENT ENV NAME DIRECT-SUPERCLASSES DIRECT-SLOTS &REST OPTIONS)

DEFCONSTANT (NAME VALUE &OPTIONAL DOCUMENTATION)

DEFGENERIC (FUN-NAME LAMBDA-LIST &BODY OPTIONS)

DEFINE-COMPILER-MACRO (NAME ARGS &BODY BODY)

DEFINE-LITERAL-READER (NAME (STREAM) &BODY BODY)

DEFINE-METHOD-COMBINATION (&WHOLE FORM &REST ARGS)

DEFINE-SYMBOL-MACRO (NAME EXPANSION)

DEFINE-SYNTAX (NAME &BODY BODY)

DEFMACRO (NAME ARGS &BODY BODY)

DEFMETHOD (NAME ARGS &BODY BODY)

DEFUN (NAME ARGS &BODY BODY)

DISABLE-READER-MACRO (NAME)

DOLIST ((VAR LIST &OPTIONAL (RESULT NIL)) &BODY BODY &ENVIRONMENT ENV)

DOTIMES ((VAR COUNT &OPTIONAL (RESULT NIL)) &BODY BODY)

ENABLE-READER-MACRO (NAME)

FLAGS-CASE (MASK &BODY CLAUSES)

FORMATTER (CONTROL-STRING)

IN-PACKAGE (STRING-DESIGNATOR)

LAMBDA (&WHOLE WHOLE ARGS &BODY BODY)

LAMBDA* (ARGS &BODY BODY)

LOOP (&ENVIRONMENT ENV &REST KEYWORDS-AND-FORMS)

MULTIPLE-VALUE-BIND (VARS VALUE-FORM &BODY BODY)

MULTIPLE-VALUE-CASE ((VALUES &KEY (TEST 'EQL)) &BODY BODY)

MULTIPLE-VALUE-LIST (VALUE-FORM)

MULTIPLE-VALUE-SETQ (VARS VALUE-FORM)

OR (&REST FORMS)

PRODUCTION-ONLY (&BODY BODY)

PRODUCTION-ONLY* (&BODY BODY)

PROG (VARLIST &BODY BODY-DECLS)

PROG* (VARLIST &BODY BODY-DECLS)

PROG1 (RESULT &BODY BODY)

PROG2 (FORM1 RESULT &BODY BODY)

RETURN (&OPTIONAL (VALUE NIL))

SHRINK-VECTOR (STR SIZE)

WITH-ACCESSORS (SLOTS INSTANCE &BODY BODY)

WITH-INPUT-FROM-STRING ((VAR STRING &KEY INDEX START END) &BODY FORMS-DECLS)

WITH-OPEN-FILE ((STREAM FILESPEC &REST OPTIONS) &BODY BODY)

WITH-OPEN-STREAM ((VAR STREAM) &BODY FORMS-DECLS)

WITH-OUTPUT-TO-STRING ((VAR &OPTIONAL STRING &KEY (ELEMENT-TYPE ''CHARACTER)) &BODY FORMS-DECLS)

WITH-SLOTS (SLOTS INSTANCE &BODY BODY)

GENERIC-FUNCTION

Public

CLOSE (STREAM &KEY ABORT)

Close the given STREAM. No more I/O may be performed, but inquiries may still be made. If :ABORT is true, an attempt is made to clean up the side effects of having created the stream.

DOCUMENTATION (SLOTD DOC-TYPE)

Return the documentation string of Doc-Type for X, or NIL if none exists. System doc-types are VARIABLE, FUNCTION, STRUCTURE, TYPE, SETF, and T. Function documentation is stored separately for function names and objects: DEFUN, LAMBDA, &co create function objects with the specified documentation strings. (SETF (DOCUMENTATION NAME 'FUNCTION) STRING) sets the documentation string stored under the specified name, and (SETF (DOCUMENTATION FUNC T) STRING) sets the documentation string stored in the function object. (DOCUMENTATION NAME 'FUNCTION) returns the documentation stored under the function name if any, and falls back on the documentation in the function object if necessary.

INPUT-STREAM-P (STREAM)

Can STREAM perform input operations?

INTERACTIVE-STREAM-P (STREAM)

Is STREAM an interactive stream?

OPEN-STREAM-P (STREAM)

Return true if STREAM is not closed. A default method is provided by class FUNDAMENTAL-STREAM which returns true if CLOSE has not been called on the stream.

OUTPUT-STREAM-P (STREAM)

Can STREAM perform output operations?

STREAM-ADVANCE-TO-COLUMN (STREAM COLUMN)

Write enough blank space so that the next character will be written at the specified column. Returns true if the operation is successful, or NIL if it is not supported for this stream. This is intended for use by by PPRINT and FORMAT ~T. The default method uses STREAM-LINE-COLUMN and repeated calls to STREAM-WRITE-CHAR with a #SPACE character; it returns NIL if STREAM-LINE-COLUMN returns NIL.

STREAM-CLEAR-INPUT (STREAM)

This is like CL:CLEAR-INPUT, but for Gray streams, returning NIL. The default method does nothing.

STREAM-CLEAR-OUTPUT (STREAM)

This is like CL:CLEAR-OUTPUT, but for Gray streams: clear the given output STREAM. The default method does nothing.

STREAM-ELEMENT-TYPE (STREAM)

Return a type specifier for the kind of object returned by the STREAM. The class FUNDAMENTAL-CHARACTER-STREAM provides a default method which returns CHARACTER.

STREAM-FINISH-OUTPUT (STREAM)

Attempts to ensure that all output sent to the Stream has reached its destination, and only then returns false. Implements FINISH-OUTPUT. The default method does nothing.

STREAM-FORCE-OUTPUT (STREAM)

Attempts to force any buffered output to be sent. Implements FORCE-OUTPUT. The default method does nothing.

STREAM-FRESH-LINE (STREAM)

Outputs a new line to the Stream if it is not positioned at the begining of a line. Returns T if it output a new line, nil otherwise. Used by FRESH-LINE. The default method uses STREAM-START-LINE-P and STREAM-TERPRI.

STREAM-LINE-COLUMN (STREAM)

Return the column number where the next character will be written, or NIL if that is not meaningful for this stream. The first column on a line is numbered 0. This function is used in the implementation of PPRINT and the FORMAT ~T directive. For every character output stream class that is defined, a method must be defined for this function, although it is permissible for it to always return NIL.

STREAM-LISTEN (STREAM)

This is used by LISTEN. It returns true or false. The default method uses STREAM-READ-CHAR-NO-HANG and STREAM-UNREAD-CHAR. Most streams should define their own method since it will usually be trivial and will always be more efficient than the default method.

STREAM-PEEK-CHAR (STREAM)

This is used to implement PEEK-CHAR; this corresponds to PEEK-TYPE of NIL. It returns either a character or :EOF. The default method calls STREAM-READ-CHAR and STREAM-UNREAD-CHAR.

STREAM-READ-BYTE (STREAM)

Used by READ-BYTE; returns either an integer, or the symbol :EOF if the stream is at end-of-file.

STREAM-READ-CHAR (STREAM)

Read one character from the stream. Return either a character object, or the symbol :EOF if the stream is at end-of-file. Every subclass of FUNDAMENTAL-CHARACTER-INPUT-STREAM must define a method for this function.

STREAM-READ-CHAR-NO-HANG (STREAM)

This is used to implement READ-CHAR-NO-HANG. It returns either a character, or NIL if no input is currently available, or :EOF if end-of-file is reached. The default method provided by FUNDAMENTAL-CHARACTER-INPUT-STREAM simply calls STREAM-READ-CHAR; this is sufficient for file streams, but interactive streams should define their own method.

STREAM-READ-LINE (STREAM)

This is used by READ-LINE. A string is returned as the first value. The second value is true if the string was terminated by end-of-file instead of the end of a line. The default method uses repeated calls to STREAM-READ-CHAR.

STREAM-START-LINE-P (STREAM)

Is STREAM known to be positioned at the beginning of a line? It is permissible for an implementation to always return NIL. This is used in the implementation of FRESH-LINE. Note that while a value of 0 from STREAM-LINE-COLUMN also indicates the beginning of a line, there are cases where STREAM-START-LINE-P can be meaningfully implemented although STREAM-LINE-COLUMN can't be. For example, for a window using variable-width characters, the column number isn't very meaningful, but the beginning of the line does have a clear meaning. The default method for STREAM-START-LINE-P on class FUNDAMENTAL-CHARACTER-OUTPUT-STREAM uses STREAM-LINE-COLUMN, so if that is defined to return NIL, then a method should be provided for either STREAM-START-LINE-P or STREAM-FRESH-LINE.

STREAM-TERPRI (STREAM)

Writes an end of line, as for TERPRI. Returns NIL. The default method does (STREAM-WRITE-CHAR stream #NEWLINE).

STREAM-UNREAD-CHAR (STREAM CHARACTER)

Un-do the last call to STREAM-READ-CHAR, as in UNREAD-CHAR. Return NIL. Every subclass of FUNDAMENTAL-CHARACTER-INPUT-STREAM must define a method for this function.

STREAM-WRITE-BYTE (STREAM INTEGER)

Implements WRITE-BYTE; writes the integer to the stream and returns the integer as the result.

STREAM-WRITE-CHAR (STREAM CHARACTER)

Write CHARACTER to STREAM and return CHARACTER. Every subclass of FUNDAMENTAL-CHARACTER-OUTPUT-STREAM must have a method defined for this function.

STREAM-WRITE-STRING (STREAM STRING &OPTIONAL START END)

This is used by WRITE-STRING. It writes the string to the stream, optionally delimited by start and end, which default to 0 and NIL. The string argument is returned. The default method provided by FUNDAMENTAL-CHARACTER-OUTPUT-STREAM uses repeated calls to STREAM-WRITE-CHAR.

Undocumented

ADD-METHOD (GENERIC-FUNCTION METHOD)

ALLOCATE-INSTANCE (CLASS &REST INITARGS)

CHANGE-CLASS (INSTANCE NEW-CLASS-NAME &REST INITARGS &ALLOW-OTHER-KEYS)

SETFCLASS-NAME (NEW-VALUE CLASS)

COMPUTE-APPLICABLE-METHODS (GENERIC-FUNCTION ARGUMENTS)

DEPRECATION-WARNING-FUNCTION-NAME (CONDITION)

DEPRECATION-WARNING-REASON (CONDITION)

DEPRECATION-WARNING-TYPE (CONDITION)

DESCRIBE-OBJECT (X STREAM)

DISABLE-READER-MACRO* (NAME)

SETFDOCUMENTATION (NEW-VALUE SLOTD DOC-TYPE)

ENABLE-READER-MACRO* (NAME)

FIND-METHOD (GENERIC-FUNCTION QUALIFIERS SPECIALIZERS &OPTIONAL ERRORP)

FUNCTION-KEYWORDS (METHOD)

INITIALIZE-INSTANCE (INSTANCE &REST INITARGS &KEY ARGUMENT-PRECEDENCE-ORDER (LAMBDA-LIST NIL LAMBDA-LIST-P) (CLOSE-DIR-P NIL) PATH FILE NAME DIRECTORY TERMS READER SUB-READERS OFFSET POSITION POSITIONS (CONVENTION CALLING-CONVENTION) (CALLING-CONVENTION CCONV CALLING-CONVENTION-P) (CCONV CDECL CCONV-P) SEARCH-PATH NAME INITIAL-CONTENTS CONTAINER-TYPE (ROOT *RBT-EMPTY-NODE*) CONTAINER LINES CHAINED-HANDLER URI PROPERTIES SIZE INITIAL-SIZE (TEST 'EQ) (DIMENSIONS 2) (MAX-SIZE 1000) QUERY SEARCHER (CREATE-P NIL) (CREATE-IF-MISSING-P NIL) READERS STARTS TERM INFO TERM-POSITIONS SEGMENT LITERAL-CHAR-CODE-LIMIT &ALLOW-OTHER-KEYS)

MAKE-INSTANCE (CLASS &REST INITARGS &ALLOW-OTHER-KEYS)

MAKE-INSTANCES-OBSOLETE (CLASS)

MAKE-LOAD-FORM (OBJECT &OPTIONAL ENVIRONMENT)

NO-APPLICABLE-METHOD (GENERIC-FUNCTION &REST ARGS)

NO-NEXT-METHOD (GENERIC-FUNCTION METHOD &REST ARGS)

REINITIALIZE-INSTANCE (INSTANCE &REST INITARGS &KEY DIRECT-SUPERCLASSES (LAMBDA-LIST NIL LAMBDA-LIST-P) (ARGUMENT-PRECEDENCE-ORDER NIL APO-P) &ALLOW-OTHER-KEYS)

REMOVE-METHOD (GENERIC-FUNCTION METHOD)

SHARED-INITIALIZE (INSTANCE SLOT-NAMES &REST INITARGS &KEY (METHOD-COMBINATION NIL METHOD-COMBINATION-SUPPLIED-P) (METHOD-CLASS NIL METHOD-CLASS-SUPPLIED-P) DOCUMENTATION DECLARATIONS ARGUMENT-PRECEDENCE-ORDER (LAMBDA-LIST NIL LAMBDA-LIST-P) (NAME NIL NAMEP) SLOT-DEFINITION SLOT-NAME DEFINITION-SOURCE DIRECT-DEFAULT-INITARGS (DIRECT-SLOTS NIL DIRECT-SLOTS-P) (DIRECT-SUPERCLASSES NIL DIRECT-SUPERCLASSES-P) PROTOCOL TYPE FORCE FORCE-NOT (ALLOCATION INSTANCE) ALLOCATION-CLASS QUALIFIERS SPECIALIZERS FUNCTION ((METHOD-CELL METHOD-CELL)) &ALLOW-OTHER-KEYS)

SLOT-MISSING (CLASS INSTANCE SLOT-NAME OPERATION &OPTIONAL NEW-VALUE)

SLOT-UNBOUND (CLASS INSTANCE SLOT-NAME)

STREAM-FILE-POSITION (STREAM)

SETFSTREAM-FILE-POSITION (NEWVAL STREAM)

STREAM-READ-SEQUENCE (STREAM SEQUENCE START END &KEY &ALLOW-OTHER-KEYS)

STREAM-WRITE-SEQUENCE (STREAM SEQUENCE START END &KEY &ALLOW-OTHER-KEYS)

SUBTYPE-ERROR-DATUM (CONDITION)

SUBTYPE-ERROR-EXPECTED-SUPERTYPE (CONDITION)

UNKNOWN-LITERAL-SYNTAX-NAME (CONDITION)

UPDATE-INSTANCE-FOR-DIFFERENT-CLASS (PREVIOUS CURRENT &REST INITARGS)

UPDATE-INSTANCE-FOR-REDEFINED-CLASS (INSTANCE ADDED-SLOTS DISCARDED-SLOTS PROPERTY-LIST &REST INITARGS)

Private

Undocumented

IOLIB-BUG-MESSAGE (CONDITION)

SLOT-ACCESSOR

Public

Undocumented

CLASS-NAME (CLASS)

METHOD-QUALIFIERS (M)

VARIABLE

Public

* (&REST NUMBERS)

the value of the most recent top level EVAL

**

the previous value of *

***

the previous value of **

*BREAK-ON-SIGNALS*

When (TYPEP condition *BREAK-ON-SIGNALS*) is true, then calls to SIGNAL will enter the debugger prior to signalling that condition.

*COMPILE-FILE-PATHNAME*

The defaulted pathname of the file currently being compiled, or NIL if not compiling.

*COMPILE-FILE-TRUENAME*

The TRUENAME of the file currently being compiled, or NIL if not compiling.

*COMPILE-PRINT*

The default for the :PRINT argument to COMPILE-FILE.

*COMPILE-VERBOSE*

The default for the :VERBOSE argument to COMPILE-FILE.

*DEBUG-IO*

interactive debugging stream

*DEBUGGER-HOOK*

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.

*ERROR-OUTPUT*

error output stream

*FEATURES*

a list of symbols that describe features provided by the implementation

*GENSYM-COUNTER*

counter for generating unique GENSYM symbols

*LOAD-PATHNAME*

the defaulted pathname that LOAD is currently loading

*LOAD-PRINT*

the default for the :PRINT argument to LOAD

*LOAD-TRUENAME*

the TRUENAME of the file that LOAD is currently loading

*LOAD-VERBOSE*

the default for the :VERBOSE argument to LOAD

*MACROEXPAND-HOOK*

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.

*MODULES*

This is a list of module names that have been loaded into Lisp so far. It is used by PROVIDE and REQUIRE.

*PACKAGE*

the current package

*PRINT-ARRAY*

Should the contents of arrays be printed?

*PRINT-BASE*

The output base for RATIONALs (including integers).

*PRINT-CASE*

What case should the printer should use default?

*PRINT-CIRCLE*

Should we use #n= and #n# notation to preserve uniqueness in general (and circularity in particular) when printing?

*PRINT-ESCAPE*

Should we print in a reasonably machine-readable way? (possibly overridden by *PRINT-READABLY*)

*PRINT-GENSYM*

Should #: prefixes be used when printing symbols with null SYMBOL-PACKAGE?

*PRINT-LENGTH*

How many elements at any level should be printed before abbreviating with "..."?

*PRINT-LEVEL*

How many levels should be printed before abbreviating with "#"?

*PRINT-LINES*

The maximum number of lines to print per object.

*PRINT-MISER-WIDTH*

If the remaining space between the current column and the right margin is less than this, then print using ``miser-style'' output. Miser style conditional newlines are turned on, and all indentations are turned off. If NIL, never use miser mode.

*PRINT-PPRINT-DISPATCH*

The pprint-dispatch-table that controls how to pretty-print objects.

*PRINT-PRETTY*

Should pretty printing be used?

*PRINT-RADIX*

Should base be verified when printing RATIONALs?

*PRINT-READABLY*

If true, all objects will be printed readably. If readable printing is impossible, an error will be signalled. This overrides the value of *PRINT-ESCAPE*.

*PRINT-RIGHT-MARGIN*

The position of the right margin in ems (for pretty-printing).

*QUERY-IO*

query I/O stream

*READ-BASE*

the radix that Lisp reads numbers in

*READ-EVAL*

If false, then the #. read macro is disabled.

*READ-SUPPRESS*

Suppress most interpreting in the reader when T.

*READTABLE*

Variable bound to current readtable.

*SAFETY-CHECKS*

Enables safety checks throught the IOLib codebase.

*STANDARD-INPUT*

default input stream

*STANDARD-OUTPUT*

default output stream

*TERMINAL-IO*

terminal I/O stream

*TRACE-OUTPUT*

trace output stream

+ (&REST NUMBERS)

the value of the most recent top level READ

++

the previous value of +

+++

the previous value of ++

- (NUMBER &REST MORE-NUMBERS)

the form currently being evaluated

/ (NUMBER &REST MORE-NUMBERS)

a list of all the values returned by the most recent top level EVAL

//

the previous value of /

///

the previous value of //

Undocumented

*DEFAULT-PATHNAME-DEFAULTS*

*RANDOM-STATE*

*READ-DEFAULT-FLOAT-FORMAT*

CLASS

Public

FUNDAMENTAL-BINARY-INPUT-STREAM

a superclass of all Gray input streams whose element-type is a subtype of unsigned-byte or signed-byte

FUNDAMENTAL-BINARY-OUTPUT-STREAM

a superclass of all Gray output streams whose element-type is a subtype of unsigned-byte or signed-byte

FUNDAMENTAL-BINARY-STREAM

a superclass of all Gray streams whose element-type is a subtype of unsigned-byte or signed-byte

FUNDAMENTAL-CHARACTER-INPUT-STREAM

a superclass of all Gray input streams whose element-type is a subtype of character

FUNDAMENTAL-CHARACTER-OUTPUT-STREAM

a superclass of all Gray output streams whose element-type is a subtype of character

FUNDAMENTAL-CHARACTER-STREAM

a superclass of all Gray streams whose element-type is a subtype of character

FUNDAMENTAL-INPUT-STREAM

a superclass of all Gray input streams

FUNDAMENTAL-OUTPUT-STREAM

a superclass of all Gray output streams

FUNDAMENTAL-STREAM

the base class for all Gray streams

PACKAGE

the standard structure for the description of a package

READTABLE

A READTABLE is a data structure that maps characters into syntax types for the Common Lisp expression reader.

Undocumented

ARRAY

BASE-STRING

BIGNUM

BIT-VECTOR

BROADCAST-STREAM

BUILT-IN-CLASS

CHARACTER (OBJECT)

CLASS

COMPLEX (REALPART &OPTIONAL (IMAGPART 0))

CONCATENATED-STREAM

CONS (SE1 SE2)

DOUBLE-FLOAT

ECHO-STREAM

FILE-STREAM

FIXNUM

FLOAT (NUMBER &OPTIONAL (OTHER NIL OTHERP))

FUNCTION (THING)

GENERIC-FUNCTION

HASH-TABLE

INTEGER

LIST (&REST ARGS)

LOGICAL-PATHNAME (PATHSPEC)

METHOD

METHOD-COMBINATION

NULL (OBJECT)

NUMBER

PATHNAME (PATHSPEC)

RANDOM-STATE

RATIO

RATIONAL (X)

REAL

RESTART

SEQUENCE

SIMPLE-ARRAY

SIMPLE-BASE-STRING

SIMPLE-BIT-VECTOR

SIMPLE-STRING

SIMPLE-VECTOR

SINGLE-FLOAT

STANDARD-CLASS

STANDARD-GENERIC-FUNCTION

STANDARD-METHOD

STANDARD-OBJECT

STREAM

STRING (X)

STRING-STREAM

STRUCTURE-CLASS

STRUCTURE-OBJECT

SYMBOL

SYNONYM-STREAM

T

TRIVIAL-GRAY-STREAM-MIXIN

TWO-WAY-STREAM

VECTOR (&REST OBJECTS)

CONDITION

Public

DEPRECATION-WARNING

Warning signaled at compile-time indicating that a certain function has been deprecated.

Undocumented

ARITHMETIC-ERROR

CELL-ERROR

CONDITION

CONTROL-ERROR

DIVISION-BY-ZERO

END-OF-FILE

ERROR (DATUM &REST ARGUMENTS)

FILE-ERROR

FLOATING-POINT-INEXACT

FLOATING-POINT-INVALID-OPERATION

FLOATING-POINT-OVERFLOW

FLOATING-POINT-UNDERFLOW

IOLIB-BUG

PACKAGE-ERROR

PARSE-ERROR

PROGRAM-ERROR

READER-ERROR

SERIOUS-CONDITION

SIMPLE-CONDITION

SIMPLE-ERROR

SIMPLE-PARSE-ERROR (MESSAGE &REST ARGS)

SIMPLE-PROGRAM-ERROR (MESSAGE &REST ARGS)

SIMPLE-READER-ERROR (STREAM MESSAGE &REST ARGS)

SIMPLE-STYLE-WARNING (MESSAGE &REST ARGS)

SIMPLE-TYPE-ERROR

SIMPLE-WARNING

STORAGE-CONDITION

STREAM-ERROR

STYLE-WARNING

SUBTYPE-ERROR

TYPE-ERROR

UNBOUND-SLOT

UNBOUND-VARIABLE

UNDEFINED-FUNCTION

UNKNOWN-LITERAL-SYNTAX

WARNING

CONSTANT

Public

ARRAY-DIMENSION-LIMIT

the exclusive upper bound on any given dimension of an array

ARRAY-RANK-LIMIT

the exclusive upper bound on the rank of an array

ARRAY-TOTAL-SIZE-LIMIT

the exclusive upper bound on the total number of elements in an array

BOOLE-1

Boole function op, makes BOOLE return integer1.

BOOLE-2

Boole function op, makes BOOLE return integer2.

BOOLE-AND

Boole function op, makes BOOLE return logand of integer1 and integer2.

BOOLE-ANDC1

Boole function op, makes BOOLE return logandc1 of integer1 and integer2.

BOOLE-ANDC2

Boole function op, makes BOOLE return logandc2 of integer1 and integer2.

BOOLE-C1

Boole function op, makes BOOLE return complement of integer1.

BOOLE-C2

Boole function op, makes BOOLE return complement of integer2.

BOOLE-CLR

Boole function op, makes BOOLE return 0.

BOOLE-EQV

Boole function op, makes BOOLE return logeqv of integer1 and integer2.

BOOLE-IOR

Boole function op, makes BOOLE return logior of integer1 and integer2.

BOOLE-NAND

Boole function op, makes BOOLE return log nand of integer1 and integer2.

BOOLE-NOR

Boole function op, makes BOOLE return lognor of integer1 and integer2.

BOOLE-ORC1

Boole function op, makes BOOLE return logorc1 of integer1 and integer2.

BOOLE-ORC2

Boole function op, makes BOOLE return logorc2 of integer1 and integer2.

BOOLE-SET

Boole function op, makes BOOLE return -1.

BOOLE-XOR

Boole function op, makes BOOLE return logxor of integer1 and integer2.

CALL-ARGUMENTS-LIMIT

The exclusive upper bound on the number of arguments which may be passed to a function, including &REST args.

CHAR-CODE-LIMIT

the upper exclusive bound on values produced by CHAR-CODE

INTERNAL-TIME-UNITS-PER-SECOND

The number of internal time units that fit into a second. See GET-INTERNAL-REAL-TIME and GET-INTERNAL-RUN-TIME.

LAMBDA-LIST-KEYWORDS

A list of symbols used as lambda list keywords in SBCL.

LAMBDA-PARAMETERS-LIMIT

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.

MOST-NEGATIVE-FIXNUM

the fixnum closest in value to negative infinity

MOST-POSITIVE-FIXNUM

the fixnum closest in value to positive infinity

MULTIPLE-VALUES-LIMIT

The exclusive upper bound on the number of multiple VALUES that you can return.

Undocumented

DOUBLE-FLOAT-EPSILON

DOUBLE-FLOAT-NEGATIVE-EPSILON

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

LONG-FLOAT-EPSILON

LONG-FLOAT-NEGATIVE-EPSILON

MOST-NEGATIVE-DOUBLE-FLOAT

MOST-NEGATIVE-LONG-FLOAT

MOST-NEGATIVE-SHORT-FLOAT

MOST-NEGATIVE-SINGLE-FLOAT

MOST-POSITIVE-DOUBLE-FLOAT

MOST-POSITIVE-LONG-FLOAT

MOST-POSITIVE-SHORT-FLOAT

MOST-POSITIVE-SINGLE-FLOAT

PI

SHORT-FLOAT-EPSILON

SHORT-FLOAT-NEGATIVE-EPSILON

SINGLE-FLOAT-EPSILON

SINGLE-FLOAT-NEGATIVE-EPSILON

T

Private

Undocumented

+READ-LITERAL-DISPATCH-CHAR+

+READ-LITERAL-SUB-CHAR+