cl.texinfo

早期freebsd实现

\input texinfo    @c -*-texinfo-*-
@setfilename ../info/cl
@settitle Common Lisp Extensions

@iftex
@finalout
@end iftex

Copyright (C) 1987 Cesar Quiroz

@node Top, Generalities,,(DIR)
@chapter Common Lisp Extensions

The routines described in this chapter provide some of the functionality of
Common Lisp inside Emacs Lisp.

@menu
* gen: Generalities.           Things you need to know.
* sym: Symbols.                Gensym, gentemp, keyword-p, @dots{}
* lis: Lists.                  List*, pairlis, acons, @dots{}
* seq: Sequences.              Every, any, notevery, notany, @dots{}
* con: Conditionals.           When, unless, case, ecase.
* ite: Iterations.             Do, do*, dolist, dotimes, @dots{}
* mul: Multiple Values.        Values, values-list, @dots{}
* ari: Integer Arithmetic.     Floor, ceiling, round, truncate, @dots{}
* stf: Generalized Variables.  Setf and friends.
* str: Structures.             Like Pascal records or C structs.
* mis: Miscellanea.            Odds and ends that didn't fit elsewhere.
* tod: To Do.                  Suggestions for future hackery.
@end menu

@node Generalities, Symbols, Top, Top
@section Generalities

This section tells you want you need to know about the routines in the file
@file{cl.el}, so that you can use them.  The distribution also includes
this documentation and perhaps a few example files.

@subsection License, Availability, Maintenance

