HOME

Mini Shell 1.0
DIR:/proc/self/root/usr/share/emacs/26.1/lisp/emacs-lisp/
Current File : //proc/self/root/usr/share/emacs/26.1/lisp/emacs-lisp/seq.elc
;ELC
;;; Compiled
;;; in Emacs version 26.1
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


(require 'cl-lib)
#@191 Loop over a sequence.
Evaluate BODY with VAR bound to each element of SEQUENCE, in turn.

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 (#$ . 427)]))
(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 (#$ . 879)])
(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 (#$ . 1445)]))
(byte-code "\300\301\302\303#\304\301\305\306#\210\307\310\311\310\312\313#\314#\210\315\310\313\312\313\316%\210\315\317\313\320\313\321%\210\315\317\313\322\313\323%\210\307\324\311\324\325\313#\326#\210\315\324\313\325\313\327%\210\307\330\311\330\331\313#\332#\210\315\330\313\331\313\333%\210\307\334\330\"\207" [function-put seq-let lisp-indent-function 2 put edebug-form-spec (sexp form body) defalias seq-elt cl-generic-define (sequence n) nil "Return 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 of SEQUENCE.\n\n(fn SEQUENCE)" #[257 "\211G\207" #1# 2 "\n\n(fn SEQUENCE)"] seq-do #'sequence "Apply FUNCTION to each element of SEQUENCE, presumably for side effects.\nReturn SEQUENCE.\n\n(fn FUNCTION SEQUENCE)" #[514 "\300\"\207" [mapc] 5 "\n\n(fn FUNCTION SEQUENCE)"] seq-each] 7)
#@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\304\305\306\"\307\"\310\311%\"\207" [0 seq-do make-byte-code 257 "\300\301\242\"\210\301\211\242T\240\207" vconcat vector [] 4 "\n\n(fn ELT)"] 11 (#$ . 2882)])
(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 (sequence) nil "Return non-nil if SEQUENCE is a sequence, nil otherwise.\n\n(fn SEQUENCE)" cl-generic-define-method #[257 "\300!\207" [sequencep] 3 "\n\n(fn SEQUENCE)"] 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 "\300#\207" [cl-subseq] 7 "\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\304\305\306\"\307\"\310\311%\"\210\211\242\237\207" [nil seq-do make-byte-code 257 "\301\300!\301\242B\240\207" vconcat vector [] 4 "\n\n(fn ELT)"] 11 "\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\304\305\306\"\307\"\310\311%\"\207" [0 seq-map make-byte-code 257 "\300\301\242\"\301\211\242T\240\210\207" vconcat vector [] 4 "\n\n(fn ELT)"] 11 (#$ . 4709)])
(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) "Like `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 result.\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) "Take the first N elements of SEQUENCE and return the result.\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 result is a sequence of\nthe 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 result is a sequence of\nthe 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 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)
#@197 Sort SEQUENCE using PRED as a 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\303\304\305\"\306\"\307\310%\"\207" [seq-sort make-byte-code 514 "\301\300!\300!\"\207" vconcat vector [] 6 "\n\n(fn A B)"] 11 (#$ . 8082)])
(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\300\372\302\372\373\304#\374#\210\306\372\304\373\304\375%\210\300\376\302\376\377\304#\201@#\210\306\376\304\377\304\201A%\210\300\201B\302\201B\201C\304#\201D#\210\306\201B\304\201C\304\201E%\210\300\201F\302\201F\201G\304#\201H#\210\306\201F\304\201G\304\201I%\210\300\201J\302\201J\201K\304#\201L#\210\306\201J\304\201K\304\201M%\210\300\201N\302\201N\201O\304#\201P#\210\306\201N\304\201O\304\201Q%\210\300\201R\302\201R\201S\304#\201T#\210\306\201R\304\201S\304\201U%\210\300\201V\302\201V\201W\304#\201X#\210\306\201V\304\201W\304\201Y%\210\300\201Z\302\201Z\201[\304#\201\\#\210\306\201Z\304\201[\304\201]%\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\304\305\306!\307\"\310\311%\"\210\312\242\313!\"\207" [nil seq-map make-byte-code 257 "\300\300\242B\240\207" vconcat vector #1=[] 4 "\n\n(fn ELT)" seq-into type-of] 9 "\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\302\303\"#\207" [apply cl-concatenate seq-map seq-into-sequence] 8 "\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\nlist.\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 for which (PRED element) is non-nil in SEQUENCE.\n\n(fn PRED SEQUENCE)" #[514 "\300\301!\302\303\304\305\306\307\310\n	\"\311\"\312\313%\"\"\207" [make-symbol "exclude" delq seq-map make-byte-code 257 "\300!\203\207\301\207" vconcat vector #1# 3 "\n\n(fn ELT)"] 13 "\n\n(fn PRED SEQUENCE)"] seq-remove (pred sequence) "Return a list of all the elements for which (PRED element) is nil in SEQUENCE.\n\n(fn PRED SEQUENCE)" #[514 "\300\301\302\303\304\305!\306\"\307\310%\"\207" [seq-filter make-byte-code 257 "\300!?\207" vconcat vector #1# 3 "\n\n(fn ELT)"] 9 "\n\n(fn PRED SEQUENCE)"] 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 and\nthe second element of SEQUENCE, then with that result and the third\nelement of SEQUENCE, etc.\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\304\305\306	\"\307\"\310\311%\"\210\211\242\207" [seq-empty-p seq-do make-byte-code 257 "\301\300\301\242\"\240\207" vconcat vector #1# 5 "\n\n(fn ELT)"] 12 "\n\n(fn FUNCTION SEQUENCE INITIAL-VALUE)"] seq-every-p (pred sequence) "Return non-nil if (PRED element) is non-nil for all elements of SEQUENCE.\n\n(fn PRED SEQUENCE)" #[514 "\3002\301\302\303\304\305\306!\307\"\310\311%\"\210\3120\207" [seq--break seq-do make-byte-code 257 "\300!\206\n\301\302\303\"\207" vconcat vector [throw seq--break nil] 4 "\n\n(fn ELT)" t] 9 "\n\n(fn PRED SEQUENCE)"] seq-some (pred sequence) "Return non-nil if PRED is satisfied for at least one element of SEQUENCE.\nIf so, return the first non-nil value returned by PRED.\n\n(fn PRED SEQUENCE)" #[514 "\3002\301\302\303\304\305\306!\307\"\310\311%\"\210\3120\207" [seq--break seq-do make-byte-code 257 "\300!\211\205\301\302\"\207" vconcat vector [throw seq--break] 5 "\n\n(fn ELT)" nil] 9 "\n\n(fn PRED SEQUENCE)"] seq-find (pred sequence &optional default) "Return the first element for which (PRED element) is non-nil in SEQUENCE.\nIf no element is found, return DEFAULT.\n\nNote that `seq-find' has an ambiguity if the found element is\nidentical to DEFAULT, as it cannot be known if an element was\nfound or not.\n\n(fn PRED SEQUENCE &optional DEFAULT)" #[770 "\3002\301\302\303\304\305\306!\307\"\310\311%\"\210\2110\207" [seq--break seq-do make-byte-code 257 "\300!\205\n\301\302\"\207" vconcat vector [throw seq--break] 4 "\n\n(fn ELT)"] 10 "\n\n(fn PRED SEQUENCE &optional DEFAULT)"] seq-count (pred sequence) "Return the number of elements for which (PRED element) is non-nil in SEQUENCE.\n\n(fn PRED SEQUENCE)" #[514 "\300C\301\302\303\304\305\306\"\307\"\310\311%\"\210\211\242\207" [0 seq-do make-byte-code 257 "\300!\205\301\211\242T\240\207" vconcat vector #1# 3 "\n\n(fn ELT)"] 11 "\n\n(fn PRED SEQUENCE)"] seq-contains (sequence elt &optional testfn) "Return the first element in SEQUENCE that is equal to ELT.\nEquality is defined by TESTFN if non-nil or by `equal' if nil.\n\n(fn SEQUENCE ELT &optional TESTFN)" #[770 "\300\301\302\303\304\305\"\306\"\307\310%\"\207" [seq-some make-byte-code 257 "\301\206\302\300\"\205\f\211\207" vconcat vector [equal] 4 "\n\n(fn E)"] 11 "\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, regardless of order.\nEquality is defined by TESTFN if non-nil or by `equal' if nil.\n\n(fn SEQUENCE1 SEQUENCE2 &optional TESTFN)" #[770 "\300\301\302\303\304\305\"\306\"\307\310%\"\205'\300\301\302\303\304\305\"\311\"\307\312%\"\207" [seq-every-p make-byte-code 257 "\302\300\301#\207" vconcat vector [seq-contains] 5 "\n\n(fn ITEM1)" [seq-contains] "\n\n(fn ITEM2)"] 11 "\n\n(fn SEQUENCE1 SEQUENCE2 &optional TESTFN)"] seq-position (sequence elt &optional testfn) "Return the index of the first element in SEQUENCE that is equal to ELT.\nEquality is defined by TESTFN if non-nil or by `equal' if nil.\n\n(fn SEQUENCE ELT &optional TESTFN)" #[770 "\300C\3012\302\303\304\305\306\307#\310\"\311\312%\"\210\3130\207" [0 seq--break seq-do make-byte-code 257 "\301\206\303\300\"\203\304\305\302\242\"\210\302\211\242T\240\207" vconcat vector [equal throw seq--break] 4 "\n\n(fn E)" nil] 13 "\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, or `equal' if TESTFN is nil.\n\n(fn SEQUENCE &optional TESTFN)" #[513 "\300C\301\302\303\304\305\306\"\307\"\310\311%\"\210\211\242\237\207" [nil seq-do make-byte-code 257 "\302\301\242\300#?\205\301\301\242B\240\207" vconcat vector [seq-contains] 5 "\n\n(fn ELT)"] 11 "\n\n(fn SEQUENCE &optional TESTFN)"] seq-mapcat (function sequence &optional type) "Concatenate the result of applying FUNCTION to each element of SEQUENCE.\nThe result is a sequence of type TYPE, or a list if TYPE is nil.\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 a list of the 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, nil is returned.\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-intersection (sequence1 sequence2 &optional testfn) "Return a list of the elements that appear in both SEQUENCE1 and SEQUENCE2.\nEquality is defined by TESTFN if non-nil or by `equal' if nil.\n\n(fn SEQUENCE1 SEQUENCE2 &optional TESTFN)" #[770 "\300\301\302\303\304\305\"\306\"\307\310%\311!\312#\207" [seq-reduce make-byte-code 514 "\302\300\301#\203\f\211B\207\207" vconcat vector [seq-contains] 6 "\n\n(fn ACC ELT)" seq-reverse nil] 11 "\n\n(fn SEQUENCE1 SEQUENCE2 &optional TESTFN)"] seq-difference (sequence1 sequence2 &optional testfn) "Return a list of the elements that appear in SEQUENCE1 but not in SEQUENCE2.\nEquality is defined by TESTFN if non-nil or by `equal' if nil.\n\n(fn SEQUENCE1 SEQUENCE2 &optional TESTFN)" #[770 "\300\301\302\303\304\305\"\306\"\307\310%\311!\312#\207" [seq-reduce make-byte-code 514 "\302\300\301#\204\f\211B\207\207" vconcat vector [seq-contains] 6 "\n\n(fn ACC ELT)" seq-reverse nil] 11 "\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\305!\306\"\307\310%\311!\312#\207" [seq-reduce make-byte-code 514 "\300!\301\"\211\203\211\211AB\241\262\241\210\202!DB\262\207" vconcat vector [assoc] 9 "\n\n(fn ACC ELT)" seq-reverse nil] 9 "\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)
#@111 Return the number of successive elements for which (PRED element) is non-nil in SEQUENCE.

(fn PRED SEQUENCE)
(defalias 'seq--count-successive #[514 "\300\301!W\203\302\"!\203T\262\202\207" [0 seq-length seq-elt] 8 (#$ . 19290)])
#@94 Return a 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\305\306\307				$\310\"\311\312%\"\210\242\207" [nil 0 seq-do make-byte-code 257 "\303\242\2043\211\304=\203%\301\305\306\307\302\242E\310\300\302\242T\"E\301\242B\240\210\303\311\240\210\2023\301\305\306\310\302\242EE\301\242B\240\210\302\211\242T\240\207" vconcat vector [&rest app pcase--flip seq-drop seq--elt-safe t] 7 "\n\n(fn NAME)"] 14 (#$ . 19541)])
#@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 (#$ . 20079)])
#@97 Return element of SEQUENCE at the index 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 (#$ . 20351)])
(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 random 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\203\301V\203S\262\211A\262\242B\262\202\211\237\207" [nil 0] 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 (#$ . 21679)])
#@68 Concatenate the elements of SEQUENCE into a vector.

(fn SEQUENCE)
(defalias 'seq--into-vector #[257 "\300!\203\207\301!\207" [vectorp vconcat] 3 (#$ . 21845)])
#@68 Concatenate the elements of SEQUENCE into a string.

(fn SEQUENCE)
(defalias 'seq--into-string #[257 "\211;\203\207\211\260\207" [] 2 (#$ . 22016)])
#@62 Activate font-lock keywords for some symbols defined in seq.
(defalias 'seq--activate-font-lock-keywords #[0 "\300\301\302\"\207" [font-lock-add-keywords emacs-lisp-mode ("\\<seq-doseq\\>" "\\<seq-let\\>")] 3 (#$ . 22174)])
(byte-code "\300\301!\204\302\303\304\"\210\305\306!\207" [fboundp elisp--font-lock-flush-elisp-buffers add-hook emacs-lisp-mode-hook seq--activate-font-lock-keywords provide seq] 3)