;ELC ;;; Compiled ;;; in Emacs version 29.4 ;;; with all optimizations. #@180 Loop over a SEQUENCE, evaluating BODY with VAR bound to each of its elements. Similar to `dolist' but can be applied to lists, strings, and vectors. (fn (VAR SEQUENCE) BODY...) (defalias 'seq-doseq '(macro . #[385 "\300\301@CBBA@E\207" [seq-do lambda] 6 (#$ . 84)])) (byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put seq-doseq lisp-indent-function 1 put edebug-form-spec ((symbolp form &optional form) body)] 5)#@287 Build a `pcase' pattern that matches elements of SEQUENCE. The `pcase' pattern will match each element of PATTERNS against the corresponding element of SEQUENCE. Extra elements of the sequence are ignored if fewer PATTERNS are given, and the match does not fail. (fn &rest PATTERNS) (defalias 'seq--pcase-macroexpander #[128 "\300\301\302!BB\207" [and (pred seqp) seq--make-pcase-bindings] 5 (#$ . 523)]) (byte-code "\300\301\302\303#\300\304\305\301#\303\207" [define-symbol-prop seq--pcase-macroexpander edebug-form-spec nil seq pcase-macroexpander] 5)#@215 Bind the variables in ARGS to the elements of SEQUENCE, then evaluate BODY. ARGS can also include the `&rest' marker followed by a variable name to be bound to the rest of SEQUENCE. (fn ARGS SEQUENCE &rest BODY) (defalias 'seq-let '(macro . #[642 "\300\301!DCBB\207" [pcase-let seq--make-pcase-patterns] 6 (#$ . 1088)])) (byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put seq-let lisp-indent-function 2 put edebug-form-spec (sexp form body)] 5)#@186 Assign the elements of SEQUENCE to the variables in ARGS. ARGS can also include the `&rest' marker followed by a variable name to be bound to the rest of SEQUENCE. (fn ARGS SEQUENCE) (defalias 'seq-setq '(macro . #[514 "\300\301!E\207" [pcase-setq seq--make-pcase-patterns] 5 (#$ . 1559)])) (byte-code "\300\301\302\303#\210\304\305\306\305\307\310#\311#\210\312\305\310\307\310\313%\210\312\314\310\315\310\316%\210\312\314\310\317\310\320%\210\304\321\306\321\322\310#\323#\210\312\321\310\322\310\324%\207" [put seq-setq edebug-form-spec (sexp form) defalias seq-elt cl-generic-define (sequence n) nil "Return the Nth element of SEQUENCE.\n\n(fn SEQUENCE N)" cl-generic-define-method #[514 "\234\207" #1=[] 4 "\n\n(fn SEQUENCE N)"] \(setf\ seq-elt\) (store (sequence array) n) #[771 "I\207" #1# 6 "\n\n(fn STORE SEQUENCE N)"] (store (sequence cons) n) #[771 "\211\233\240\207" #1# 5 "\n\n(fn STORE SEQUENCE N)"] seq-length (sequence) "Return the number of elements in SEQUENCE.\n\n(fn SEQUENCE)" #[257 "\211G\207" #1# 2 "\n\n(fn SEQUENCE)"]] 6)#@54 Return the first element of SEQUENCE. (fn SEQUENCE) (defalias 'seq-first #[257 "\300\301\"\207" [seq-elt 0] 4 (#$ . 2623)])#@64 Return SEQUENCE with its first element removed. (fn SEQUENCE) (defalias 'seq-rest #[257 "\300\301\"\207" [seq-drop 1] 4 (#$ . 2754)]) (byte-code "\300\301\302\301\303\304#\305#\210\306\301\304\303\304\307%\210\300\310\301\"\207" [defalias seq-do cl-generic-define #'sequence nil "Apply FUNCTION to each element of SEQUENCE.\nPresumably, FUNCTION has useful side effects.\nReturn SEQUENCE.\n\n(fn FUNCTION SEQUENCE)" cl-generic-define-method #[514 "\300\"\207" [mapc] 5 "\n\n(fn FUNCTION SEQUENCE)"] seq-each] 6)#@196 Apply FUNCTION to each element of SEQUENCE and return nil. Unlike `seq-map', FUNCTION takes two arguments: the element of the sequence, and its index within the sequence. (fn FUNCTION SEQUENCE) (defalias 'seq-do-indexed #[514 "\300C\301\302\303#\"\266\304\207" [0 seq-do make-closure #[257 "\301\300\242\"\210\300\211\242T\240\207" [V0 V1] 4 "\n\n(fn ELT)"] nil] 8 (#$ . 3276)]) (byte-code "\300\301\302\301\303\304#\305#\210\306\301\304\303\304\307%\210\300\310\302\310\311\304#\312#\210\306\310\304\311\304\313%\210\300\314\302\314\315\304#\316#\210\306\314\304\315\304\317%\210\300\320\302\320\321\304#\322#\210\306\320\304\321\304\323%\207" [defalias seqp cl-generic-define (object) nil "Return non-nil if OBJECT is a sequence, nil otherwise.\n\n(fn OBJECT)" cl-generic-define-method #[257 "\300!\207" [sequencep] 3 "\n\n(fn OBJECT)"] seq-copy (sequence) "Return a shallow copy of SEQUENCE.\n\n(fn SEQUENCE)" #[257 "\300!\207" [copy-sequence] 3 "\n\n(fn SEQUENCE)"] seq-subseq (sequence start &optional end) "Return the sequence of elements of SEQUENCE from START to END.\nEND is exclusive.\n\nIf END is omitted, it defaults to the length of the sequence. If\nSTART or END is negative, it counts from the end. Signal an\nerror if START or END are outside of the sequence (i.e too large\nif positive or too small if negative).\n\n(fn SEQUENCE START &optional END)" #[770 ";\204 \300!\203O\207<\203\233\301\211\203,\302W\203,G\211\262\\\262\302W\203@\206=G\211\262\\\262\302Y\204K\303\304\"\210\302V\203eS\233\262\204a\303\304\"\210A\262\203\226Z\211\302W\204\213\203|V\202\210\211\302V\203\220\211S\233?\203\220\303\305\"\210\306\"\207\307!\207\303\310\"\207" [vectorp nil 0 error "Start index out of bounds: %s" "End index out of bounds: %s" take copy-sequence "Unsupported sequence: %s"] 10 "\n\n(fn SEQUENCE START &optional END)"] seq-map #'sequence "Return the result of applying FUNCTION to each element of SEQUENCE.\n\n(fn FUNCTION SEQUENCE)" #[514 "\300C\301\302\303#\"\210\211\242\237\207" [nil seq-do make-closure #[257 "\300\301!\300\242B\240\207" [V0 V1] 4 "\n\n(fn ELT)"]] 8 "\n\n(fn FUNCTION SEQUENCE)"]] 6)#@205 Return the result of applying FUNCTION to each element of SEQUENCE. Unlike `seq-map', FUNCTION takes two arguments: the element of the sequence, and its index within the sequence. (fn FUNCTION SEQUENCE) (defalias 'seq-map-indexed #[514 "\300C\301\302\303#\"\207" [0 seq-map make-closure #[257 "\301\300\242\"\300\211\242T\240\210\207" [V0 V1] 4 "\n\n(fn ELT)"]] 8 (#$ . 5486)]) (byte-code "\300\301\302\303\302\304%\210\305\306\307\306\310\302#\311#\210\300\306\302\310\302\312%\210\305\313\307\313\314\302#\315#\210\300\313\302\314\302\316%\210\305\317\307\317\320\302#\321#\210\300\317\302\320\302\322%\210\305\323\307\323\324\302#\325#\210\300\323\302\324\302\326%\210\305\327\307\327\330\302#\331#\210\300\327\302\330\302\332%\210\305\333\307\333\334\302#\335#\210\300\333\302\334\302\336%\210\305\337\307\337\340\302#\341#\210\300\337\302\340\302\342%\210\300\337\302\343\302\344%\207" [cl-generic-define-method seq-map nil #'(sequence sequence) #[514 "\300\"\207" [mapcar] 5 "\n\n(fn FUNCTION SEQUENCE)"] defalias seq-mapn cl-generic-define (function sequence &rest sequences) "Return the result of applying FUNCTION to each element of SEQUENCEs.\nLike `seq-map', but FUNCTION is mapped over all SEQUENCEs.\nThe arity of FUNCTION must match the number of SEQUENCEs, and the\nmapping stops on the shortest sequence.\nReturn a list of the results.\n\n(fn FUNCTION SEQUENCES...)" #[642 "\300\301\302B\"\300>\204!\303\301\304\"\"B\262\301\305\"\262\202\237\207" [nil seq-map #[257 "\300\301\"\207" [seq-into list] 4 "\n\n(fn S)"] apply car cdr] 10 "\n\n(fn FUNCTION SEQUENCE &rest SEQUENCES)"] seq-drop (sequence n) "Remove the first N elements of SEQUENCE and return the resulting sequence.\nThe result is a sequence of the same type as SEQUENCE.\n\nIf N is a negative integer or zero, SEQUENCE is returned.\n\n(fn SEQUENCE N)" #[514 "\211\300X\203\207\301!\302^#\207" [0 seq-length seq-subseq] 7 "\n\n(fn SEQUENCE N)"] seq-take (sequence n) "Return the sequence made of the first N elements of SEQUENCE.\nThe result is a sequence of the same type as SEQUENCE.\n\nIf N is a negative integer or zero, an empty sequence is\nreturned.\n\n(fn SEQUENCE N)" #[514 "\300\301\301]\302!^#\207" [seq-subseq 0 seq-length] 8 "\n\n(fn SEQUENCE N)"] seq-drop-while (pred sequence) "Remove the successive elements of SEQUENCE for which PRED returns non-nil.\nPRED is a function of one argument. The function keeps removing\nelements from SEQUENCE until PRED returns nil for an element.\nValue is a sequence of the same type as SEQUENCE.\n\n(fn PRED SEQUENCE)" #[514 "\300\301\"\"\207" [seq-drop seq--count-successive] 7 "\n\n(fn PRED SEQUENCE)"] seq-take-while (pred sequence) "Take the successive elements of SEQUENCE for which PRED returns non-nil.\nPRED is a function of one argument. The function keeps collecting\nelements from SEQUENCE and adding them to the result until PRED\nreturns nil for an element.\nValue is a sequence of the same type as SEQUENCE.\n\n(fn PRED SEQUENCE)" #[514 "\300\301\"\"\207" [seq-take seq--count-successive] 7 "\n\n(fn PRED SEQUENCE)"] seq-empty-p (sequence) "Return non-nil if the SEQUENCE is empty, nil otherwise.\n\n(fn SEQUENCE)" #[257 "\300!\301U\207" [seq-length 0] 3 "\n\n(fn SEQUENCE)"] seq-sort (pred sequence) "Sort SEQUENCE using PRED as the sorting comparison function.\nThe result is a sequence of the same type as SEQUENCE.\n\n(fn PRED SEQUENCE)" #[514 "\300\301\302\"\"\303\304!\"\207" [seq-sort append nil seq-into type-of] 7 "\n\n(fn PRED SEQUENCE)"] (pred (list list)) #[514 "\300\301!\"\207" [sort seq-copy] 5 "\n\n(fn PRED LIST)"]] 6)#@223 Sort SEQUENCE transformed by FUNCTION using PRED as the comparison function. Elements of SEQUENCE are transformed by FUNCTION before being sorted. FUNCTION must be a function of one argument. (fn FUNCTION PRED SEQUENCE) (defalias 'seq-sort-by #[771 "\300\301\302#\"\207" [seq-sort make-closure #[514 "\300\301!\301!\"\207" [V0 V1] 6 "\n\n(fn A B)"]] 8 (#$ . 9120)]) (byte-code "\300\301\302\301\303\304#\305#\210\306\301\304\303\304\307%\210\306\301\304\310\304\311%\210\300\312\302\312\313\304#\314#\210\306\312\304\313\304\315%\210\300\316\302\316\317\304#\320#\210\306\316\304\317\304\321%\210\300\322\302\322\323\304#\324#\210\306\322\304\323\304\325%\210\300\326\302\326\327\304#\330#\210\306\326\304\327\304\331%\210\300\332\302\332\333\304#\334#\210\306\332\304\333\304\335%\210\300\336\302\336\337\304#\340#\210\306\336\304\337\304\341%\210\300\342\302\342\343\304#\344#\210\306\342\304\343\304\345%\210\300\346\302\346\347\304#\350#\210\306\346\304\347\304\351%\210\300\352\302\352\353\304#\354#\210\306\352\304\353\304\355%\210\300\356\302\356\357\304#\360#\210\306\356\304\357\304\361%\210\300\362\302\362\363\304#\364#\210\306\362\304\363\304\365%\210\300\366\302\366\367\304#\370#\210\306\366\304\367\304\371%\210\372\366\373\374#\210\300\373\302\373\375\304#\376#\210\306\373\304\375\304\377%\210\300\201@\302\201@\201A\304#\201B#\210\306\201@\304\201A\304\201C%\210\300\201D\302\201D\201E\304#\201F#\210\306\201D\304\201E\304\201G%\207" [defalias seq-reverse cl-generic-define (sequence) nil "Return a sequence with elements of SEQUENCE in reverse order.\n\n(fn SEQUENCE)" cl-generic-define-method #[257 "\300C\301\302\303\"\"\210\304\242\305!\"\207" [nil seq-map make-closure #[257 "\300\300\242B\240\207" [V0] 4 "\n\n(fn ELT)"] seq-into type-of] 6 "\n\n(fn SEQUENCE)"] ((sequence sequence)) #[257 "\300!\207" [reverse] 3 "\n\n(fn SEQUENCE)"] seq-concatenate (type &rest sequences) "Concatenate SEQUENCES into a single sequence of type TYPE.\nTYPE must be one of following symbols: `vector', `string' or `list'.\n\n\n(fn TYPE SEQUENCE...)" #[385 "\300\301\"\262\302\267\202\303\304\"\207\303\305\"\207\303\306\211\307\"\"\207\310\311\"\207" [mapcar seq-into-sequence #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (vector 12 string 17 list 22)) apply vconcat concat append (nil) error "Not a sequence type name: %S"] 7 "\n\n(fn TYPE &rest SEQUENCES)"] seq-into-sequence (sequence) "Convert SEQUENCE into a sequence.\n\nThe default implementation is to signal an error if SEQUENCE is not a\nsequence, specific functions should be implemented for new types\nof sequence.\n\n(fn SEQUENCE)" #[257 "\300!\204 \301\302\"\210\207" [sequencep error "Cannot convert %S into a sequence"] 4 "\n\n(fn SEQUENCE)"] seq-into (sequence type) "Concatenate the elements of SEQUENCE into a sequence of type TYPE.\nTYPE can be one of the following symbols: `vector', `string' or\n`list'.\n\n(fn SEQUENCE TYPE)" #[514 "\211\300\267\202\301!\207\302!\207\303!\207\304\305\"\207" [#s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (vector 6 string 10 list 14)) seq--into-vector seq--into-string seq--into-list error "Not a sequence type name: %S"] 5 "\n\n(fn SEQUENCE TYPE)"] seq-filter (pred sequence) "Return a list of all the elements in SEQUENCE for which PRED returns non-nil.\n\n(fn PRED SEQUENCE)" #[514 "\300\301!\302\303\304\305#\"\"\207" [make-symbol "exclude" delq seq-map make-closure #[257 "\301!\203\207\300\207" [V0 V1] 3 "\n\n(fn ELT)"]] 10 "\n\n(fn PRED SEQUENCE)"] seq-remove (pred sequence) "Return a list of all the elements in SEQUENCE for which PRED returns nil.\n\n(fn PRED SEQUENCE)" #[514 "\300\301\302\"\"\207" [seq-filter make-closure #[257 "\300!?\207" [V0] 3 "\n\n(fn ELT)"]] 6 "\n\n(fn PRED SEQUENCE)"] seq-remove-at-position (sequence n) "Return a copy of SEQUENCE with the element at index N removed.\n\nN is the (zero-based) index of the element that should not be in\nthe result.\n\nThe result is a sequence of the same type as SEQUENCE.\n\n(fn SEQUENCE N)" #[514 "\300\301!\211\302=\203\303\202\211\262\304\305#\304T\"#\207" [seq-concatenate type-of cons list seq-subseq 0] 8 "\n\n(fn SEQUENCE N)"] seq-reduce (function sequence initial-value) "Reduce the function FUNCTION across SEQUENCE, starting with INITIAL-VALUE.\n\nReturn the result of calling FUNCTION with INITIAL-VALUE and the\nfirst element of SEQUENCE, then calling FUNCTION with that result\nand the second element of SEQUENCE, then with that result and the\nthird element of SEQUENCE, etc. FUNCTION will be called with\nINITIAL-VALUE (and then the accumulated value) as the first\nargument, and the elements from SEQUENCE as the second argument.\n\nIf SEQUENCE is empty, return INITIAL-VALUE and FUNCTION is not called.\n\n(fn FUNCTION SEQUENCE INITIAL-VALUE)" #[771 "\300!\203\207\211C\301\302\303#\"\210\211\242\207" [seq-empty-p seq-do make-closure #[257 "\300\301\300\242\"\240\207" [V0 V1] 5 "\n\n(fn ELT)"]] 9 "\n\n(fn FUNCTION SEQUENCE INITIAL-VALUE)"] seq-every-p (pred sequence) "Return non-nil if PRED returns non-nil for all the elements of SEQUENCE.\n\n(fn PRED SEQUENCE)" #[514 "\3002\301\302\303\"\"\210\3040\207" [seq--break seq-do make-closure #[257 "\300!\206\n\301\302\303\"\207" [V0 throw seq--break nil] 4 "\n\n(fn ELT)"] t] 6 "\n\n(fn PRED SEQUENCE)"] seq-some (pred sequence) "Return non-nil if PRED returns non-nil for at least one element of SEQUENCE.\nIf the value is non-nil, it is the first non-nil value returned by PRED.\n\n(fn PRED SEQUENCE)" #[514 "\3002\301\302\303\"\"\210\3040\207" [seq--break seq-do make-closure #[257 "\300!\211\205 \301\302\"\207" [V0 throw seq--break] 5 "\n\n(fn ELT)"] nil] 6 "\n\n(fn PRED SEQUENCE)"] seq-find (pred sequence &optional default) "Return the first element in SEQUENCE for which PRED returns non-nil.\nIf no such element is found, return DEFAULT.\n\nNote that `seq-find' has an ambiguity if the found element is\nidentical to DEFAULT, as in that case it is impossible to know\nwhether an element was found or not.\n\n(fn PRED SEQUENCE &optional DEFAULT)" #[770 "\3002\301\302\303\"\"\210\2110\207" [seq--break seq-do make-closure #[257 "\300!\205\n\301\302\"\207" [V0 throw seq--break] 4 "\n\n(fn ELT)"]] 7 "\n\n(fn PRED SEQUENCE &optional DEFAULT)"] seq-count (pred sequence) "Return the number of elements in SEQUENCE for which PRED returns non-nil.\n\n(fn PRED SEQUENCE)" #[514 "\300C\301\302\303#\"\210\211\242\207" [0 seq-do make-closure #[257 "\301!\205 \300\211\242T\240\207" [V0 V1] 3 "\n\n(fn ELT)"]] 8 "\n\n(fn PRED SEQUENCE)"] seq-contains (sequence elt &optional testfn) "Return the first element in SEQUENCE that is \"equal\" to ELT.\n\"Equality\" is defined by the function TESTFN, which defaults to `equal'.\n\n(fn SEQUENCE ELT &optional TESTFN)" #[770 "\300\301\302#\"\207" [seq-some make-closure #[257 "\300\206\302\301\"\205\f\211\207" [V0 V1 equal] 4 "\n\n(fn E)"]] 8 "\n\n(fn SEQUENCE ELT &optional TESTFN)"] make-obsolete seq-contains-p "27.1" (sequence elt &optional testfn) "Return non-nil if SEQUENCE contains an element \"equal\" to ELT.\n\"Equality\" is defined by the function TESTFN, which defaults to `equal'.\n\n(fn SEQUENCE ELT &optional TESTFN)" #[770 "\3002\301\302\303#\"\210\3040\207" [seq--break seq-do make-closure #[257 "\300\206\302\301\"\211\205\303\304\"\207" [V0 V1 equal throw seq--break] 5 "\n\n(fn E)"] nil] 8 "\n\n(fn SEQUENCE ELT &optional TESTFN)"] seq-set-equal-p (sequence1 sequence2 &optional testfn) "Return non-nil if SEQUENCE1 and SEQUENCE2 contain the same elements.\nThe order of the elements in the sequences is not important.\n\"Equality\" of elements is defined by the function TESTFN, which\ndefaults to `equal'.\n\n(fn SEQUENCE1 SEQUENCE2 &optional TESTFN)" #[770 "\300\301\302#\"\205\300\301\303#\"\207" [seq-every-p make-closure #[257 "\302\301\300#\207" [V0 V1 seq-contains-p] 5 "\n\n(fn ITEM1)"] #[257 "\302\301\300#\207" [V0 V1 seq-contains-p] 5 "\n\n(fn ITEM2)"]] 8 "\n\n(fn SEQUENCE1 SEQUENCE2 &optional TESTFN)"] seq-position (sequence elt &optional testfn) "Return the (zero-based) index of the first element in SEQUENCE \"equal\" to ELT.\n\"Equality\" is defined by the function TESTFN, which defaults to `equal'.\n\n(fn SEQUENCE ELT &optional TESTFN)" #[770 "\300C\3012\302\303\304$\"\210\3050\207" [0 seq--break seq-do make-closure #[257 "\301\206\303\302\"\203\304\305\300\242\"\210\300\211\242T\240\207" [V0 V1 V2 equal throw seq--break] 4 "\n\n(fn E)"] nil] 10 "\n\n(fn SEQUENCE ELT &optional TESTFN)"]] 6) (byte-code "\300\301\302\301\303\304#\305#\210\306\301\304\303\304\307%\210\300\310\302\310\311\304#\312#\210\306\310\304\311\304\313%\210\306\310\304\314\304\315%\210\300\316\302\316\317\304#\320#\210\306\316\304\317\304\321%\210\300\322\302\322\323\304#\324#\210\306\322\304\323\304\325%\210\300\326\302\326\327\304#\330#\210\306\326\304\327\304\331%\210\300\332\302\332\333\304#\334#\210\306\332\304\333\304\335%\210\300\336\302\336\337\304#\340#\210\306\336\304\337\304\341%\210\300\342\302\342\343\304#\344#\210\306\342\304\343\304\345%\210\300\346\302\346\347\304#\350#\210\306\346\304\347\304\351%\210\300\352\302\352\353\304#\354#\210\306\352\304\353\304\355%\207" [defalias seq-positions cl-generic-define (sequence elt &optional testfn) nil "Return list of indices of SEQUENCE elements for which TESTFN returns non-nil.\n\nTESTFN is a two-argument function which is called with each element of\nSEQUENCE as the first argument and ELT as the second.\nTESTFN defaults to `equal'.\n\nThe result is a list of (zero-based) indices.\n\n(fn SEQUENCE ELT &optional TESTFN)" cl-generic-define-method #[770 "\300C\301\302\303$\"\210\211\242\237\207" [nil seq-do-indexed make-closure #[514 "\301\206\303\302\"\205\300\300\242B\240\207" [V0 V1 V2 equal] 5 "\n\n(fn E INDEX)"]] 10 "\n\n(fn SEQUENCE ELT &optional TESTFN)"] seq-uniq (sequence &optional testfn) "Return a list of the elements of SEQUENCE with duplicates removed.\nTESTFN is used to compare elements, and defaults to `equal'.\n\n(fn SEQUENCE &optional TESTFN)" #[513 "\300C\301\302\303#\"\210\211\242\237\207" [nil seq-do make-closure #[257 "\302\300\242\301#?\205\300\300\242B\240\207" [V0 V1 seq-contains-p] 5 "\n\n(fn ELT)"]] 8 "\n\n(fn SEQUENCE &optional TESTFN)"] ((sequence list) &optional testfn) #[513 "C\300\204d\242G\211\301V\203C\302\303\304\305$\242\203>\306\242@\"\2045\242@\307\310#\266\242@B\262\211\242A\240\210\202\266\202\204\242\203`\242@\235\204W\242@B\262\211\242A\240\210\202C\210\202\204\242\203\204\311\312\313#\"\204{\242@B\262\211\242A\240\210\202d\211\237\207" [nil 100 make-hash-table :test equal :size gethash puthash t seq-find make-closure #[257 "\300\301\242@\"\207" [V0 V1] 4 "\n\n(fn ELEM)"]] 11 "\n\n(fn SEQUENCE &optional TESTFN)"] seq-mapcat (function sequence &optional type) "Concatenate the results of applying FUNCTION to each element of SEQUENCE.\nThe result is a sequence of type TYPE; TYPE defaults to `list'.\n\n(fn FUNCTION SEQUENCE &optional TYPE)" #[770 "\300\301\206\302\303\"#\207" [apply seq-concatenate list seq-map] 9 "\n\n(fn FUNCTION SEQUENCE &optional TYPE)"] seq-partition (sequence n) "Return list of elements of SEQUENCE grouped into sub-sequences of length N.\nThe last sequence may contain less than N elements. If N is a\nnegative integer or 0, the function returns nil.\n\n(fn SEQUENCE N)" #[514 "\211\300W?\205#\301\302!\204\303\"B\262\304\"\262\202\211\237\262\207" [1 nil seq-empty-p seq-take seq-drop] 6 "\n\n(fn SEQUENCE N)"] seq-union (sequence1 sequence2 &optional testfn) "Return a list of all the elements that appear in either SEQUENCE1 or SEQUENCE2.\n\"Equality\" of elements is defined by the function TESTFN, which\ndefaults to `equal'.\n\n(fn SEQUENCE1 SEQUENCE2 &optional TESTFN)" #[770 "\300\301\"\302\302\303##\211\237\207" [make-closure #[514 "\301\300#\203\n\207\211B\207" [V0 seq-contains-p] 6 "\n\n(fn ACC ELT)"] seq-reduce nil] 11 "\n\n(fn SEQUENCE1 SEQUENCE2 &optional TESTFN)"] seq-intersection (sequence1 sequence2 &optional testfn) "Return a list of all the elements that appear in both SEQUENCE1 and SEQUENCE2.\n\"Equality\" of elements is defined by the function TESTFN, which\ndefaults to `equal'.\n\n(fn SEQUENCE1 SEQUENCE2 &optional TESTFN)" #[770 "\300\301\302#\303!\304#\207" [seq-reduce make-closure #[514 "\302\301\300#\203\f\211B\207\207" [V0 V1 seq-contains-p] 6 "\n\n(fn ACC ELT)"] seq-reverse nil] 8 "\n\n(fn SEQUENCE1 SEQUENCE2 &optional TESTFN)"] seq-difference (sequence1 sequence2 &optional testfn) "Return list of all the elements that appear in SEQUENCE1 but not in SEQUENCE2.\n\"Equality\" of elements is defined by the function TESTFN, which\ndefaults to `equal'.\n\n(fn SEQUENCE1 SEQUENCE2 &optional TESTFN)" #[770 "\300\301\302#\303!\304#\207" [seq-reduce make-closure #[514 "\302\301\300#\203\n\207\211B\207" [V0 V1 seq-contains-p] 6 "\n\n(fn ACC ELT)"] seq-reverse nil] 8 "\n\n(fn SEQUENCE1 SEQUENCE2 &optional TESTFN)"] seq-group-by #'sequence "Apply FUNCTION to each element of SEQUENCE.\nSeparate the elements of SEQUENCE into an alist using the results as\nkeys. Keys are compared using `equal'.\n\n(fn FUNCTION SEQUENCE)" #[514 "\300\301\302\"\303!\304#\207" [seq-reduce make-closure #[514 "\300!\301\"\211\203\211AB\241\241\210\202DB\262\207" [V0 assoc] 8 "\n\n(fn ACC ELT)"] seq-reverse nil] 6 "\n\n(fn FUNCTION SEQUENCE)"] seq-min (sequence) "Return the smallest element of SEQUENCE.\nSEQUENCE must be a sequence of numbers or markers.\n\n(fn SEQUENCE)" #[257 "\300\301\302\303\"\"\207" [apply min seq-into list] 6 "\n\n(fn SEQUENCE)"] seq-max (sequence) "Return the largest element of SEQUENCE.\nSEQUENCE must be a sequence of numbers or markers.\n\n(fn SEQUENCE)" #[257 "\300\301\302\303\"\"\207" [apply max seq-into list] 6 "\n\n(fn SEQUENCE)"]] 6)#@91 Count successive elements in SEQUENCE for which PRED returns non-nil. (fn PRED SEQUENCE) (defalias 'seq--count-successive #[514 "\300\301!W\203\302\"!\203T\262\202\207" [0 seq-length seq-elt] 8 (#$ . 23153)])#@92 Return list of bindings of the variables in ARGS to the elements of a sequence. (fn ARGS) (defalias 'seq--make-pcase-bindings #[257 "\300C\301C\300C\302\303\304 %\"\210\242\207" [nil 0 seq-do make-closure #[257 "\300\242\2043\211\304=\203%\302\305\306\307\301\242E\310\303\301\242T\"E\302\242B\240\210\300\311\240\210\2023\302\305\306\310\301\242EE\302\242B\240\210\301\211\242T\240\207" [V0 V1 V2 V3 &rest app pcase--flip seq-drop seq--elt-safe t] 7 "\n\n(fn NAME)"]] 11 (#$ . 23383)])#@85 Return a list of `(seq ...)' pcase patterns from the argument list ARGS. (fn ARGS) (defalias 'seq--make-pcase-patterns #[257 "\300\301\302\"B\207" [seq seq-map #[257 "\300!\203\n\301!\207\207" [seqp seq--make-pcase-patterns] 3 "\n\n(fn ELT)"]] 5 (#$ . 23887)])#@114 Return the element of SEQUENCE whose zero-based index is N. If no element is found, return nil. (fn SEQUENCE N) (defalias 'seq--elt-safe #[514 "\3001\n\301\"0\207\210\302\207" [(error) seq-elt nil] 5 (#$ . 24159)]) (byte-code "\300\301\302\301\303\304#\305#\210\306\301\304\303\304\307%\210\306\310\304\311\304\312%\210\306\313\304\314\304\315%\210\306\316\304\317\304\320%\210\306\321\304\322\304\323%\207" [defalias seq-random-elt cl-generic-define (sequence) nil "Return a randomly chosen element from SEQUENCE.\nSignal an error if SEQUENCE is empty.\n\n(fn SEQUENCE)" cl-generic-define-method #[257 "\300!\203\n\301\302!\207\303\304\305!!\"\207" [seq-empty-p error "Sequence cannot be empty" seq-elt random seq-length] 6 "\n\n(fn SEQUENCE)"] seq-drop ((list list) n) #[514 "\211\233\207" #1=[] 4 "Optimized implementation of `seq-drop' for lists.\n\n(fn LIST N)"] seq-take ((list list) n) #[514 "\300\"\207" [take] 5 "Optimized implementation of `seq-take' for lists.\n\n(fn LIST N)"] seq-drop-while (pred (list list)) #[514 "\211\203@!\203\211A\262\202\207" #1# 4 "Optimized implementation of `seq-drop-while' for lists.\n\n(fn PRED LIST)"] seq-empty-p ((list list)) #[257 "\211?\207" #1# 2 "Optimized implementation of `seq-empty-p' for lists.\n\n(fn LIST)"]] 6)#@66 Concatenate the elements of SEQUENCE into a list. (fn SEQUENCE) (defalias 'seq--into-list #[257 "\211<\203\207\300\301\"\207" [append nil] 4 (#$ . 25453)])#@68 Concatenate the elements of SEQUENCE into a vector. (fn SEQUENCE) (defalias 'seq--into-vector #[257 "\300!\203\207\301!\207" [vectorp vconcat] 3 (#$ . 25618)])#@68 Concatenate the elements of SEQUENCE into a string. (fn SEQUENCE) (defalias 'seq--into-string #[257 "\211;\203\207\211\260\207" [] 2 (#$ . 25788)])#@181 Split SEQUENCE into a list of sub-sequences of at most LENGTH elements. All the sub-sequences will be LENGTH long, except the last one, which may be shorter. (fn SEQUENCE LENGTH) (defalias 'seq-split #[514 "\211\300W\203\n\301\302!\210\303G\304\211W\203(\305\\^\211\262#B\262\202\237\207" [1 error "Sub-sequence length must be larger than zero" nil 0 seq-subseq] 11 (#$ . 25946)])#@100 Apply FUNCTION to SEQUENCE and return the list of all the non-nil results. (fn FUNCTION SEQUENCE) (defalias 'seq-keep #[514 "\300\301\302\"\"\207" [delq nil seq-map] 7 (#$ . 26350)]) (provide 'seq)