EXT:THE-ENVIRONMENT As in Scheme, the macro (ext:the-environment) returns the current lexical environment. This works only in interpreted code and is not compilable!

(ext:eval-env form &OPTIONAL env) evaluates a form in a given lexical environment, just as if the form had been a part of the program that the environment came from.

CLISP compiles to platform-independent byte-code.

Compiler macros are expanded in the compiled code only, and ignored by the interpreter.

Hash tables are externalizable objects.

The declaration (compile) has the effect that the current form is compiled prior to execution. Examples:

 (LOCALLY (DECLARE (compile)) form)

(LET ((x 0))
  (FLET ((inc () (DECLARE (compile)) (INCF x))
         (dec () (DECF x)))
    (VALUES #'inc #'dec)))

The type assertion (THE value-type form) enforces a type check in interpreted code. No type check is done in compiled code. See also the ext:ethe macro.

The initial value of an &AUX variable in a boa lambda list is the value of the corresponding slot's initial form.

(PROCLAIM '(SPECIAL variable)) declarations may not be undone. The same holds for DEFVAR, DEFPARAMETER and DEFCONSTANT declarations.

It is an error if a DEFCONSTANT variable is bound at the moment the DEFCONSTANT is executed, but DEFCONSTANT does not check this.

Constants may not be bound dynamically or lexically.

EVAL-WHEN also accepts the situations (not eval) and (not compile).

The general form of the COMPLEX type specifier is (COMPLEX type-of-real-part type-of-imaginary-part). The type specifier (COMPLEX type) is equivalent to (COMPLEX type type).

The [ANSI CL standard] type specifier (REAL low high) denotes the real numbers between low and high.

DEFTYPE lambda lists are subject to destructuring (nested lambda lists are allowed, as in DEFMACRO) and may contain a &WHOLE marker, but not an &ENVIRONMENT marker.

(ext:type-expand-1 typespec) If typespec is a user-defined type, ext:type-expand-1 will expand it once and return two values: the expansion and T. If typespec is not a user-defined type, then the two values typespec and NIL are returned.

(ext:type-expand typespec) This is similar to (ext:type-expand-1 typespec), but repeatedly expands typespec until it is no longer a user-defined type. A second value of T or NIL is returned as for ext:type-expand-1, indicating whether the original typespec was a user-definedtype.

The possible results of TYPE-OF are:

EQ compares CHARACTERs and FIXNUMs as EQL does. No unnecessary copies are made of CHARACTERs and NUMBERs. Nevertheless, one should use EQL as it is more portable across Common Lisp implementations.

(let ((x y)) (eq x x)) always returns T, regardless of y.

(SETF (SYMBOL-FUNCTION symbol) object) requires object to be either a function, a SYMBOL-FUNCTION return value or a lambda expression. The lambda expression is thereby immediately converted to a function.

Additional places:

&KEY markers in DEFSETF lambda lists are supported, but the corresponding keywords must appear literally in the program text.

(GET-SETF-EXPANSION form &OPTIONAL env), (ext:get-setf-method form &OPTIONAL env), and (ext:get-setf-method-multiple-value form &OPTIONAL env) receive as optional argument the environment necessary for macro expansions. In DEFINE-SETF-EXPANDER and ext:define-setf-method lambda lists, one can specify &ENVIRONMENT and a variable, which will be bound to the environment. This environment should be passed to all calls of GET-SETF-EXPANSION, ext:get-setf-method and ext:get-setf-method-multiple-value. If this is done, even local macros will be interpreted as places correctly.

Attempts to modify read-only data will signal an error. Program text and quoted constants loaded from files are considered read-only data. This check is only performed for strings, not for conses, other kinds of arrays, and user-defined data types.

See also the ext:letf and ext:letf* macros.

(FUNCTION symbol) returns the local function definition established by FLET or LABELS, if it exists, otherwise the global function definition.

(SPECIAL-OPERATOR-P symbol) returns NIL or T. If it returns T, then (SYMBOL-FUNCTION symbol) returns the (useless) special operator handler.

The macro DEFINE-SYMBOL-MACRO establishes SYMBOL-MACROs with global scope (as opposed to SYMBOL-MACROs defined with SYMBOL-MACROLET, which have local scope): (DEFINE-SYMBOL-MACRO symbol expansion).

The function ext:symbol-macro-expand tests for a SYMBOL-MACRO: If symbol is defined as a SYMBOL-MACRO, (ext:symbol-macro-expand symbol) returns two values, T and the expansion, otherwise it returns NIL.

Calling BOUNDP on a symbol defined as a SYMBOL-MACRO returns T.

Calling SYMBOL-VALUE on a symbol defined as a SYMBOL-MACRO returns the value of the expansion. Calling SET on a symbol defined as a SYMBOL-MACRO calls SETF on the expansion.

Calling MAKUNBOUND on a symbol defined as a SYMBOL-MACRO removes the SYMBOL-MACRO definition.

LAMBDA-LIST-KEYWORDS (&OPTIONAL &REST &KEY &ALLOW-OTHER-KEYS &AUX &BODY &WHOLE &ENVIRONMENT)

DEFUN and DEFMACRO are allowed in non-toplevel positions. As an example, consider the old ([CLtL1]) definition of GENSYM:

(let ((gensym-prefix "G")
      (gensym-count 1))
  (defun gensym (&optional (x nil s))
    (when s
      (cond ((stringp x) (setq gensym-prefix x))
            ((integerp x)
             (if (minusp x)
               (error "~S: index ~S is negative" 'gensym x)
               (setq gensym-count x)))
            (t (error "~S: argument ~S of wrong type" 'gensym x))))
    (prog1
      (make-symbol
        (concatenate 'string
          gensym-prefix
          (write-to-string gensym-count :base 10 :radix nil)))
      (incf gensym-count))))

For MAKE-PACKAGE, the default value of the :use argument is ("COMMON-LISP").

MAKE-PACKAGE accepts a keyword argument :case-sensitive. Similarly, DEFPACKAGE accepts an option :case-sensitive. When its value is non-NIL, the package will be case sensitive, i.e., the reader will not case-convert symbol names before looking them up or creating them in this package. The package names are still subject to (READTABLE-CASE *READTABLE*), though.

Byte specifiers are objects of type byte, not INTEGERs.

When a mathematical function may return an exact (rational) or inexact (floating-point) result, it always returns the exact result.

There are four floating point types: SHORT-FLOAT, SINGLE-FLOAT, DOUBLE-FLOAT and LONG-FLOAT:

The single and double float formats are those of the IEEE standard (1981), except that CLISP does not support features like +0, -0, +inf, -inf, gradual underflow, NaN, etc. (Common Lisp does not make use of these features.) This is why *FEATURES* does not contain the :IEEE-FLOATING-POINT keyword.

Long floats have variable mantissa length, which is a multiple of 16 (or 32, depending on the word size of the processor). The default length used when long floats are read is given by the place (ext:long-float-digits). It can be set by (SETF (ext:long-float-digits) nnn), where nnn is a positive integer. E.g., (SETF (ext:long-float-digits) 3322) sets the default precision of long floats to 1000 decimal digits.

Complex numbers can have a real part and an imaginary part of different types. For example, (sqrt -9.0) evaluates to the number #C(0 3.0), which has a real part of exactly 0, not only 0.0 (which would mean "approximately 0").

The type specifier for this is (COMPLEX INTEGER SINGLE-FLOAT), and (COMPLEX type-of-real-part type-of-imaginary-part) in general.

The type specifier (COMPLEX type) is equivalent to (COMPLEX type type).

Complex numbers can have a real part and an imaginary part of different types. If the imaginary part is EQL to 0, the number is automatically converted to a real number.

This has the advantage that (let ((x (sqrt -9.0))) (* x x)) - instead of evaluating to #C(-9.0 0.0), with x = #C(0.0 3.0) - evaluates to #C(-9.0 0) = -9.0, with x = #C(0 3.0).

ext:! (ext:! n) returns the factorial of n, n being a nonnegative INTEGER.

ext:exquo (ext:exquo x y) returns the integer quotient x/y of two integers x,y, and signals an error when the quotient is not integer. (This is more efficient than /.)

ext:xgcd (ext:xgcd x₁ ... x_n) returns the values g, k₁, ..., k_n, where g is the greatest common divisor of the integers x₁, ..., x_n, and k₁, ..., k_n are the integer coefficients such that

 g = (GCD x1 ... xn)
   = (+ (* k1 x1) ... (* kn xn))

EXPT (EXPT base exponent) is not very precise if exponent has large absolute value.

LOG (LOG number base) signals an error if base = 1.

PI The value of PI is a LONG-FLOAT with the precision given by (ext:long-float-digits). When this precision is changed, the value of PI is automatically recomputed. Therefore PI is a variable, not a constant.

FLOAT-RADIX always returns 2.

(FLOAT-DIGITS number digits) coerces number (a real number) to a floating point number with at least digits mantissa digits. The following holds:

 (>= (FLOAT-DIGITS (FLOAT-DIGITS number digits)) digits)

Together with PI, the other long float constants LEAST-NEGATIVE-LONG-FLOAT LEAST-NEGATIVE-NORMALIZED-LONG-FLOAT LEAST-POSITIVE-LONG-FLOAT LEAST-POSITIVE-NORMALIZED-LONG-FLOAT LONG-FLOAT-EPSILON LONG-FLOAT-NEGATIVE-EPSILON MOST-NEGATIVE-LONG-FLOAT MOST-POSITIVE-LONG-FLOAT are recomputed whenever (ext:long-float-digits) is changed. They are variables, not constants.

This condition is never signaled by CLISP.

This condition is never signaled by CLISP.

The function ext:mapcap is like MAPCAN, except that it concatenates the resulting lists with APPEND instead of NCONC:

(ext:mapcap function x₁ ... x_n) == (APPLY #'APPEND (MAPCAR function x₁ ... x_n))

(Actually a bit more efficient that this would be.)

The function ext:maplap is like MAPCON, except that it concatenates the resulting lists with APPEND instead of NCONC:

(ext:maplap function x₁ ... x_n) == (APPLY #'APPEND (MAPLIST function x₁ ... x_n))

(Actually a bit more efficient that this would be.)

(ext:string-width string) returns the number of screen columns occupied by string. This is computed as the sum of all ext:char-widths of all of the string's characters.

For iteration through a sequence, a macro ext:doseq, similar to DOLIST, may be used instead of MAP:

(ext:doseq (variable seqform [resultform])
  {declaration}*
  {tag|statement}*)

ext:doseq forms are “iteration forms”.

NREVERSE The result of NREVERSE is always EQ to the argument. NREVERSE on a VECTOR swaps pairs of elements. NREVERSE on a LIST swaps the first and the last element and reverses the list chaining between them.

NRECONC The result of NRECONC is EQ to the first argument unless it is NIL, in which case the result is EQ to the second argument.

REMOVE, REMOVE-IF, REMOVE-IF-NOT, REMOVE-DUPLICATES return their argument unchanged, if no element has to be removed.

DELETE, DELETE-IF, DELETE-IF-NOT, DELETE-DUPLICATES destructively modify their argument: If the argument is a LIST, the CDR parts are modified. If the argument is a VECTOR with fill pointer, the fill pointer is lowered and the remaining elements are compacted below the new fill pointer.

Contrary to the [ANSI CL standard] issue 283 RANGE-OF-COUNT-KEYWORD:NIL-OR-INTEGER, negative :count keyword arguments are not allowed unless you set custom:*sequence-count-ansi* to a non-NIL value, in hich case “using a negative integer value is functionally equivalent to using a value of zero”, as per the [ANSI CL standard] issue.

SORT and STABLE-SORT have two additional keywords :start and :end:

(SORT sequence predicate &KEY :key :start :end)
(STABLE-SORT sequence predicate &KEY :key :start :end)

SORT and STABLE-SORT are identical. They implement the mergesort algorithm. Worst case complexity: O(n*log(n)) comparisons, where n is the LENGTH of the subsequence bounded by the :start and :end arguments.

MAKE-HASH-TABLE has an additional keyword :initial-contents:

(MAKE-HASH-TABLE &KEY :test :initial-contents :size
                 :rehash-size :rehash-threshold)

The :initial-contents argument is an alist that is used to initialize the new hash table. The :rehash-threshold argument is ignored.

For iteration through a hash table, a macro ext:dohash, similar to DOLIST, can be used instead of MAPHASH:

(ext:dohash (key-var value-var hash-table-form [resultform])
  {declaration}*
  {tag|statement}*)

ext:dohash forms are “iteration forms”.