Previous: Loading, Up: System Construction Concepts

24.1.2 Features

A feature is an aspect or attribute of Common Lisp, of the implementation, or of the environment. A feature is identified by a symbol.

A feature is said to be present in a Lisp image if and only if the symbol naming it is an element of the list held by the variable *features*, which is called the features list.

24.1.2.1 Feature Expressions

Boolean combinations of features, called feature expressions, are used by the #+ and #- reader macros in order to direct conditional reading of expressions by the Lisp reader.

The rules for interpreting a feature expression are as follows:

feature

If a symbol naming a feature is used as a feature expression, the feature expression succeeds if that feature is present; otherwise it fails.

(not feature-conditional)

A not feature expression succeeds if its argument feature-conditional fails; otherwise, it succeeds.

(and {feature-conditional}*)

An and feature expression succeeds if all of its argument feature-conditionals succeed; otherwise, it fails.

(or {feature-conditional}*)

An or feature expression succeeds if any of its argument feature-conditionals succeed; otherwise, it fails.

24.1.2.1.1 Examples of Feature Expressions

For example, suppose that in implementation A, the features spice and perq are present, but the feature lispm is not present; in implementation B, the feature lispm is present, but the features spice and perq are not present; and in implementation C, none of the features spice, lispm, or perq are present. The next figure shows some sample expressions, and how they would be read2 in these implementations.

(cons #+spice "Spice" #-spice "Lispm" x)
in implementation A ... (CONS "Spice" X)
in implementation B ... (CONS "Lispm" X)
in implementation C ... (CONS "Lispm" X)
(cons #+spice "Spice" #+LispM "Lispm" x)
in implementation A ... (CONS "Spice" X)
in implementation B ... (CONS "Lispm" X)
in implementation C ... (CONS X)
(setq a '(1 2 #+perq 43 #+(not perq) 27))
in implementation A ... (SETQ A '(1 2 43))
in implementation B ... (SETQ A '(1 2 27))
in implementation C ... (SETQ A '(1 2 27))
(let ((a 3) #+(or spice lispm) (b 3)) (foo a))
in implementation A ... (LET ((A 3) (B 3)) (FOO A))
in implementation B ... (LET ((A 3) (B 3)) (FOO A))
in implementation C ... (LET ((A 3)) (FOO A))
(cons #+Lispm "#+Spice" #+Spice "foo" #-(or Lispm Spice) 7 x)
in implementation A ... (CONS "foo" X)
in implementation B ... (CONS "#+Spice" X)
in implementation C ... (CONS 7 X)

Figure 24.1: Features examples