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)

executes a compiled version of form.

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

returns two functions. The first is compiled and increments x, the second is interpreted (slower) and decrements the same x.

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