Merge from trunk.

[gnu-emacs] / lisp / emacs-lisp / cl-loaddefs.el

diff --git a/lisp/emacs-lisp/cl-loaddefs.el b/lisp/emacs-lisp/cl-loaddefs.el
index 5308b700a22b61b0278dd63bac173d5bbd26f629..270211f6a7892f178838bc55266eec1433ee44e9 100644 (file)
--- a/lisp/emacs-lisp/cl-loaddefs.el
+++ b/lisp/emacs-lisp/cl-loaddefs.el
@@ -10,7 +10,7 @@
 ;;;;;;  ceiling* floor* isqrt lcm gcd cl-progv-before cl-set-frame-visible-p
 ;;;;;;  cl-map-overlays cl-map-intervals cl-map-keymap-recursively
 ;;;;;;  notevery notany every some mapcon mapcan mapl maplist map
 ;;;;;;  ceiling* floor* isqrt lcm gcd cl-progv-before cl-set-frame-visible-p
 ;;;;;;  cl-map-overlays cl-map-intervals cl-map-keymap-recursively
 ;;;;;;  notevery notany every some mapcon mapcan mapl maplist map

-;;;;;;  cl-mapcar-many equalp coerce) "cl-extra" "cl-extra.el" "2f89c94c42629315419a9d7404469c42")
+;;;;;;  cl-mapcar-many equalp coerce) "cl-extra" "cl-extra.el" "26339d9571f9485bf34fa6d2ae38fc84")

 ;;; Generated autoloads from cl-extra.el
 
 (autoload 'coerce "cl-extra" "\
 ;;; Generated autoloads from cl-extra.el
 
 (autoload 'coerce "cl-extra" "\


@@ -273,8 +273,8 @@ Not documented
 
 ;;;***
 \f
 
 ;;;***
 \f

-;;;### (autoloads (compiler-macroexpand define-compiler-macro ignore-errors
-;;;;;;  assert check-type typep cl-struct-setf-expander defstruct
+;;;### (autoloads (defsubst* compiler-macroexpand define-compiler-macro
+;;;;;;  assert check-type typep deftype cl-struct-setf-expander defstruct

 ;;;;;;  define-modify-macro callf2 callf letf* letf rotatef shiftf
 ;;;;;;  remf cl-do-pop psetf setf get-setf-method defsetf define-setf-method
 ;;;;;;  declare the locally multiple-value-setq multiple-value-bind
 ;;;;;;  define-modify-macro callf2 callf letf* letf rotatef shiftf
 ;;;;;;  remf cl-do-pop psetf setf get-setf-method defsetf define-setf-method
 ;;;;;;  declare the locally multiple-value-setq multiple-value-bind


@@ -282,15 +282,9 @@ Not documented
 ;;;;;;  flet progv psetq do-all-symbols do-symbols dotimes dolist
 ;;;;;;  do* do loop return-from return block etypecase typecase ecase
 ;;;;;;  case load-time-value eval-when destructuring-bind function*
 ;;;;;;  flet progv psetq do-all-symbols do-symbols dotimes dolist
 ;;;;;;  do* do loop return-from return block etypecase typecase ecase
 ;;;;;;  case load-time-value eval-when destructuring-bind function*

-;;;;;;  defmacro* defun* gentemp gensym cl-compile-time-init) "cl-macs"
-;;;;;;  "cl-macs.el" "80422dc6f5f8faffd926deba0c4c0ed7")
+;;;;;;  defmacro* defun* gentemp gensym) "cl-macs" "cl-macs.el" "9452c0e16fd960fce5c19e5c067a7160")

 ;;; Generated autoloads from cl-macs.el
 
 ;;; Generated autoloads from cl-macs.el
 