These files are covered by the GNU Emacs General Public License (if you
don't know its terms, try @kbd{@key{C-h} @key{C-c}}) and the statement of
no warranty (again, you can type @kbd{@key{C-h} @key{C-w}} if you don't
know its terms) also applies to them. @refill

I, Cesar Quiroz, the original author of the software described here, will
appreciate hearing about bug reports (and fixes), suggestions and comments,
applying both to the code and to this documentation.  I don't promise to
act on those communications, but whenever they might conduce to
improvements of this software, I will make those improvements available to
the general community through the Free Software Foundation.  You can reach
me at the following net addresses:
@quotation
quiroz@@seneca.cs.rochester.edu
quiroz@@rochester.arpa
@{allegra | seismo | @dots{} @} ! rochester ! quiroz
CSNET: Cesar Quiroz at node Rochester
@end quotation

@subsection Purpose and Limitations

These routines were written with two purposes in mind:

@enumerate
@item
To make programming in Emacs Lisp even more compatible with Common Lisp.
Indeed, my original motivation was to have a @code{do} macro.
@item
To facilitate to novice Lisp programmers a chance to practice with
features commonly found only in expensive implementations of Lisp. 
@end enumerate

In order to satisfy these purposes, the routines were written in such a way
that it is practical to use them inside Emacs: no effort was given to
implement features that could slow down the host Emacs unnecessarily nor
require recoding of the Emacs Lisp interpreter.

For instance, no support is given to floating point arithmetic.

So, I have tried to implement a subset of the functionality of Common Lisp.
Whatever is implemented, has syntactic and semantic properties like the
equally named features of Common Lisp, but not all the relevant features
have been implemented (@pxref{To Do}, for some suggestions).  When
deciding what to include, I have tried to strike a balance between these
constraints:

@enumerate
@item
Keep it simple, I didn't want to spend much time in this idea.
@item
Keep it compatible with Common Lisp.
@item
Keep it flexible, so my code doesn't oppose a better implementation (when
this looked hard, I just didn't implement the feature).
@item
Keep an eye on the intended use of Emacs Lisp: to support an advanced
editor.  I don't expect that more arithmetic support will be as conducive
to this goal as having better iterations and conditionals will.
@end enumerate

For background, the reference is ``Common Lisp: The Language'' by Guy
Steele Jr. (Digital Press, 1984).  For all the features described here
you can assume that the intent has been to provide the syntax and
semantics of the features of like name in the book.  For the most part,
this documentation will concentrate on how my routines @i{fail} to
implement Common Lisp faithfully.

@subsubsection Specific Limitations

Emacs Lisp and Common Lisp differ enough to make some of the emulation
difficult, expensive or nearly impractical.  Some specific limitations are
stated here:

@enumerate
@item
Common Lisp is lexically scoped (mostly), while Emacs Lisp is dynamically
scoped.  Things like @code{block}, @code{return}, @code{tagbody} are then
practically impossible to imitate correctly (in principle, rewriting
@code{eval}, @code{apply} and a couple of other functions would suffice,
problem is that such rewriting amounts to  a new interpreter on top
of the old.)  Things like @samp{implicit-blocks},
@samp{implicit-tagbodies} and the like have not been implemented at all.
Where they are needed, the most you can assume is that I tried to put
@samp{implicit-progns} around places where it made sense. @refill

@item
Emacs Lisp's @code{lambda} does not support all the possible argument
markers.  Similarly, @code{defmacro} doesn't support automatic
destructuring of the calls.  An approximation to a keyword-based calling
style was implemented, mainly for the sake of @code{defstruct}, but is
not general enough.  @refill

@item
Emacs Lisp supports arithmetic only on integers.

@item
Emacs Lisp doesn't support many of the basic types of Common Lisp.  In
particular, there are no arrays beyond vectors and strings (although these
ones are compatible), characters are essentially small
integers, etc. @refill

@item
There are no declarations in Emacs Lisp (in the sense of Common Lisp's
@code{declare}, @code{proclaim}, @dots{}) nor there is a explicit lattice
of types.  These limitations could be effectively overcome from Lisp code
(to a extent), but I don't see them as a very pressing need, if a need at
all in Emacs Lisp.  @code{defstruct} can be used to generate new types
that can be recognized at runtime. @refill

@item
The Emacs Lisp reader is not programmable.  The syntax it accepts is
almost standard, but it preempts '?' as a dispatching macro of sorts.
The @code{format} function is incompatible with Common Lisp.  There
isn't a `quasi-constant' notation (the usual @code{backquote} of Common
Lisp).  None of these differences causes any problems when writing Emacs
Lisp (although the lack of backquoting is felt sorely), but they oppose
a Common Lisp emulation. @refill

@end enumerate

@subsection Loading and Compiling

The file @file{cl.el} provides the @samp{cl} feature, you can use this to
test whether these routines have been loaded, or to load them from your
code (by means of @code{(require 'cl)}).  The compiled file is a little
larger than 50K bytes.

If you need to recompile the sources, make sure you load them first on the
Emacs that will do the recompilation.  This is because many syntactic
characteristics (like the special forms) have been implemented as macros
and you need to make sure that macros are known to the compiler before they
are used.

These extensions work correctly when interpreted in a GNU Emacs of
version 17.64 or beyond.  Compiling them requires a more recent byte
compiler, preferably one strictly younger than version 18.XX.

@subsection On Line Help

The routines in this file have documentation strings, so you can (and
should) consult them for the exact syntax allowed.  That information is
not repeated in this manual.  Some of the routines are also documented
explicitly in the Common Lisp reference, their doc-strings begin with
@samp{[cl]} to represent this fact.

The rest (those without the @samp{[cl]} mark) are auxiliary functions or
macros used by the rest of the implementation.  They are not constrained
by any standard and are advertised only in as much as they can be useful
in other applications. @refill

Each of the following sections contains a subsection called `Features
Provided'.  It lists briefly the user-visible features of this
implementation.  In its entries, names by themselves refer to functions.
Macros and variables are identified by a `MACRO' or a `VARIABLE' ahead
of their names.

@node Symbols, Lists, Generalities, Top
@section Symbols

The most important omission is that of a @var{packages} mechanism.
(For a possible implementation, @pxref{To Do})  Whenever a Common Lisp
function expects a package, I have substituted an obarray.  There is a
hack to have pseudo-keywords, see below. @refill

There are two other notorious omissions over which I haven't lost any
sleep.  The first is the lack of a @code{remprop} function, which could be
easily provided if needed.  The second is the lack of ways to modify the
print name of a symbol.  This one would probably be good only to
introduce strange bugs, so I don't miss it. @refill

@subsection Features Provided

@table @code
@item VARIABLE *gensym-index*
@itemx VARIABLE *gensym-prefix*
@itemx VARIABLE *gentemp-index*
@itemx VARIABLE *gentemp-prefix*
These variables are used to keep the state of the generator of new names.
Better leave them alone.
@item gensym
@itemx gentemp
These do the same as the Common Lisp names of like names.
@item MACRO defkeyword 
@itemx keyword-of
@item keywordp
These provide the pseudo-keywords implementation.
@end table

@subsection Keywords

The lack of packages makes it difficult to implement keywords correctly.
I have provided a macro @code{defkeyword} that takes a symbol and makes
sure it evaluates to itself.  (So, it is like @code{defconst}.)  If your
programs ever need keywords, put a bunch of calls to @code{defkeyword} at
the beginning of your code, so when loaded they will be in effect. @refill

The (standard) predicate @code{keywordp} tests to see if the given
symbol's name begins with a colon and then ensures that it evaluates to
itself. @refill

The function @code{keyword-of} takes a symbol and returns a keyword of
like name. @refill

@example
 (keyword-of 'foo)
:foo
 (keyword-of ':bar)
:bar
@end example

This feature was added mainly to support @code{defstruct} and the tests of
the sequence functions.  It is fragile and easy to fool.

@subsection New Symbols

A common need (especially when writing macros) is to be able to invent new
names for things.  I provide the @code{gensym} and @code{gentemp}
functions.  The global state needed is kept in the variables
@code{*gentemp-index*}, @code{*gentemp-prefix*}, @code{*gensym-index*} and
@code{*gensym-prefix*}.  Changing them, especially the index ones, is a
very bad idea.  I am not providing the Common Lisp default prefixes ('G'
for @code{gensym} and 'T' for @code{gentemp}) because of debugging
paranoia.  My default prefixes are harder to come by when giving sane
names to things. @refill

@node Lists, Sequences, Symbols, Top
@section Lists

Lists (indeed, conses) are so deeply involved in Lisp that there seems
to be little need to justify improving the list handling of a Lisp.

Common Lisp, however, is a rather huge Lisp.  I haven't provided all the
functions in the chapter of lists, mainly because some of them could be
implemented correctly only if keyword arguments were supported.
That explains why I haven't rushed to provide
@code{subst}, @code{sublis}, etc.  Also, that explains the rather
temporary nature of the implementation of @code{member} and
@code{adjoin}.  I will welcome any efforts to extend
this work. @refill

@subsection Features Provided

@table @code
@item endp
@itemx list*