-This is Info file ../info/cl.info, produced by Makeinfo version 1.68
-from the input file cl.texi.
+This is ../info/cl.info, produced by makeinfo version 4.0 from cl.texi.
INFO-DIR-SECTION XEmacs Editor
START-INFO-DIR-ENTRY
This clause type is taken from older versions of the `loop' macro,
and is not present in modern Common Lisp. The `using (sequence
- ...)' term of the older macros is not supported.
+ ...)' term of the older macros is not supported.
`for VAR being the elements of-ref SEQUENCE'
This clause iterates over a sequence, with VAR a `setf'-able
Due to a minor implementation restriction, it will not work to have
more than one `for' clause iterating over symbols, hash tables,
keymaps, overlays, or intervals in a given `loop'. Fortunately,
- it would rarely if ever be useful to do so. It *is* legal to mix
+ it would rarely if ever be useful to do so. It _is_ legal to mix
one of these types of clauses with other clauses like `for ... to'
or `while'.
makes no attempt to emulate Common Lisp multiple return values; Emacs
versions of Common Lisp functions that return more than one value
either return just the first value (as in `compiler-macroexpand') or
-return a list of values (as in `get-setf-method'). This package *does*
+return a list of values (as in `get-setf-method'). This package _does_
define placeholders for the Common Lisp functions that work with
multiple values, but in Emacs Lisp these functions simply operate on
lists instead. The `values' form, for example, is a synonym for `list'
in Emacs.
- - Special Form: multiple-value-bind (VAR...) VALUES-FORM FORMS...
+ - Special Form: multiple-value-bind (var...) values-form forms...
This form evaluates VALUES-FORM, which must return a list of
values. It then binds the VARs to these respective values, as if
by `let', and then executes the body FORMS. If there are more
VARs than values, the extra VARs are bound to `nil'. If there are
fewer VARs than values, the excess values are ignored.
- - Special Form: multiple-value-setq (VAR...) FORM
+ - Special Form: multiple-value-setq (var...) form
This form evaluates FORM, which must return a list of values. It
then sets the VARs to these respective values, as if by `setq'.
Extra VARs or values are treated the same as in
Destructuring is made available to the user by way of the following
macro:
- - Special Form: destructuring-bind ARGLIST EXPR FORMS...
+ - Special Form: destructuring-bind arglist expr forms...
This macro expands to code which executes FORMS, with the
variables in ARGLIST bound to the list of values returned by EXPR.
The ARGLIST can include all the features allowed for `defmacro'
facility, which allows you to define compile-time expansions and
optimizations for your functions.
- - Special Form: define-compiler-macro NAME ARGLIST FORMS...
+ - Special Form: define-compiler-macro name arglist forms...
This form is similar to `defmacro', except that it only expands
calls to NAME at compile-time; calls processed by the Lisp
interpreter are not expanded, nor are they expanded by the
optimizes a number of other cases, including common `:test'
predicates.)
- - Function: compiler-macroexpand FORM
+ - Function: compiler-macroexpand form
This function is analogous to `macroexpand', except that it
expands compiler macros rather than regular macros. It returns
FORM unchanged if it is not a call to a function for which a
Under the earlier non-optimizing compiler, these declarations will
effectively be ignored.
- - Function: proclaim DECL-SPEC
+ - Function: proclaim decl-spec
This function records a "global" declaration specified by
DECL-SPEC. Since `proclaim' is a function, DECL-SPEC is evaluated
and thus should normally be quoted.
- - Special Form: declaim DECL-SPECS...
+ - Special Form: declaim decl-specs...
This macro is like `proclaim', except that it takes any number of
DECL-SPEC arguments, and the arguments are unevaluated and
unquoted. The `declaim' macro also puts an `(eval-when (compile
compiler treats the rest of the file that contains the `declaim'
form.)
- - Special Form: declare DECL-SPECS...
+ - Special Form: declare decl-specs...
This macro is used to make declarations within functions and other
code. Common Lisp allows declarations in various locations,
generally at the beginning of any of the many "implicit `progn's"
etc. Currently the only declaration understood by `declare' is
`special'.
- - Special Form: locally DECLARATIONS... FORMS...
+ - Special Form: locally declarations... forms...
In this package, `locally' is no different from `progn'.
- - Special Form: the TYPE FORM
+ - Special Form: the type form
Type information provided by `the' is ignored in this package; in
other words, `(the TYPE FORM)' is equivalent to FORM. Future
versions of the optimizing byte-compiler may make use of this
(declaim (inline foo bar))
(eval-when (compile load eval) (proclaim '(inline foo bar)))
- (proclaim-inline foo bar) ; XEmacs only
- (defsubst foo (...) ...) ; instead of defun; Emacs 19 only
+ (proclaim-inline foo bar) ; XEmacs only
+ (defsubst foo (...) ...) ; instead of defun; Emacs 19 only
*Please note:* This declaration remains in effect after the
containing source file is done. It is correct to use it to
* Menu:
-* Property Lists:: `get*', `remprop', `getf', `remf'
+* Property Lists:: `getf', `remf'
* Creating Symbols:: `gensym', `gentemp'
\1f
==============
These functions augment the standard Emacs Lisp functions `get' and
-`put' for operating on properties attached to symbols. There are also
+`put' for operating on properties attached to objects. There are also
functions for working with property lists as first-class data
-structures not attached to particular symbols.
-
- - Function: get* SYMBOL PROPERTY &optional DEFAULT
- This function is like `get', except that if the property is not
- found, the DEFAULT argument provides the return value. (The Emacs
- Lisp `get' function always uses `nil' as the default; this
- package's `get*' is equivalent to Common Lisp's `get'.)
-
- The `get*' function is `setf'-able; when used in this fashion, the
- DEFAULT argument is allowed but ignored.
-
- - Function: remprop SYMBOL PROPERTY
- This function removes the entry for PROPERTY from the property
- list of SYMBOL. It returns a true value if the property was
- indeed found and removed, or `nil' if there was no such property.
- (This function was probably omitted from Emacs originally because,
- since `get' did not allow a DEFAULT, it was very difficult to
- distinguish between a missing property and a property whose value
- was `nil'; thus, setting a property to `nil' was close enough to
- `remprop' for most purposes.)
-
- - Function: getf PLACE PROPERTY &optional DEFAULT
+structures not attached to particular objects.
+
+ - Function: getf place property &optional default
This function scans the list PLACE as if it were a property list,
i.e., a list of alternating property names and values. If an
even-numbered element of PLACE is found which is `eq' to PROPERTY,
(put sym prop val) == (setf (getf (symbol-plist sym) prop) val)
- The `get' and `get*' functions are also `setf'-able. The fact
- that `default' is ignored can sometimes be useful:
+ The `get' function is also `setf'-able. The fact that `default'
+ is ignored can sometimes be useful:
- (incf (get* 'foo 'usage-count 0))
+ (incf (get 'foo 'usage-count 0))
Here, symbol `foo''s `usage-count' property is incremented if it
exists, or set to 1 (an incremented 0) otherwise.
When not used as a `setf' form, `getf' is just a regular function
and its PLACE argument can actually be any Lisp expression.
- - Special Form: remf PLACE PROPERTY
+ - Special Form: remf place property
This macro removes the property-value pair for PROPERTY from the
property list stored at PLACE, which is any `setf'-able place
expression. It returns true if the property was found. Note that
These functions create unique symbols, typically for use as temporary
variables.
- - Function: gensym &optional X
+ - Function: gensym &optional x
This function creates a new, uninterned symbol (using
`make-symbol') with a unique name. (The name of an uninterned
symbol is relevant only if the symbol is printed.) By default,
and uninterned symbols, so their names had to be treated more
carefully.
- - Function: gentemp &optional X
+ - Function: gentemp &optional x
This function is like `gensym', except that it produces a new
- *interned* symbol. If the symbol that is generated already
+ _interned_ symbol. If the symbol that is generated already
exists, the function keeps incrementing the counter and trying
again until a new symbol is generated.
These functions return `t' if the specified condition is true of the
numerical argument, or `nil' otherwise.
- - Function: plusp NUMBER
+ - Function: plusp number
This predicate tests whether NUMBER is positive. It is an error
if the argument is not a number.
- - Function: minusp NUMBER
+ - Function: minusp number
This predicate tests whether NUMBER is negative. It is an error
if the argument is not a number.
- - Function: oddp INTEGER
+ - Function: oddp integer
This predicate tests whether INTEGER is odd. It is an error if
the argument is not an integer.
- - Function: evenp INTEGER
+ - Function: evenp integer
This predicate tests whether INTEGER is even. It is an error if
the argument is not an integer.
- - Function: floatp-safe OBJECT
+ - Function: floatp-safe object
This predicate tests whether OBJECT is a floating-point number.
On systems that support floating-point, this is equivalent to
`floatp'. On other systems, this always returns `nil'.
These functions perform various arithmetic operations on numbers.
- - Function: abs NUMBER
+ - Function: abs number
This function returns the absolute value of NUMBER. (Newer
versions of Emacs provide this as a built-in function; this package
defines `abs' only for Emacs 18 versions which don't provide it as
a primitive.)
- - Function: expt BASE POWER
+ - Function: expt base power
This function returns BASE raised to the power of NUMBER. (Newer
versions of Emacs provide this as a built-in function; this
package defines `expt' only for Emacs 18 versions which don't
provide it as a primitive.)
- - Function: gcd &rest INTEGERS
+ - Function: gcd &rest integers
This function returns the Greatest Common Divisor of the arguments.
For one argument, it returns the absolute value of that argument.
For zero arguments, it returns zero.
- - Function: lcm &rest INTEGERS
+ - Function: lcm &rest integers
This function returns the Least Common Multiple of the arguments.
For one argument, it returns the absolute value of that argument.
For zero arguments, it returns one.
- - Function: isqrt INTEGER
+ - Function: isqrt integer
This function computes the "integer square root" of its integer
argument, i.e., the greatest integer less than or equal to the true
square root of the argument.
- - Function: floor* NUMBER &optional DIVISOR
+ - Function: floor* number &optional divisor
This function implements the Common Lisp `floor' function. It is
called `floor*' to avoid name conflicts with the simpler `floor'
function built-in to Emacs 19.
function, except that it returns the two results in a list since
Emacs Lisp does not support multiple-valued functions.
- - Function: ceiling* NUMBER &optional DIVISOR
+ - Function: ceiling* number &optional divisor
This function implements the Common Lisp `ceiling' function, which
is analogous to `floor' except that it rounds the argument or
quotient of the arguments up toward plus infinity. The remainder
will be between 0 and minus R.
- - Function: truncate* NUMBER &optional DIVISOR
+ - Function: truncate* number &optional divisor
This function implements the Common Lisp `truncate' function,
which is analogous to `floor' except that it rounds the argument
or quotient of the arguments toward zero. Thus it is equivalent
to `floor*' if the argument or quotient is positive, or to
`ceiling*' otherwise. The remainder has the same sign as NUMBER.
- - Function: round* NUMBER &optional DIVISOR
+ - Function: round* number &optional divisor
This function implements the Common Lisp `round' function, which
is analogous to `floor' except that it rounds the argument or
quotient of the arguments to the nearest integer. In the case of
a tie (the argument or quotient is exactly halfway between two
integers), it rounds to the even integer.
- - Function: mod* NUMBER DIVISOR
+ - Function: mod* number divisor
This function returns the same value as the second return value of
`floor'.
- - Function: rem* NUMBER DIVISOR
+ - Function: rem* number divisor
This function returns the same value as the second return value of
`truncate'.
which is much more likely to give statistically clean random numbers
than the simple generators supplied by many operating systems.
- - Function: random* NUMBER &optional STATE
+ - Function: random* number &optional state
This function returns a random nonnegative number less than
NUMBER, and of the same type (either integer or floating-point).
The STATE argument should be a `random-state' object which holds
sequence generated from this variable will be irreproducible for
all intents and purposes.
- - Function: make-random-state &optional STATE
+ - Function: make-random-state &optional state
This function creates or copies a `random-state' object. If STATE
is omitted or `nil', it returns a new copy of `*random-state*'.
This is a copy in the sense that future sequences of calls to
later rerun, it can read the original run's random-state from the
file.
- - Function: random-state-p OBJECT
+ - Function: random-state-p object
This predicate returns `t' if OBJECT is a `random-state' object,
or `nil' otherwise.