cl.texinfo

早期freebsd实现

@itemx list-length
Very standard utilities.  List* has proven especially useful to
overcome the lack of a real @code{backquote}.  In addition, things that
usually required the relatively clumsy
@example
(cons 'a (cons 'b oldlist))
(append (list a b) oldlist)
@end example
can now be simply put:
@example
(list* 'a 'b oldlist)
@end example
See also @code{acons}.

@item member
Another well known function.  Supports test with @code{eql} only.

@item acons
@itemx pairlis
These two are part of the standards association lists implementation.  I
am leaving @code{sublis} as an exercise for the reader.

@item adjoin
Done mainly for the sake of @code{pushnew}.

@item butlast
@itemx last
@itemx ldiff
Occasionally useful ways to access the last cons or a specified tail of
a list.  I don't remember why there isn't a @code{tailp} here.

@item c[ad][ad][ad][ad]r, up to four a's or d's
These 28 functions (and their setf inverses) have been provided once and
for all.  Many packages contributed to Emacs Lisp contain macros that
implement some of these, I think this code will make most of them
unnecessary. 

@item first
@itemx rest
@itemx second
@itemx third
@itemx fourth
@itemx fifth
@itemx sixth
@itemx seventh
@itemx eighth
@itemx ninth
@itemx tenth
More standard accessors (and their setf inverses).  Not particularly
useful but easy to provide.

@item setnth
@itemx setnthcdr
These functions are non-standard.  They are here for @code{defsetf}
purposes only, but they might be useful on their own.

@end table

@node Sequences, Conditionals, Lists, Top
@section Sequences

Sequences are partly supported in Emacs Lisp (see, for instance, the
@code{elt} function).  This limited support is compatible with Common
Lisp, so it should be easy to extend.  However, the lack of
keyword arguments makes many of the functions impossible so far (but, as
mentioned below, a basic framework for that extension
is provided here). @refill

The functionality really provided here is given by the functions
(essentially, predicates) @code{every}, @code{some}, @code{notevery},
@code{notany}.  I have found them useful countless times, so I thought
to provide them before anything else. @refill

That still leaves many omissions, though.

@subsection Features Provided

@table @code
@item every
@itemx notany
@itemx notevery
@itemx some
Extremely useful functions.  If your favorite Lisp doesn't have them,
you are missing a lot.

@item setelt
A setf-inverse to @code{elt}.

@item add-to-klist
@itemx build-klist
@itemx extract-from-klist
A @dfn{klist} is just an alist whose keys are keywords.  I based the
pseudo-keyword argument support of @code{defstruct} on this idea, but
their best fit is here, as they could help to write the remaining
sequence-handling functions (@code{find}, @code{substitute}, @dots{})
that I didn't provide for the lack of a good keyword
arguments mechanism. @refill

@item elt-satisfies-if-not-p
@itemx elt-satisfies-if-p
@itemx elt-satisfies-test-p
@itemx elts-match-under-klist-p
The Common Lisp book defines some of the semantics of sequence functions
in terms of satisfaction of certain tests.  These predicates provide
that functionality, but I haven't integrated them with the rest of the
extensions.  However, I thought it was better to include them anyway, as
they can serve somebody else as a starting point.

@end table


@node Conditionals, Iterations, Sequences, Top
@section Conditionals

An elementary incompatibility prevents us from producing true Common
Lisp here.  The @code{if} forms are different.  In Emacs Lisp, @code{if}
can take any number of subforms, there being a @var{condition} form, a
@var{then} form, and after them any number of @var{else} subforms,
which are executed in an implicit @code{progn}.  Moreover, that style is
widely used in the Emacs sources, so I thought most impractical to break
with 
it to support Common Lisp's @code{if} (where only one @var{else} form is
tolerated).  For the most part, I use @code{cond} almost always, so it
doesn't bother me much.  If you use single-branch @code{if}s often,
consider @code{when} or @code{unless} as alternatives.  @refill

@code{case} and @code{ecase} are a convenient way to write things that
usually end up in a very baroque @code{cond}.  

@subsection Features Provided

@table @code
@item MACRO case
@itemx MACRO ecase
@itemx MACRO unless
@itemx MACRO when
The standard stuff, completely implemented.
@end table

