xemacs-beta: man/cl.texi comparison

comparison man/cl.texi @ 380:8626e4521993 r21-2-5

Import from CVS: tag r21-2-5

author	cvs
date	Mon, 13 Aug 2007 11:07:10 +0200
parents	cc15677e0335
children	74fd4e045ea6

comparison

equal deleted inserted replaced

-:76b7d63099ad
+:8626e4521993
 it compares numbers without regard to type (so that @code{(equalp 3
 3.0)} is true).  Vectors and conses are compared recursively.  All other
 objects are compared as if by @code{equal}.
 This function differs from Common Lisp @code{equalp} in several
-respects.  First, in keeping with the idea that strings are less
+respects.  In keeping with the idea that strings are less
 vector-like in Emacs Lisp, this package's @code{equalp} also will not
-compare strings against vectors of integers.  Second, Common Lisp's
+compare strings against vectors of integers.
-@code{equalp} compares hash tables without regard to ordering, whereas
-this package simply compares hash tables in terms of their underlying
-structure (which means vectors for Lucid Emacs 19 hash tables, or lists
-for other hash tables).
 @end defun
 Also note that the Common Lisp functions @code{member} and @code{assoc}
 use @code{eql} to compare elements, whereas Emacs Lisp follows the
 MacLisp tradition and uses @code{equal} for these two functions.
 The use of @code{nthcdr} as a @var{place} form is an extension
 to standard Common Lisp.
 @item
 The following Emacs-specific functions are also @code{setf}-able.
-(Some of these are defined only in Emacs 19 or only in Lucid Emacs.)
+(Some of these are defined only in Emacs 19 or only in XEmacs.)
 @smallexample
 buffer-file-name                  marker-position
 buffer-modified-p                 match-data
 buffer-name                       mouse-position
 buffer-string                     overlay-end
 buffer-substring                  overlay-get
 current-buffer                    overlay-start
 current-case-table                point
 current-column                    point-marker
 current-global-map                point-max
 current-input-mode                point-min
 current-local-map                 process-buffer
 current-window-configuration      process-filter
 default-file-modes                process-sentinel
 default-value                     read-mouse-position
 documentation-property            screen-height
 extent-data                       screen-menubar
 extent-end-position               screen-width
 extent-start-position             selected-window
 face-background                   selected-screen
 face-background-pixmap            selected-frame
 face-font                         standard-case-table
 face-foreground                   syntax-table
 face-underline-p                  window-buffer
 file-modes                        window-dedicated-p
 frame-height                      window-display-table
 frame-parameters                  window-height
 frame-visible-p                   window-hscroll
 frame-width                       window-point
 get-register                      window-start
 getenv                            window-width
 global-key-binding                x-get-cut-buffer
 keymap-parent                     x-get-cutbuffer
 local-key-binding                 x-get-secondary-selection
 mark                              x-get-selection
 mark-marker
 @end smallexample
 Most of these have directly corresponding ``set'' functions, like
 @code{use-local-map} for @code{current-local-map}, or @code{goto-char}
 for @code{point}.  A few, like @code{point-min}, expand to longer
 is the opposite word of the word following @code{the}) to cause
 @var{var} and @var{var2} to be bound to the two parts of each
 hash table entry.
 @item for @var{var} being the key-codes of @var{keymap}
-This clause iterates over the entries in @var{keymap}.  In GNU Emacs
+This clause iterates over the entries in @var{keymap}.  In GNU Emacs 18
-18 and 19, keymaps are either alists or vectors, and key-codes are
+and 19, keymaps are either alists or vectors, and key-codes are integers
-integers or symbols.  In Lucid Emacs 19, keymaps are a special new
+or symbols.  In XEmacs, keymaps are a special new data type, and
-data type, and key-codes are symbols or lists of symbols.  The
+key-codes are symbols or lists of symbols.  The iteration does not enter
-iteration does not enter nested keymaps or inherited (parent) keymaps.
+nested keymaps or inherited (parent) keymaps.  You can use @samp{the
-You can use @samp{the key-bindings} to access the commands bound to
+key-bindings} to access the commands bound to the keys rather than the
-the keys rather than the key codes, and you can add a @code{using}
+key codes, and you can add a @code{using} clause to access both the
-clause to access both the codes and the bindings together.
+codes and the bindings together.
 @item for @var{var} being the key-seqs of @var{keymap}
 This clause iterates over all key sequences defined by @var{keymap}
 and its nested keymaps, where @var{var} takes on values which are
 strings in Emacs 18 or vectors in Emacs 19.  The strings or vectors
 are reused for each iteration, so you must copy them if you wish to keep
 them permanently.  You can add a @samp{using (key-bindings ...)}
 clause to get the command bindings as well.
 @item for @var{var} being the overlays [of @var{buffer}] @dots{}