-(autoload 'cl-compile-time-init "cl-macs" "\
-Not documented
-
-\(fn)" nil nil)
-

 (autoload 'gensym "cl-macs" "\
 Generate a new uninterned symbol.
 The name is made by appending a number to PREFIX, default \"G\".
 (autoload 'gensym "cl-macs" "\
 Generate a new uninterned symbol.
 The name is made by appending a number to PREFIX, default \"G\".


@@ -325,7 +319,7 @@ its argument list allows full Common Lisp conventions.
 \(fn FUNC)" nil (quote macro))
 
 (autoload 'destructuring-bind "cl-macs" "\
 \(fn FUNC)" nil (quote macro))
 
 (autoload 'destructuring-bind "cl-macs" "\

-Not documented
+

 
 \(fn ARGS EXPR &rest BODY)" nil (quote macro))
 
 
 \(fn ARGS EXPR &rest BODY)" nil (quote macro))
 


@@ -395,7 +389,7 @@ This is equivalent to `(return-from nil RESULT)'.
 
 (autoload 'return-from "cl-macs" "\
 Return from the block named NAME.
 
 (autoload 'return-from "cl-macs" "\
 Return from the block named NAME.

-This jump out to the innermost enclosing `(block NAME ...)' form,
+This jumps out to the innermost enclosing `(block NAME ...)' form,

 returning RESULT from that form (or nil if RESULT is omitted).
 This is compatible with Common Lisp, but note that `defun' and
 `defmacro' do not create implicit blocks as they do in Common Lisp.
 returning RESULT from that form (or nil if RESULT is omitted).
 This is compatible with Common Lisp, but note that `defun' and
 `defmacro' do not create implicit blocks as they do in Common Lisp.


@@ -451,7 +445,7 @@ from OBARRAY.
 \(fn (VAR [OBARRAY [RESULT]]) BODY...)" nil (quote macro))
 
 (autoload 'do-all-symbols "cl-macs" "\
 \(fn (VAR [OBARRAY [RESULT]]) BODY...)" nil (quote macro))
 
 (autoload 'do-all-symbols "cl-macs" "\

-Not documented
+

 
 \(fn SPEC &rest BODY)" nil (quote macro))
 
 
 \(fn SPEC &rest BODY)" nil (quote macro))
 


@@ -506,14 +500,16 @@ Like `let', but lexically scoped.
 The main visible difference is that lambdas inside BODY will create
 lexical closures as in Common Lisp.
 
 The main visible difference is that lambdas inside BODY will create
 lexical closures as in Common Lisp.
 

-\(fn VARLIST BODY)" nil (quote macro))
+\(fn BINDINGS BODY)" nil (quote macro))

 
 (autoload 'lexical-let* "cl-macs" "\
 Like `let*', but lexically scoped.
 
 (autoload 'lexical-let* "cl-macs" "\
 Like `let*', but lexically scoped.

-The main visible difference is that lambdas inside BODY will create
-lexical closures as in Common Lisp.
+The main visible difference is that lambdas inside BODY, and in
+successive bindings within BINDINGS, will create lexical closures
+as in Common Lisp.  This is similar to the behavior of `let*' in
+Common Lisp.

 
 

-\(fn VARLIST BODY)" nil (quote macro))
+\(fn BINDINGS BODY)" nil (quote macro))

 
 (autoload 'multiple-value-bind "cl-macs" "\
 Collect multiple return values.
 
 (autoload 'multiple-value-bind "cl-macs" "\
 Collect multiple return values.


@@ -535,17 +531,23 @@ values.  For compatibility, (values A B C) is a synonym for (list A B C).
 \(fn (SYM...) FORM)" nil (quote macro))
 
 (autoload 'locally "cl-macs" "\
 \(fn (SYM...) FORM)" nil (quote macro))
 
 (autoload 'locally "cl-macs" "\

-Not documented
+

 
 \(fn &rest BODY)" nil (quote macro))
 
 (autoload 'the "cl-macs" "\
 
 \(fn &rest BODY)" nil (quote macro))
 
 (autoload 'the "cl-macs" "\

-Not documented
+

 
 \(fn TYPE FORM)" nil (quote macro))
 
 (autoload 'declare "cl-macs" "\
 
 \(fn TYPE FORM)" nil (quote macro))
 
 (autoload 'declare "cl-macs" "\

-Not documented
+Declare SPECS about the current function while compiling.
+For instance
+
+  (declare (warn 0))
+
+will turn off byte-compile warnings in the function.
+See Info node `(cl)Declarations' for details.

 
 \(fn &rest SPECS)" nil (quote macro))
 
 
 \(fn &rest SPECS)" nil (quote macro))
 


@@ -605,7 +607,7 @@ before assigning any PLACEs to the corresponding values.
 \(fn PLACE VAL PLACE VAL ...)" nil (quote macro))
 
 (autoload 'cl-do-pop "cl-macs" "\
 \(fn PLACE VAL PLACE VAL ...)" nil (quote macro))
 
 (autoload 'cl-do-pop "cl-macs" "\

-Not documented
+

 
 \(fn PLACE)" nil nil)
 
 
 \(fn PLACE)" nil nil)
 


@@ -676,17 +678,33 @@ from ARGLIST using FUNC: (define-modify-macro incf (&optional (n 1)) +)
 
 (autoload 'defstruct "cl-macs" "\
 Define a struct type.
 
 (autoload 'defstruct "cl-macs" "\
 Define a struct type.

-This macro defines a new Lisp data type called NAME, which contains data
-stored in SLOTs.  This defines a `make-NAME' constructor, a `copy-NAME'
-copier, a `NAME-p' predicate, and setf-able `NAME-SLOT' accessors.
+This macro defines a new data type called NAME that stores data
+in SLOTs.  It defines a `make-NAME' constructor, a `copy-NAME'
+copier, a `NAME-p' predicate, and slot accessors named `NAME-SLOT'.
+You can use the accessors to set the corresponding slots, via `setf'.
+
+NAME may instead take the form (NAME OPTIONS...), where each
+OPTION is either a single keyword or (KEYWORD VALUE).
+See Info node `(cl)Structures' for a list of valid keywords.
+
+Each SLOT may instead take the form (SLOT SLOT-OPTS...), where
+SLOT-OPTS are keyword-value pairs for that slot.  Currently, only
+one keyword is supported, `:read-only'.  If this has a non-nil
+value, that slot cannot be set via `setf'.

 
 

-\(fn (NAME OPTIONS...) (SLOT SLOT-OPTS...)...)" nil (quote macro))
+\(fn NAME SLOTS...)" nil (quote macro))

 
 (autoload 'cl-struct-setf-expander "cl-macs" "\
 
 (autoload 'cl-struct-setf-expander "cl-macs" "\

-Not documented
+

 
 \(fn X NAME ACCESSOR PRED-FORM POS)" nil nil)
 
 
 \(fn X NAME ACCESSOR PRED-FORM POS)" nil nil)
 

+(autoload 'deftype "cl-macs" "\
+Define NAME as a new data type.
+The type name can then be used in `typecase', `check-type', etc.
+
+\(fn NAME ARGLIST &rest BODY)" nil (quote macro))
+

 (autoload 'typep "cl-macs" "\
 Check that OBJECT is of type TYPE.
 TYPE is a Common Lisp-style type specifier.
 (autoload 'typep "cl-macs" "\
 Check that OBJECT is of type TYPE.
 TYPE is a Common Lisp-style type specifier.


@@ -708,12 +726,6 @@ omitted, a default message listing FORM itself is used.
 
 \(fn FORM &optional SHOW-ARGS STRING &rest ARGS)" nil (quote macro))
 
 
 \(fn FORM &optional SHOW-ARGS STRING &rest ARGS)" nil (quote macro))
 

-(autoload 'ignore-errors "cl-macs" "\
-Execute BODY; if an error occurs, return nil.
-Otherwise, return result of last form in BODY.
-
-\(fn &rest BODY)" nil (quote macro))
-

 (autoload 'define-compiler-macro "cl-macs" "\
 Define a compiler-only macro.
 This is like `defmacro', but macro expansion occurs only if the call to
 (autoload 'define-compiler-macro "cl-macs" "\
 Define a compiler-only macro.
 This is like `defmacro', but macro expansion occurs only if the call to


@@ -729,10 +741,18 @@ and then returning foo.
 \(fn FUNC ARGS &rest BODY)" nil (quote macro))
 
 (autoload 'compiler-macroexpand "cl-macs" "\
 \(fn FUNC ARGS &rest BODY)" nil (quote macro))
 
 (autoload 'compiler-macroexpand "cl-macs" "\

-Not documented
+

 
 \(fn FORM)" nil nil)
 
 
 \(fn FORM)" nil nil)
 

+(autoload 'defsubst* "cl-macs" "\
+Define NAME as a function.
+Like `defun', except the function is automatically declared `inline',
+ARGLIST allows full Common Lisp conventions, and BODY is implicitly
+surrounded by (block NAME ...).
+
+\(fn NAME ARGLIST [DOCSTRING] BODY...)" nil (quote macro))
+

 ;;;***
 \f
 ;;;### (autoloads (tree-equal nsublis sublis nsubst-if-not nsubst-if
 ;;;***
 \f
 ;;;### (autoloads (tree-equal nsublis sublis nsubst-if-not nsubst-if


@@ -745,7 +765,7 @@ Not documented
 ;;;;;;  find nsubstitute-if-not nsubstitute-if nsubstitute substitute-if-not
 ;;;;;;  substitute-if substitute delete-duplicates remove-duplicates
 ;;;;;;  delete-if-not delete-if delete* remove-if-not remove-if remove*
 ;;;;;;  find nsubstitute-if-not nsubstitute-if nsubstitute substitute-if-not
 ;;;;;;  substitute-if substitute delete-duplicates remove-duplicates
 ;;;;;;  delete-if-not delete-if delete* remove-if-not remove-if remove*

-;;;;;;  replace fill reduce) "cl-seq" "cl-seq.el" "e3c349e5231811c1c0482dd378dae56a")
+;;;;;;  replace fill reduce) "cl-seq" "cl-seq.el" "df375ddc313f0c1c262cacab5cffd3e4")

 ;;; Generated autoloads from cl-seq.el
 
 (autoload 'reduce "cl-seq" "\
 ;;; Generated autoloads from cl-seq.el
 
 (autoload 'reduce "cl-seq" "\


@@ -1071,7 +1091,7 @@ Keywords supported:  :key
 
 (autoload 'union "cl-seq" "\
 Combine LIST1 and LIST2 using a set-union operation.
 
 (autoload 'union "cl-seq" "\
 Combine LIST1 and LIST2 using a set-union operation.

-The result list contains all items that appear in either LIST1 or LIST2.
+The resulting list contains all items that appear in either LIST1 or LIST2.

 This is a non-destructive function; it makes a copy of the data if necessary
 to avoid corrupting the original LIST1 and LIST2.
 
 This is a non-destructive function; it makes a copy of the data if necessary
 to avoid corrupting the original LIST1 and LIST2.
 


@@ -1081,7 +1101,7 @@ Keywords supported:  :test :test-not :key
 
 (autoload 'nunion "cl-seq" "\
 Combine LIST1 and LIST2 using a set-union operation.
 
 (autoload 'nunion "cl-seq" "\
 Combine LIST1 and LIST2 using a set-union operation.

-The result list contains all items that appear in either LIST1 or LIST2.
+The resulting list contains all items that appear in either LIST1 or LIST2.

 This is a destructive function; it reuses the storage of LIST1 and LIST2
 whenever possible.
 
 This is a destructive function; it reuses the storage of LIST1 and LIST2
 whenever possible.
 


@@ -1091,7 +1111,7 @@ Keywords supported:  :test :test-not :key
 
 (autoload 'intersection "cl-seq" "\
 Combine LIST1 and LIST2 using a set-intersection operation.
 
 (autoload 'intersection "cl-seq" "\
 Combine LIST1 and LIST2 using a set-intersection operation.

-The result list contains all items that appear in both LIST1 and LIST2.
+The resulting list contains all items that appear in both LIST1 and LIST2.

 This is a non-destructive function; it makes a copy of the data if necessary
 to avoid corrupting the original LIST1 and LIST2.
 
 This is a non-destructive function; it makes a copy of the data if necessary
 to avoid corrupting the original LIST1 and LIST2.
 


@@ -1101,7 +1121,7 @@ Keywords supported:  :test :test-not :key
 
 (autoload 'nintersection "cl-seq" "\
 Combine LIST1 and LIST2 using a set-intersection operation.
 
 (autoload 'nintersection "cl-seq" "\
 Combine LIST1 and LIST2 using a set-intersection operation.

-The result list contains all items that appear in both LIST1 and LIST2.
+The resulting list contains all items that appear in both LIST1 and LIST2.

 This is a destructive function; it reuses the storage of LIST1 and LIST2
 whenever possible.
 
 This is a destructive function; it reuses the storage of LIST1 and LIST2
 whenever possible.
 


@@ -1111,7 +1131,7 @@ Keywords supported:  :test :test-not :key
 
 (autoload 'set-difference "cl-seq" "\
 Combine LIST1 and LIST2 using a set-difference operation.
 
 (autoload 'set-difference "cl-seq" "\
 Combine LIST1 and LIST2 using a set-difference operation.

-The result list contains all items that appear in LIST1 but not LIST2.
+The resulting list contains all items that appear in LIST1 but not LIST2.

 This is a non-destructive function; it makes a copy of the data if necessary
 to avoid corrupting the original LIST1 and LIST2.
 
 This is a non-destructive function; it makes a copy of the data if necessary
 to avoid corrupting the original LIST1 and LIST2.
 


@@ -1121,7 +1141,7 @@ Keywords supported:  :test :test-not :key
 
 (autoload 'nset-difference "cl-seq" "\
 Combine LIST1 and LIST2 using a set-difference operation.
 
 (autoload 'nset-difference "cl-seq" "\
 Combine LIST1 and LIST2 using a set-difference operation.

-The result list contains all items that appear in LIST1 but not LIST2.
+The resulting list contains all items that appear in LIST1 but not LIST2.

 This is a destructive function; it reuses the storage of LIST1 and LIST2
 whenever possible.
 
 This is a destructive function; it reuses the storage of LIST1 and LIST2
 whenever possible.
 


@@ -1131,7 +1151,7 @@ Keywords supported:  :test :test-not :key
 
 (autoload 'set-exclusive-or "cl-seq" "\
 Combine LIST1 and LIST2 using a set-exclusive-or operation.
 
 (autoload 'set-exclusive-or "cl-seq" "\
 Combine LIST1 and LIST2 using a set-exclusive-or operation.

-The result list contains all items that appear in exactly one of LIST1, LIST2.
+The resulting list contains all items appearing in exactly one of LIST1, LIST2.

 This is a non-destructive function; it makes a copy of the data if necessary
 to avoid corrupting the original LIST1 and LIST2.
 
 This is a non-destructive function; it makes a copy of the data if necessary
 to avoid corrupting the original LIST1 and LIST2.
 


@@ -1141,7 +1161,7 @@ Keywords supported:  :test :test-not :key
 
 (autoload 'nset-exclusive-or "cl-seq" "\
 Combine LIST1 and LIST2 using a set-exclusive-or operation.
 
 (autoload 'nset-exclusive-or "cl-seq" "\
 Combine LIST1 and LIST2 using a set-exclusive-or operation.

-The result list contains all items that appear in exactly one of LIST1, LIST2.
+The resulting list contains all items appearing in exactly one of LIST1, LIST2.

 This is a destructive function; it reuses the storage of LIST1 and LIST2
 whenever possible.
 
 This is a destructive function; it reuses the storage of LIST1 and LIST2
 whenever possible.
 


@@ -1228,7 +1248,6 @@ Keywords supported:  :test :test-not :key
 ;; version-control: never
 ;; no-byte-compile: t
 ;; no-update-autoloads: t
 ;; version-control: never
 ;; no-byte-compile: t
 ;; no-update-autoloads: t

+;; coding: utf-8

 ;; End:
 ;; End:

-
-;; arch-tag: 08cc5aab-e992-47f6-992e-12a7428c1a0e

 ;;; cl-loaddefs.el ends here
 ;;; cl-loaddefs.el ends here