@node Iterations, Multiple Values, Conditionals, Top
@section Iterations

Having a @code{do} macro was my original motivation.  The alternatives
in standard Emacs Lisp are either expensive (recursion) or correspond
directly to the expansion of my macros:
@example
 (macroexpand '
  (do ((i 0) (j 1 (+ 1 j)))
      ((> j (foo i)) (cons i bar))
    (setq i (baz i j))))

(let ((i 0) (j 1))
  (while (not (> j (foo i)))
    (setq i (baz i j))
    (psetq j (+ 1 j)))
  (cons i bar))
@end example
So I prefer to leave to the macros the problem of remembering the
details right.

The incompatibilities are due to the problems already discussed
(@pxref{Generalities}, for more details). @refill

If you write Emacs Lisp code often, you will find enough uses for these.
Examples are cooking up a translation table to move @key{C-s} out of the
way of multiplexers, switches, concentrators and similar fauna, or
building keymaps.  @refill

@subsection Features Provided

@table @code
@item MACRO do
@itemx MACRO do*
@itemx MACRO dolist
@itemx MACRO dotimes
The standard, but for the lack of implicit blocks.

@item MACRO loop
The basic standard one, not the fancy one.  As per the book, warns you
about atomic entries at the surface of the macro (to guarantee that the
fancy @code{loop} macros can be made standard later).

@item MACRO do-all-symbols
@itemx MACRO do-symbols
These operate on obarrays, the default is the current one.

@end table

@node Multiple Values, Integer Arithmetic, Iterations, Top
@section Multiple Values

The multiple values mechanism covers (simply and elegantly, in my
opinion) various common needs:

@enumerate
@item
The case where a function returns a composite value, that has to be
assembled in the callee and disassembled in the caller.  An example is
@code{pair-with-newsyms}.
@item
The case where a function might cheaply compute redundant information
that is useful to the caller only eventually.  For instance, routines
that compute quotients and remainders together, whose callers might be
more often interested in just receiving the quotient.
@item
The case of functions that usually return a useful value, but might need
to elaborate on occasion (say, returning a reason code too).
@end enumerate

The general idea is that one such function @i{always} returns the extra
values, but only callers that are aware of this ability receive them.
Unaware callers just receive the first value.

I think my implementation is pretty much complete.  I am imposing no
limits on the number of multiple values a function may return, so
I am not providing the constant @code{multiple-values-limit}.  You can
assume multiple values are bound by the memory 
size only. @refill

@subsection Features Provided

@table @code
@item values
@itemx values-list
These are the forms that produce multiple values.

@item MACRO multiple-value-bind
@itemx MACRO multiple-value-call
@itemx MACRO multiple-value-list
@itemx MACRO multiple-value-prog1
@itemx MACRO multiple-value-setq
These are the forms that receive multiple values.

@item VARIABLE *mvalues-count*
@itemx VARIABLE *mvalues-values*
Used by the implementation.  Don't touch them!

@end table

@node Integer Arithmetic, Generalized Variables, Multiple Values, Top
@section Integer Arithmetic

I have provided most of the functions that are supposed to act on
integers.  Of those that take arbitrary numbers, I have implemented
those that have a reasonable implementation if restricted to integers
only, although some more could be added (like a restricted form of
@code{expt}).

Being a little worried about the bad fame that affects some
implementations of the '%' C operator, I have taken perhaps unnecessary
precautions whenever integer division is concerned (see the function
@code{safe-idiv}).  This should be of interest only when dividing
numbers that might be negative, but I have preferred here to be safe
rather than fast.  @refill

@subsection Features Provided

@table @code
@item abs
@itemx signum
The usual.

@item gcd
@itemx lcm
The usual.

@item isqrt
A rather annoying function.  Only use I can think of: to cut short a
prime number sieve.

@item evenp
@itemx oddp
@itemx plusp
@itemx minusp
A few predicates that use to come handy.

@item ceiling
@itemx floor
@itemx round
@itemx truncate
@itemx mod
@itemx rem
The intention is to give everybody his preferred way to divide integers.
I have tried not to depend on the unreliable semantics of C's integer
division, I hope I got it right.  Read the code when in doubt.