X-Git-Url: https://code.delx.au/gnu-emacs/blobdiff_plain/e983096bb6a50fdae6625cb363642bcd74ec39c5..0d8de0fd0a5a63cc9558b5c99f9c7f1ddcaf338a:/lisp/emacs-lisp/cl-loaddefs.el diff --git a/lisp/emacs-lisp/cl-loaddefs.el b/lisp/emacs-lisp/cl-loaddefs.el index 4ac292f207..270211f6a7 100644 --- 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 -;;;;;; 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" "\ @@ -273,8 +273,8 @@ Not documented ;;;*** -;;;### (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 @@ -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* -;;;;;; defmacro* defun* gentemp gensym cl-compile-time-init) "cl-macs" -;;;;;; "cl-macs.el" "d33a3362d98432c0e9ca0b168f85ba93") +;;;;;; defmacro* defun* gentemp gensym) "cl-macs" "cl-macs.el" "9452c0e16fd960fce5c19e5c067a7160") ;;; 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\". @@ -325,7 +319,7 @@ its argument list allows full Common Lisp conventions. \(fn FUNC)" nil (quote macro)) (autoload 'destructuring-bind "cl-macs" "\ -Not documented + \(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. -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. @@ -451,7 +445,7 @@ from OBARRAY. \(fn (VAR [OBARRAY [RESULT]]) BODY...)" nil (quote macro)) (autoload 'do-all-symbols "cl-macs" "\ -Not documented + \(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. -\(fn VARLIST BODY)" nil (quote macro)) +\(fn BINDINGS BODY)" nil (quote macro)) (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. @@ -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" "\ -Not documented + \(fn &rest BODY)" nil (quote macro)) (autoload 'the "cl-macs" "\ -Not documented + \(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)) @@ -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" "\ -Not documented + \(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. -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" "\ -Not documented + \(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. @@ -708,12 +726,6 @@ omitted, a default message listing FORM itself is used. \(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 @@ -729,10 +741,18 @@ and then returning foo. \(fn FUNC ARGS &rest BODY)" nil (quote macro)) (autoload 'compiler-macroexpand "cl-macs" "\ -Not documented + \(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)) + ;;;*** ;;;### (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* -;;;;;; 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" "\ @@ -1071,7 +1091,7 @@ Keywords supported: :key (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. @@ -1081,7 +1101,7 @@ Keywords supported: :test :test-not :key (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. @@ -1091,7 +1111,7 @@ Keywords supported: :test :test-not :key (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. @@ -1101,7 +1121,7 @@ Keywords supported: :test :test-not :key (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. @@ -1111,7 +1131,7 @@ Keywords supported: :test :test-not :key (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. @@ -1121,7 +1141,7 @@ Keywords supported: :test :test-not :key (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. @@ -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. -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. @@ -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. -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. @@ -1228,7 +1248,6 @@ Keywords supported: :test :test-not :key ;; version-control: never ;; no-byte-compile: t ;; no-update-autoloads: t +;; coding: utf-8 ;; End: - -;; arch-tag: 08cc5aab-e992-47f6-992e-12a7428c1a0e ;;; cl-loaddefs.el ends here