-This clause iterates over the Emacs 19 ``overlays'' or Lucid
+This clause iterates over the Emacs 19 ``overlays'' or XEmacs
-Emacs ``extents'' of a buffer (the clause @code{extents} is synonymous
+``extents'' of a buffer (the clause @code{extents} is synonymous with
-with @code{overlays}).  Under Emacs 18, this clause iterates zero
+@code{overlays}).  Under Emacs 18, this clause iterates zero times.  If
-times.  If the @code{of} term is omitted, the current buffer is used.
+the @code{of} term is omitted, the current buffer is used.  This clause
-This clause also accepts optional @samp{from @var{pos}} and
+also accepts optional @samp{from @var{pos}} and @samp{to @var{pos}}
-@samp{to @var{pos}} terms, limiting the clause to overlays which
+terms, limiting the clause to overlays which overlap the specified
-overlap the specified region.
+region.
 @item for @var{var} being the intervals [of @var{buffer}] @dots{}
 This clause iterates over all intervals of a buffer with constant
 text properties.  The variable @var{var} will be bound to conses
 of start and end positions, where one start position is always equal
 Emacs 19.
 @example
 (declaim (inline foo bar))
 (eval-when (compile load eval) (proclaim '(inline foo bar)))
-(proclaim-inline foo bar)      ; Lucid Emacs only
+(proclaim-inline foo bar)      ; XEmacs only
 (defsubst foo (...) ...)       ; instead of defun; Emacs 19 only
 @end example
 @strong{Please note:}  This declaration remains in effect after the
 containing source file is done.  It is correct to use it to
 @node Hash Tables, Structures, Lists, Top
 @chapter Hash Tables
 @noindent
+Hash tables are now implemented directly in the C code and documented in
+@ref{Hash Tables,,, lispref, XEmacs Lisp Programmer's Manual}.
+@ignore
 A @dfn{hash table} is a data structure that maps ``keys'' onto
 ``values.''  Keys and values can be arbitrary Lisp data objects.
 Hash tables have the property that the time to search for a given
 key is roughly constant; simpler data structures like association
 lists take time proportional to the number of entries in the list.
 In this package, any reasonable predicate function will work,
 though if you use something else you should check the details of
 the hashing function described below to make sure it is suitable
 for your predicate.
-Some versions of Emacs (like Lucid Emacs 19) include a built-in
+Some versions of Emacs (like XEmacs) include a built-in hash
-hash table type; in these versions, @code{make-hash-table} with
+table type; in these versions, @code{make-hash-table} with a test of
-a test of @code{eq} will use these built-in hash tables.  In all
+@code{eq}, @code{eql}, or @code{equal} will use these built-in hash
-other cases, it will return a hash-table object which takes the
+tables.  In all other cases, it will return a hash-table object which
-form of a list with an identifying ``tag'' symbol at the front.
+takes the form of a list with an identifying ``tag'' symbol at the
-All of the hash table functions in this package can operate on
+front.  All of the hash table functions in this package can operate on
-both types of hash table; normally you will never know which
+both types of hash table; normally you will never know which type is
-type is being used.
+being used.
 This function accepts the additional Common Lisp keywords
 @code{:rehash-size} and @code{:rehash-threshold}, but it ignores
 their values.
 @end defun
 of the given entry.  The return value of @var{function} is ignored;
 @var{maphash} itself returns @code{nil}.  @xref{Loop Facility}, for
 an alternate way of iterating over hash tables.
 @end defun
-@defun hash-table-count table
+@defun hash-table-count table This function returns the number of
-This function returns the number of entries in @var{table}.
+entries in @var{table}.  @strong{Warning:} The current implementation of
-@strong{Warning:}  The current implementation of Lucid Emacs 19
+XEmacs hash-tables does not decrement the stored @code{count}
-hash-tables does not decrement the stored @code{count} when
+when @code{remhash} removes an entry.  Therefore, the return value of
-@code{remhash} removes an entry.  Therefore, the return value of
+this function is not dependable if you have used @code{remhash} on the
-this function is not dependable if you have used @code{remhash}
+table and the table's test is @code{eq}, @code{eql}, or @code{equal}.
-on the table and the table's test is @code{eq}.  A slower, but
+A slower, but reliable, way to count the entries is
-reliable, way to count the entries is @code{(loop for x being the
+@code{(loop for x being the hash-keys of @var{table} count t)}.
-hash-keys of @var{table} count t)}.
+@end defun
-@end defun
+@defun hash-table-p object This function returns @code{t} if
-@defun hash-table-p object
+@var{object} is a hash table, @code{nil} otherwise.  It recognizes both
-This function returns @code{t} if @var{object} is a hash table,
+types of hash tables (both XEmacs built-in tables and tables implemented
-@code{nil} otherwise.  It recognizes both types of hash tables
+with special lists.)
-(both Lucid Emacs built-in tables and tables implemented with
-special lists.)
 @end defun
 Sometimes when dealing with hash tables it is useful to know the
 exact ``hash function'' that is used.  This package implements
 hash tables using Emacs Lisp ``obarrays,'' which are the same
 list rather than an obarray of many lists.  For very small tables this
 structure will be more efficient since lookup does not require
 converting the key to a string or looking it up in an obarray.
 However, such tables are guaranteed to take time proportional to
 their size to do a search.
+@end ignore
 @iftex
 @chapno=18
 @end iftex
 @example
 (mapcar #'(lambda (x) (* x 2)) list)            ; Common Lisp
 (mapcar (function (lambda (x) (* x 2))) list)   ; Emacs Lisp
 @end example
-Lucid Emacs supports @code{#'} notation starting with version 19.8.
+XEmacs supports @code{#'} notation starting with version 19.8.
 @item
 Reader macros.  Common Lisp includes a second type of macro that
 works at the level of individual characters.  For example, Common
 Lisp implements the quote notation by a reader macro called @code{'},

Mercurial > hg > xemacs-beta

comparison man/cl.texi @ 380:8626e4521993 r21-2-5