;ELC ;;; compiled by kwzh@nutrimat.gnu.ai.mit.edu on Thu Jun 15 18:25:07 1995 ;;; from file /gd/gnu/emacs/19.0/lisp/cl-seq.el ;;; emacs version 19.28.94.3. ;;; bytecomp version FSF 2.10 ;;; optimization is on. ;;; this file uses opcodes which do not exist in Emacs 18. (if (and (boundp 'emacs-version) (or (and (boundp 'epoch::version) epoch::version) (string-lessp emacs-version "19.28.90"))) (error "`cl-seq.el' was compiled for Emacs 19.29 or later")) (byte-code " >\n!" [cl-19 features error "Tried to load `cl-seq' before `cl'!"] 2) (defalias 'cl-push '(macro . #[(x place) " EE" [setq place cons x] 5])) (defalias 'cl-pop '(macro . #[(place) "\n\n\nDEED" [car prog1 place setq cdr] 7])) (defalias 'cl-parsing-keywords '(macro . #[(kwords other-keys &rest body) " \" =?% \"\"DEFFEC\"BB" [let* mapcar #[(x) ":\n@  DEDD =*EF =<EF !O\"!:VA@EX*D" [x var car cdr memq quote cl-keys mem :test-not and setq cl-test t :if-not cl-if intern format "cl-%s" symbol-name 1 nil or] 6] kwords append other-keys t let ((cl-keys-temp cl-keys)) while cl-keys-temp or memq (car cl-keys-temp) quote #[(x) ":@" [x] 1] (car (cdr (memq (quote :allow-other-keys) cl-keys))) (error "Bad keyword argument %s" (car cl-keys-temp)) (setq cl-keys-temp (cdr (cdr cl-keys-temp))) body] 16])) (byte-code "##" [put cl-parsing-keywords lisp-indent-function 2 edebug-form-spec (sexp sexp &rest form)] 4) (defalias 'cl-check-key '(macro . #[(x) " E F" [if cl-key funcall x] 5])) (defalias 'cl-check-test-nokey '(macro . #[(item x) " FDEDEDED D E EFDF" [cond cl-test eq not funcall item x cl-test-not cl-if cl-if-not t if numberp equal] 10])) (defalias 'cl-check-test '(macro . #[(item x) " DE" [cl-check-test-nokey item cl-check-key x] 4])) (defalias 'cl-check-match '(macro . #[(x y) " D\nD \nFDE D \nE \nEFF" [cl-check-key x y if cl-test eq not funcall cl-test-not numberp equal] 9])) (byte-code "####BBBBB" [put cl-check-key edebug-form-spec edebug-forms cl-check-test cl-check-test-nokey cl-check-match cl-test current-load-list cl-test-not cl-if cl-if-not cl-key] 4) #@110 Reduce two-argument FUNCTION across SEQUENCE. Keywords supported: :start :end :from-end :initial-value :key (defalias 'reduce #[(cl-func cl-seq &rest cl-keys) " >A@ >A@ >A@ >A@ >A@ \fM\f@>C >A@C\f@\"\fAA\f,)<[\" #\nm >x   A@!A@ \n  A@!A@\"  A@!A@\"." [:from-end cl-keys cl-from-end :start 0 cl-start :end cl-end :initial-value cl-initial-value :key cl-key cl-keys-temp (:from-end :start :end :initial-value :key) :allow-other-keys error "Bad keyword argument %s" cl-seq append nil subseq cl-func cl-accum] 6 (#$ . 2284)]) #@70 Fill the elements of SEQ with ITEM. Keywords supported: :start :end (defalias 'fill #[(seq item &rest cl-keys) " >A@  >A@ 8@>. >A@.@\"AA) A@  >A@ >A@ >A@ \nJ\n@>@ >A@@\n@\"\nAA\n))= X UG l Z uZ^SY \\\\#{*<;  Z<  Z^SY@AA*7 \fG\\^ 7 W7HAT* BG  KGZ\\^<| Wx @IA T_) W HIT T}," [:start1 cl-keys 0 cl-start1 :end1 cl-end1 :start2 cl-start2 :end2 cl-end2 cl-keys-temp (:start1 :end1 :start2 :end2) :allow-other-keys error "Bad keyword argument %s" cl-seq1 cl-seq2 cl-len cl-n cl-set-elt 4000000 cl-n1 cl-p1 cl-p2] 7 (#$ . 3442)]) #@221 Remove all occurrences of ITEM in SEQ. This is a non-destructive function; it makes a copy of SEQ if necessary to avoid corrupting the original SEQ. Keywords supported: :test :test-not :key :count :start :end :from-end (defalias 'remove* #[(cl-item cl-seq &rest cl-keys) " >A@ >A@ >A@ >A@ >A@ >A@< >A@ < >A@ >A@ >A@U >A@ @>| >A@|@\"AAe) ډ X< W%\"TDD \"$$<$;$$!))\nZUV\nA\n7@!:@\"? = a V@!Y@!? =~w@!z@@!@=SA S V VVVSA&&aVa\n\n&@!&@\"? =Q  &@!&@!? =Q=6&@!9&@QM&@!P&@=a&A&S&V&\" U&A&A&A!S S &\n). " [:test cl-keys cl-test :test-not t cl-test-not :key cl-key :if cl-if :if-not cl-if-not :count cl-count :from-end cl-from-end :start 0 cl-start :end cl-end cl-keys-temp (:test :test-not :key :if :if-not :count :from-end :start :end) :allow-other-keys error "Bad keyword argument %s" 8000000 cl-seq 4000000 cl-position cl-item cl-i apply delete* append nil cl-res vconcat cl-p ldiff 1 copy-sequence] 13 (#$ . 4330)]) #@212 Remove all items satisfying PREDICATE in SEQ. This is a non-destructive function; it makes a copy of SEQ if necessary to avoid corrupting the original SEQ. Keywords supported: :key :count :start :end :from-end (defalias 'remove-if #[(cl-pred cl-list &rest cl-keys) " &" [apply remove* nil cl-list :if cl-pred cl-keys] 7 (#$ . 5722)]) #@216 Remove all items not satisfying PREDICATE in SEQ. This is a non-destructive function; it makes a copy of SEQ if necessary to avoid corrupting the original SEQ. Keywords supported: :key :count :start :end :from-end (defalias 'remove-if-not #[(cl-pred cl-list &rest cl-keys) " &" [apply remove* nil cl-list :if-not cl-pred cl-keys] 7 (#$ . 6073)]) #@191 Remove all occurrences of ITEM in SEQ. This is a destructive function; it reuses the storage of SEQ whenever possible. Keywords supported: :test :test-not :key :count :start :end :from-end (defalias 'delete* #[(cl-item cl-seq &rest cl-keys) " >A@ >A@ >A@ >A@ >A@ >A@< >A@ < >A@ >A@ >A@U >A@ @>| >A@|@\"AAe) ډ X~  !\" " [x y delq copy-list] 4]) #@123 Return a copy of SEQ with all duplicate elements removed. Keywords supported: :test :test-not :key :start :end :from-end (defalias 'remove-duplicates #[(cl-seq &rest cl-keys) " \n#" [cl-delete-duplicates cl-seq cl-keys t] 4 (#$ . 8636)]) #@121 Remove all duplicate elements from SEQ (destructively). Keywords supported: :test :test-not :key :start :end :from-end (defalias 'delete-duplicates #[(cl-seq &rest cl-keys) " \n#" [cl-delete-duplicates cl-seq cl-keys nil] 4 (#$ . 8885)]) (defalias 'cl-delete-duplicates #[(cl-seq cl-keys cl-copy) "<\n>A@\n>A@\n>A@\n>A@\n>A@0 \n>A@ \n>A@\n>A@\no@>e\n>A@e@\"AAN)  G Z  V@!@A S$! AA) S A S  T * G Z A8 U8 V8!@!#@A S$8A S  VG SP S  AA VpA@!tA@AA S$! SAAA S  T R).\"\n#!;!!!)" [cl-seq :test cl-keys cl-test :test-not t cl-test-not :key cl-key :start 0 cl-start :end cl-end :from-end cl-from-end :if cl-if cl-keys-temp (:test :test-not :key :start :end :from-end :if) :allow-other-keys error "Bad keyword argument %s" nil cl-i cl-p 1 cl-position cl-copy copy-sequence cl-tail cl-delete-duplicates append cl-res vconcat] 6]) #@213 Substitute NEW for OLD in SEQ. This is a non-destructive function; it makes a copy of SEQ if necessary to avoid corrupting the original SEQ. Keywords supported: :test :test-not :key :count :start :end :from-end (defalias 'substitute #[(cl-new cl-old cl-seq &rest cl-keys) " >A@ >A@ >A@ >A@ >A@ >A@< >A@ < >A@ >A@N >A@ >A@ @>| >A@|@\"AAe)= ݉ X$ ! # T  S   & ). " [:test cl-keys cl-test :test-not t cl-test-not :key cl-key :if cl-if :if-not cl-if-not :count cl-count :start 0 cl-start :end cl-end :from-end cl-from-end cl-keys-temp (:test :test-not :key :if :if-not :count :start :end :from-end) :allow-other-keys error "Bad keyword argument %s" cl-old cl-new nil 8000000 cl-seq cl-position cl-i copy-sequence cl-set-elt apply nsubstitute] 11 (#$ . 10019)]) #@224 Substitute NEW for all items satisfying PREDICATE in SEQ. This is a non-destructive function; it makes a copy of SEQ if necessary to avoid corrupting the original SEQ. Keywords supported: :key :count :start :end :from-end (defalias 'substitute-if #[(cl-new cl-pred cl-list &rest cl-keys) "\n\f&" [apply substitute cl-new nil cl-list :if cl-pred cl-keys] 8 (#$ . 10934)]) #@228 Substitute NEW for all items not satisfying PREDICATE in SEQ. This is a non-destructive function; it makes a copy of SEQ if necessary to avoid corrupting the original SEQ. Keywords supported: :key :count :start :end :from-end (defalias 'substitute-if-not #[(cl-new cl-pred cl-list &rest cl-keys) "\n\f&" [apply substitute cl-new nil cl-list :if-not cl-pred cl-keys] 8 (#$ . 11323)]) #@183 Substitute NEW for OLD in SEQ. This is a destructive function; it reuses the storage of SEQ whenever possible. Keywords supported: :test :test-not :key :count :start :end :from-end (defalias 'nsubstitute #[(cl-new cl-old cl-seq &rest cl-keys) " >A@ >A@ >A@ >A@ >A@ >A@< >A@ < >A@ >A@N >A@ >A@ @>| >A@|@\"AAe)= ܉ XA@ >A@ >A@ >A@ >A@ >A@< >A@ < >A@G >A@ >A@ @>u >A@u@\"AA^)%." [:test cl-keys cl-test :test-not t cl-test-not :key cl-key :if cl-if :if-not cl-if-not :start 0 cl-start :end cl-end :from-end cl-from-end cl-keys-temp (:test :test-not :key :if :if-not :start :end :from-end) :allow-other-keys error "Bad keyword argument %s" cl-position cl-item cl-seq] 7 (#$ . 14655)]) (defalias 'cl-position #[(cl-item cl-seq cl-start &optional cl-end cl-from-end) "<  \n W&F \n<\n\n@!>\n@\"? =\fd\f\nZ\n\n@!\\\n@!? =  \ny\n\n@!{\n@ \n\n\n@!\n@= \nA T* G7 S Y/ \n\n H! H\"? =,\f\f\n\n H! H!? =,  \n\n H! H, \n(\n H!+ H= Y W_ \nT\n H!W H\"? =\f\f\nt\n H!w H!? =  \n\n H! H \n\n H! H= T8 W " [cl-seq cl-start cl-p cl-end 8000000 nil cl-res cl-from-end cl-test cl-item cl-key cl-test-not cl-if cl-if-not] 6]) #@159 Find the first item satisfying PREDICATE in LIST. Return the index of the matching item, or nil if not found. Keywords supported: :key :start :end :from-end (defalias 'position-if #[(cl-pred cl-list &rest cl-keys) " &" [apply position nil cl-list :if cl-pred cl-keys] 7 (#$ . 16026)]) #@163 Find the first item not satisfying PREDICATE in LIST. Return the index of the matching item, or nil if not found. Keywords supported: :key :start :end :from-end (defalias 'position-if-not #[(cl-pred cl-list &rest cl-keys) " &" [apply position nil cl-list :if-not cl-pred cl-keys] 7 (#$ . 16328)]) #@104 Count the number of occurrences of ITEM in LIST. Keywords supported: :test :test-not :key :start :end (defalias 'count #[(cl-item cl-seq &rest cl-keys) " >A@ >A@ >A@ >A@ >A@ >A@< >A@ < >A@G >A@ x@>n >A@n@\"AAW)G:W.:A@H\n\n!\"? =  !!? = !!=%TT. " [:test cl-keys cl-test :test-not t cl-test-not :key cl-key :if cl-if :if-not cl-if-not :start 0 cl-start :end cl-end cl-keys-temp (:test :test-not :key :if :if-not :start :end) :allow-other-keys error "Bad keyword argument %s" nil cl-x cl-count cl-seq cl-item] 5 (#$ . 16642)]) #@95 Count the number of items satisfying PREDICATE in LIST. Keywords supported: :key :start :end (defalias 'count-if #[(cl-pred cl-list &rest cl-keys) " &" [apply count nil cl-list :if cl-pred cl-keys] 7 (#$ . 17393)]) #@99 Count the number of items not satisfying PREDICATE in LIST. Keywords supported: :key :start :end (defalias 'count-if-not #[(cl-pred cl-list &rest cl-keys) " &" [apply count nil cl-list :if-not cl-pred cl-keys] 7 (#$ . 17624)]) #@286 Compare SEQ1 with SEQ2, return index of first mismatching element. Return nil if the sequences match. If one sequence is a prefix of the other, the return value indicates the end of the shorted sequence. Keywords supported: :test :test-not :key :start1 :end1 :start2 :end2 :from-end (defalias 'mismatch #[(cl-seq1 cl-seq2 &rest cl-keys) " >A@ >A@ >A@ >A@ >A@ >A@1\f >A@ >A@C >A@ t@>j >A@j@\"AAS)GG z\fWdWd\n\nS!SS!S\"? =TS!S%S!\nSS!!ST6S!<SMS!SS=dSS\fWtWS<\f<\fWW\n\n@\fH!@\fH@H!@H\"? =!@\fH!1,@1\fHPG@L\fH!`[@`\fH{r@wH!@H@\fH!@\fH@H!@H=AA\fT\fT\fWW\f*." [:test cl-keys cl-test :test-not t cl-test-not :key cl-key :from-end cl-from-end :start1 0 cl-start1 :end1 cl-end1 :start2 cl-start2 :end2 cl-end2 cl-keys-temp (:test :test-not :key :from-end :start1 :end1 :start2 :end2) :allow-other-keys error "Bad keyword argument %s" cl-seq1 cl-seq2 cl-p2 cl-p1] 6 (#$ . 17868)]) #@226 Search for SEQ1 as a subsequence of SEQ2. Return the index of the leftmost element of the first match found; return nil if there are no matches. Keywords supported: :test :test-not :key :start1 :end1 :start2 :end2 :from-end (defalias 'search #[(cl-seq1 cl-seq2 &rest cl-keys) " >A@ >A@ >A@ >A@ >A@ >A@1\f >A@ >A@C >A@ t@>j >A@j@\"AAS)GG\fY %%\fZ\f!\fSZW %\fTT\\ & TW$,." [:test cl-keys cl-test :test-not t cl-test-not :key cl-key :from-end cl-from-end :start1 0 cl-start1 :end1 cl-end1 :start2 cl-start2 :end2 cl-end2 cl-keys-temp (:test :test-not :key :from-end :start1 :end1 :start2 :end2) :allow-other-keys error "Bad keyword argument %s" cl-seq1 cl-seq2 cl-len cl-first nil cl-if cl-pos cl-position apply mismatch] 16 (#$ . 19349)]) #@157 Sort the argument SEQUENCE according to PREDICATE. This is a destructive function; it reuses the storage of SEQUENCE if possible. Keywords supported: :key (defalias 'sort* #[(cl-seq cl-pred &rest cl-keys) "<\"$\">A@ \nF\n@><>A@<\n@\"\nAA\n$) >V\"Z\")" [cl-seq replace apply sort* append nil cl-pred cl-keys :key cl-key cl-keys-temp (:key) :allow-other-keys error "Bad keyword argument %s" (nil identity) sort #[(cl-x cl-y) " \n! !\"" [cl-pred cl-key cl-x cl-y] 4]] 8 (#$ . 20306)]) #@164 Sort the argument SEQUENCE stably according to PREDICATE. This is a destructive function; it reuses the storage of SEQUENCE if possible. Keywords supported: :key (defalias 'stable-sort #[(cl-seq cl-pred &rest cl-keys) "\n \f$" [apply sort* cl-seq cl-pred cl-keys] 5 (#$ . 20857)]) #@228 Destructively merge the two sequences to produce a new sequence. TYPE is the sequence type to return, SEQ1 and SEQ2 are the two argument sequences, and PRED is a `less-than' predicate on the elements. Keywords supported: :key (defalias 'merge #[(cl-type cl-seq1 cl-seq2 cl-pred &rest cl-keys) "<\n\" < \" >A@ C@>9 >A@9@\"AA\")\f  ^ @!` @m@!o@\" A@\fB\fGA@\fB\fG\f \"*" [cl-seq1 append nil cl-seq2 :key cl-keys cl-key cl-keys-temp (:key) :allow-other-keys error "Bad keyword argument %s" cl-res cl-pred coerce cl-type] 5 (#$ . 21149)]) #@132 Find the first occurrence of ITEM in LIST. Return the sublist of LIST whose car is ITEM. Keywords supported: :test :test-not :key (defalias 'member* #[(cl-item cl-list &rest cl-keys) ">A@>A@>A@>A@>A@ >A@@>A@ @ \fj\f@>`>A@`\f@\"\fAA\fI)\n\n@!@\"? =  @!@!? =@!@@!@=Ap->" [cl-keys :test cl-test :test-not t cl-test-not :key cl-key :if cl-if :if-not cl-if-not cl-keys-temp (:test :test-not :key :if :if-not) :allow-other-keys error "Bad keyword argument %s" cl-list cl-item] 5 (#$ . 21786)]) #@123 Find the first item satisfying PREDICATE in LIST. Return the sublist of LIST whose car matches. Keywords supported: :key (defalias 'member-if #[(cl-pred cl-list &rest cl-keys) " &" [apply member* nil cl-list :if cl-pred cl-keys] 7 (#$ . 22472)]) #@127 Find the first item not satisfying PREDICATE in LIST. Return the sublist of LIST whose car matches. Keywords supported: :key (defalias 'member-if-not #[(cl-pred cl-list &rest cl-keys) " &" [apply member* nil cl-list :if-not cl-pred cl-keys] 7 (#$ . 22735)]) (defalias 'cl-adjoin #[(cl-item cl-list &rest cl-keys) " >A@\n\n !  $) B" [:key cl-keys cl-key apply member* cl-item cl-list] 5]) #@95 Find the first item whose car matches ITEM in LIST. Keywords supported: :test :test-not :key (defalias 'assoc* #[(cl-item cl-alist &rest cl-keys) ">A@>A@>A@>A@>A@ >A@@>A@ @ \fj\f@>`>A@`\f@\"\fAA\fI)@:\n\n@@!@@\"? =  @@!@@!? =@@!@@@@!@@=Ap@-\"" [cl-keys :test cl-test :test-not t cl-test-not :key cl-key :if cl-if :if-not cl-if-not cl-keys-temp (:test :test-not :key :if :if-not) :allow-other-keys error "Bad keyword argument %s" cl-alist cl-item assoc] 5 (#$ . 23160)]) #@86 Find the first item whose car satisfies PREDICATE in LIST. Keywords supported: :key (defalias 'assoc-if #[(cl-pred cl-list &rest cl-keys) " &" [apply assoc* nil cl-list :if cl-pred cl-keys] 7 (#$ . 23838)]) #@93 Find the first item whose car does not satisfy PREDICATE in LIST. Keywords supported: :key (defalias 'assoc-if-not #[(cl-pred cl-list &rest cl-keys) " &" [apply assoc* nil cl-list :if-not cl-pred cl-keys] 7 (#$ . 24061)]) #@95 Find the first item whose cdr matches ITEM in LIST. Keywords supported: :test :test-not :key (defalias 'rassoc* #[(cl-item cl-alist &rest cl-keys) " >A@>A@\">A@\">A@>A@\n>A@F>A@\nF\f p @>f>A@f @\" AA O)@: @A!@A\"?=\n\n@A!@A!?\f= @A!@A @A!@A=Av@- \"" [cl-keys cl-item :test cl-test :test-not t cl-test-not :key cl-key :if cl-if :if-not cl-if-not cl-keys-temp (:test :test-not :key :if :if-not) :allow-other-keys error "Bad keyword argument %s" cl-alist rassq] 5 (#$ . 24299)]) (defalias 'rassoc #[(item alist) " \n$" [rassoc* item alist :test equal] 5]) #@86 Find the first item whose cdr satisfies PREDICATE in LIST. Keywords supported: :key (defalias 'rassoc-if #[(cl-pred cl-list &rest cl-keys) " &" [apply rassoc* nil cl-list :if cl-pred cl-keys] 7 (#$ . 25044)]) #@93 Find the first item whose cdr does not satisfy PREDICATE in LIST. Keywords supported: :key (defalias 'rassoc-if-not #[(cl-pred cl-list &rest cl-keys) " &" [apply rassoc* nil cl-list :if-not cl-pred cl-keys] 7 (#$ . 25269)]) #@296 Combine LIST1 and LIST2 using a set-union operation. The result 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. Keywords supported: :test :test-not :key (defalias 'union #[(cl-list1 cl-list2 &rest cl-keys) " \f G GY  M\n. @9 @\n$E @>E @B A " [cl-list1 cl-list2 cl-keys apply adjoin] 5 (#$ . 25510)]) #@261 Combine LIST1 and LIST2 using a set-union operation. The result 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. Keywords supported: :test :test-not :key (defalias 'nunion #[(cl-list1 cl-list2 &rest cl-keys) " \f \f$" [cl-list1 cl-list2 apply union cl-keys] 5 (#$ . 26008)]) #@302 Combine LIST1 and LIST2 using a set-intersection operation. The result 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. Keywords supported: :test :test-not :key (defalias 'intersection #[(cl-list1 cl-list2 &rest cl-keys) "   >A@ 9 @>1 >A@1 @\" AA) G GYI  W @l\fd\f @!f @ $p @>z @ B AI *" [cl-list1 cl-list2 :key cl-keys cl-key cl-keys-temp (:key :test :test-not) :allow-other-keys error "Bad keyword argument %s" nil cl-res apply member*] 6 (#$ . 26410)]) #@267 Combine LIST1 and LIST2 using a set-intersection operation. The result 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. Keywords supported: :test :test-not :key (defalias 'nintersection #[(cl-list1 cl-list2 &rest cl-keys) "  \f$" [cl-list1 cl-list2 apply intersection cl-keys] 5 (#$ . 27086)]) #@299 Combine LIST1 and LIST2 using a set-difference operation. The result 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. Keywords supported: :test :test-not :key (defalias 'set-difference #[(cl-list1 cl-list2 &rest cl-keys) " \n >A@ 3 @>+ >A@+ @\" AA) p E@Z\fR\f@!T@ $^@ >h@ B A7 *" [cl-list1 cl-list2 :key cl-keys cl-key cl-keys-temp (:key :test :test-not) :allow-other-keys error "Bad keyword argument %s" nil cl-res apply member*] 6 (#$ . 27503)]) #@264 Combine LIST1 and LIST2 using a set-difference operation. The result 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. Keywords supported: :test :test-not :key (defalias 'nset-difference #[(cl-list1 cl-list2 &rest cl-keys) " \n \f$" [cl-list1 cl-list2 apply set-difference cl-keys] 5 (#$ . 28161)]) #@309 Combine LIST1 and LIST2 using a set-exclusive-or operation. The result list contains all items that appear 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. Keywords supported: :test :test-not :key (defalias 'set-exclusive-or #[(cl-list1 cl-list2 &rest cl-keys) " \f ‡ $ $\"" [cl-list1 cl-list2 nil append apply set-difference cl-keys] 7 (#$ . 28582)]) #@274 Combine LIST1 and LIST2 using a set-exclusive-or operation. The result list contains all items that appear in exactly one of LIST1, LIST2. This is a destructive function; it reuses the storage of LIST1 and LIST2 whenever possible. Keywords supported: :test :test-not :key (defalias 'nset-exclusive-or #[(cl-list1 cl-list2 &rest cl-keys) " \f ‡ $  $" [cl-list1 cl-list2 nil apply nset-difference cl-keys] 6 (#$ . 29080)]) #@134 True if LIST1 is a subset of LIST2. I.e., if every element of LIST1 also appears in LIST2. Keywords supported: :test :test-not :key (defalias 'subsetp #[(cl-list1 cl-list2 &rest cl-keys) "\n\fÇ\n >A@ C@>9 >A@9@\"AA\")gW@!Y@\n $gAD)?" [cl-list1 t cl-list2 nil :key cl-keys cl-key cl-keys-temp (:key :test :test-not) :allow-other-keys error "Bad keyword argument %s" apply member*] 6 (#$ . 29534)]) #@169 Substitute NEW for elements matching PREDICATE in TREE (non-destructively). Return a copy of TREE with all matching elements replaced by NEW. Keywords supported: :key (defalias 'subst-if #[(cl-new cl-pred cl-tree &rest cl-keys) " BC\f&" [apply sublis nil cl-new cl-tree :if cl-pred cl-keys] 7 (#$ . 30008)]) #@173 Substitute NEW for elts not matching PREDICATE in TREE (non-destructively). Return a copy of TREE with all non-matching elements replaced by NEW. Keywords supported: :key (defalias 'subst-if-not #[(cl-new cl-pred cl-tree &rest cl-keys) " BC\f&" [apply sublis nil cl-new cl-tree :if-not cl-pred cl-keys] 7 (#$ . 30334)]) #@188 Substitute NEW for OLD everywhere in TREE (destructively). Any element of TREE which is `eql' to OLD is changed to NEW (via a call to `setcar'). Keywords supported: :test :test-not :key (defalias 'nsubst #[(cl-new cl-old cl-tree &rest cl-keys) "\n BC\f $" [apply nsublis cl-old cl-new cl-tree cl-keys] 5 (#$ . 30672)]) #@177 Substitute NEW for elements matching PREDICATE in TREE (destructively). Any element of TREE which matches is changed to NEW (via a call to `setcar'). Keywords supported: :key (defalias 'nsubst-if #[(cl-new cl-pred cl-tree &rest cl-keys) " BC\f&" [apply nsublis nil cl-new cl-tree :if cl-pred cl-keys] 7 (#$ . 31002)]) #@181 Substitute NEW for elements not matching PREDICATE in TREE (destructively). Any element of TREE which matches is changed to NEW (via a call to `setcar'). Keywords supported: :key (defalias 'nsubst-if-not #[(cl-new cl-pred cl-tree &rest cl-keys) " BC\f&" [apply nsublis nil cl-new cl-tree :if-not cl-pred cl-keys] 7 (#$ . 31338)]) #@172 Perform substitutions indicated by ALIST in TREE (non-destructively). Return a copy of TREE with all matching elements replaced. Keywords supported: :test :test-not :key (defalias 'sublis #[(cl-alist cl-tree &rest cl-keys) " >A@ >A@ >A@ >A@ >A@ >A@< >A@ < \ff\f@>\\ >A@\\\f@\"\fAA\fE)!-" [:test cl-keys cl-test :test-not t cl-test-not :key cl-key :if cl-if :if-not cl-if-not cl-keys-temp (:test :test-not :key :if :if-not) :allow-other-keys error "Bad keyword argument %s" cl-sublis-rec cl-tree] 4 (#$ . 31686)]) (byte-code " B" [cl-alist current-load-list] 2) (defalias 'cl-sublis-rec #[(cl-tree) "\n ! \n Q # @@\f\"?=G3\f!?=G @@B @@\fG @@\f=Q A [ @A : @! A!\n @=\n A=  \nB* *" [cl-key cl-tree cl-alist cl-p cl-temp cl-test cl-test-not cl-if cl-if-not cl-sublis-rec cl-d cl-a] 4]) #@173 Perform substitutions indicated by ALIST in TREE (destructively). Any matching element of TREE is changed via a call to `setcar'. Keywords supported: :test :test-not :key (defalias 'nsublis #[(cl-alist cl-tree &rest cl-keys) " >A@ >A@ >A@ >A@ >A@ >A@< >A@ < \ff\f@>\\ >A@\\\f@\"\fAA\fE)C!@." [:test cl-keys cl-test :test-not t cl-test-not :key cl-key :if cl-if :if-not cl-if-not cl-keys-temp (:test :test-not :key :if :if-not) :allow-other-keys error "Bad keyword argument %s" cl-tree cl-hold cl-nsublis-rec] 4 (#$ . 32606)]) (defalias 'cl-nsublis-rec #[(cl-tree) ":  @!@\n X * @@\f\"?=N:\f!?=N @@I @@\fN @@\f=X A e @Ap@:p@! { A!}A\n @@\f\"?=\f!?= @@ @@\f @@\f= A  @AA*" [cl-tree cl-key cl-alist cl-p cl-temp cl-test cl-test-not cl-if cl-if-not cl-nsublis-rec nil] 4]) #@147 T if trees X and Y have `eql' leaves. Atoms are compared by `eql'; cons cells are compared recursively. Keywords supported: :test :test-not :key (defalias 'tree-equal #[(cl-x cl-y &rest cl-keys) " >A@ >A@ >A@ >A@ I@>? >A@?@\"AA()\"+" [:test cl-keys cl-test :test-not t cl-test-not :key cl-key cl-keys-temp (:test :test-not :key) :allow-other-keys error "Bad keyword argument %s" cl-tree-equal-rec cl-x cl-y] 4 (#$ . 33572)]) (defalias 'cl-tree-equal-rec #[(cl-x cl-y) ": :@ @\"A A:? :? H \f7\f!8\fB\f !C \"? =\fR\f!So\fa\f!b\fl\f !m \fy\f!z\f\f ! =" [cl-x cl-y cl-tree-equal-rec cl-test cl-key cl-test-not] 4]) (run-hooks (quote cl-seq-load-hook))