;ELC ;;; Compiled ;;; in Emacs version 29.4 ;;; with all optimizations. (require 'macroexp) (defconst pcase--memoize (make-hash-table :weakness 'key :test 'eq)) (defconst pcase--dontcare-upats '(t _ pcase--dontcare)) (defvar pcase--dontwarn-upats '(pcase--dontcare)) (byte-code "\300\301\302\"\210\300\303\304\"\207" [def-edebug-elem-spec pcase-PAT (&or (&interpose symbolp pcase--edebug-match-pat-args) sexp) pcase-FUN (&or lambda-expr (functionp &rest form) sexp)] 3)#@16 (fn HEAD PF) (defalias 'pcase--edebug-match-pat-args #[514 "@\262\300\301\"\206\302!\2059\205\303!!\262\207" [alist-get ('sexp (or &rest pcase-PAT) (and &rest pcase-PAT) (guard form) (pred &or ("not" pcase-FUN) pcase-FUN) (app pcase-FUN pcase-PAT)) pcase--get-macroexpander edebug-get-spec] 6 (#$ . 481)])#@68 Return the macroexpander for pcase pattern head S, or nil. (fn S) (defalias 'pcase--get-macroexpander #[257 "\211\300N\207" [pcase-macroexpander] 3 (#$ . 809)])#@1744 Evaluate EXP to get EXPVAL; try passing control to one of CASES. CASES is a list of elements of the form (PATTERN CODE...). For the first CASE whose PATTERN "matches" EXPVAL, evaluate its CODE..., and return the value of the last form. If no CASE has a PATTERN that matches, return nil. Each PATTERN expands, in essence, to a predicate to call on EXPVAL. When the return value of that call is non-nil, PATTERN matches. PATTERN can take one of the forms: _ matches anything. \='VAL matches if EXPVAL is `equal' to VAL. KEYWORD shorthand for \='KEYWORD INTEGER shorthand for \='INTEGER STRING shorthand for \='STRING SYMBOL matches anything and binds it to SYMBOL. If a SYMBOL is used twice in the same pattern the second occurrence becomes an `eq'uality test. (pred FUN) matches if FUN called on EXPVAL returns non-nil. (pred (not FUN)) matches if FUN called on EXPVAL returns nil. (app FUN PAT) matches if FUN called on EXPVAL matches PAT. (guard BOOLEXP) matches if BOOLEXP evaluates to non-nil. (and PAT...) matches if all the patterns match. (or PAT...) matches if any of the patterns matches. FUN in `pred' and `app' can take one of the forms: SYMBOL or (lambda ARGS BODY) call it with one argument (F ARG1 .. ARGn) call F with ARG1..ARGn and EXPVAL as n+1'th argument FUN, BOOLEXP, and subsequent PAT can refer to variables bound earlier in the pattern by a SYMBOL pattern. Additional patterns can be defined using `pcase-defmacro'. See Info node `(elisp) Pattern-Matching Conditional' in the Emacs Lisp manual for more information and examples. (fn EXP &rest CASES) (defalias 'pcase '(macro . #[385 "\301@\"@\232\203A@\232\203\211AA\207\302\"\303@BB#\210\207" [pcase--memoize gethash pcase--expand puthash] 9 (#$ . 978)])) (byte-code "\300\301\302\303#\304\301\305\306#\210\304\301\307\310#\207" [function-put pcase lisp-indent-function 1 put edebug-form-spec (form &rest (pcase-PAT body)) function-documentation (pcase--make-docstring)] 5) (defalias 'pcase--make-docstring #[0 "\300\301K\302\"\303\301\"\304\305!\210\306\307\310\"r\211q\210\311\312\"\216A\206 c\210\313C\314\311\315\"!\210\316\242\236\317\242\"B\240\266\211\242\203l\211\242\211\242A\240\210\242\211@A\300\302\"\320c\210\321\322!\313%\262\323\206e\324\261\266\202:\210\325 \203{\326@\"\202|\211*\207" [documentation pcase raw help-split-fundoc require help-fns generate-new-buffer " *temp*" t make-closure #[0 "\301\300!\205 \302\300!\207" [V0 buffer-name kill-buffer] 2] nil mapatoms #[257 "\301!\211\205\300B\300\242B\240\207" [V0 pcase--get-macroexpander] 5 "\n\n(fn SYMBOL)"] \` delq "\n\n-- " help-fns--signature indirect-function "\n" "Not documented." buffer-string help-add-fundoc-usage] 14])#@229 The exhaustive version of `pcase' (which see). If EXP fails to match any of the patterns in CASES, an error is signaled. In contrast, `pcase' will return nil if there is no match, but not signal an error. (fn EXP &rest CASES) (defalias 'pcase-exhaustive '(macro . #[385 "\301\302!\211B\303\304\305\306EDC\"\")\207" [pcase--dontwarn-upats gensym "x" pcase--expand append error "No clause matching `%S'"] 11 (#$ . 3885)])) (byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put pcase-exhaustive lisp-indent-function 1 put edebug-form-spec pcase] 5)#@258 Like `lambda' but allow each argument to be a pattern. I.e. accepts the usual &optional and &rest keywords, but every formal argument can be any pattern accepted by `pcase' (a mere variable name being but a special case of it). (fn LAMBDA-LIST &rest BODY) (defalias 'pcase-lambda '(macro . #[385 "\300C\301!\302\303\304\"\"\305\306@\307\242\237ABBC\"BB\207" [nil macroexp-parse-body mapcar make-closure #[257 "\2119\203\207\301\302\303\300\242G\"!\300D\300\242B\240\210\207" [V0 make-symbol format "arg%s"] 5 "\n\n(fn PAT)"] lambda append pcase-let*] 12 (#$ . 4458)])) (byte-code "\300\301\302\303#\300\301\304\305#\306\301\307\310#\207" [function-put pcase-lambda doc-string-elt 2 lisp-indent-function defun put edebug-form-spec (&define (&rest pcase-PAT) lambda-doc def-body)] 6)#@22 (fn BINDINGS BODY) (defalias 'pcase--let* #[514 "\204\300!\207\301@@!\203\302@C\303A\"\"\207\211A\262\242\304A@@\303\"D\305B\"\207" [macroexp-progn pcase--trivial-upat-p macroexp-let* pcase--let* pcase--expand ((pcase--dontcare nil))] 9 (#$ . 5259)])#@484 Like `let*', but supports destructuring BINDINGS using `pcase' patterns. As with `pcase-let', BINDINGS are of the form (PATTERN EXP), but the EXP in each binding in BINDINGS can use the results of the destructuring bindings that precede it in BINDINGS' order. Each EXP should match its respective PATTERN (i.e. be of structure compatible to PATTERN); a mismatch may signal an error or may go undetected, binding variables to arbitrary values, such as nil. (fn BINDINGS &rest BODY) (defalias 'pcase-let* '(macro . #[385 "\301\"\211@\232\203\211A\207\302\"\303B#\210\207" [pcase--memoize gethash pcase--let* puthash] 8 (#$ . 5536)])) (byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put pcase-let* lisp-indent-function 1 put edebug-form-spec ((&rest (pcase-PAT &optional form)) body)] 5)#@589 Like `let', but supports destructuring BINDINGS using `pcase' patterns. BODY should be a list of expressions, and BINDINGS should be a list of bindings of the form (PATTERN EXP). All EXPs are evaluated first, and then used to perform destructuring bindings by matching each EXP against its respective PATTERN. Then BODY is evaluated with those bindings in effect. Each EXP should match its respective PATTERN (i.e. be of structure compatible to PATTERN); a mismatch may signal an error or may go undetected, binding variables to arbitrary values, such as nil. (fn BINDINGS &rest BODY) (defalias 'pcase-let '(macro . #[385 "A\204 \301BB\207\302\302\262\211\203Z\211@\211@>\203*\303\304!ABB\262\202S\305@!\2039\211B\262\202S\303\306\307G\"!\211ABB\262@DB\262\210A\266\202\202\210\310\237\301BBE\207" [pcase--dontcare-upats pcase-let* nil make-symbol "_" pcase--trivial-upat-p format "x%d" let] 9 (#$ . 6354)])) (byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put pcase-let lisp-indent-function 1 put edebug-form-spec pcase-let*] 5)#@595 Eval BODY once for each set of bindings defined by PATTERN and LIST elements. PATTERN should be a `pcase' pattern describing the structure of LIST elements, and LIST is a list of objects that match PATTERN, i.e. have a structure that is compatible with PATTERN. For each element of LIST, this macro binds the variables in PATTERN to the corresponding subfields of the LIST element, and then evaluates BODY with these bindings in effect. The destructuring bindings of variables in PATTERN to the subfields of the elements of LIST is performed as if by `pcase-let'. (fn (PATTERN LIST) BODY...) (defalias 'pcase-dolist '(macro . #[385 "\300@!\203 \301BB\207\302\303!\301AB\304@DCBBE\207" [pcase--trivial-upat-p dolist gensym "x" pcase-let*] 8 (#$ . 7441)])) (byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put pcase-dolist lisp-indent-function 1 put edebug-form-spec ((pcase-PAT form) body)] 5)#@426 Assign values to variables by destructuring with `pcase'. PATTERNS are normal `pcase' patterns, and VALUES are expression. Evaluation happens sequentially as in `setq' (not in parallel). An example: (pcase-setq \=`((,a) [(,b)]) \='((1) [(2)])) VAL is presumed to match PAT. Failure to match may signal an error or go undetected, binding variables to arbitrary values, such as nil. (fn PATTERNS VALUE PATTERN VALUES ...) (defalias 'pcase-setq '(macro . #[642 "\211\203=\211G\300\301\"\302U\204\303\304\305\301\\D\"\210\210\306\2033\305\211A\262\242\211A\262\242EB\262\202\307\305E\237BB\207\310!\203H\311E\207\312\313B\314B\"\207" [mod 2 0 signal wrong-number-of-arguments pcase-setq nil progn pcase--trivial-upat-p setq pcase-compile-patterns #[385 "\300\301\302\"B\207" [setq mapcan #[257 "\211@A@D\207" [] 5 "\n\n(fn VARVAL)"]] 6 "\n\n(fn VARVALS &rest _)"] ((pcase--dontcare . ignore))] 9 (#$ . 8364)])) (put 'pcase-setq 'edebug-form-spec '(&rest [pcase-PAT form]))#@13 (fn UPAT) (defalias 'pcase--trivial-upat-p #[257 "\2119\205 \211>?\207" [pcase--dontcare-upats] 3 (#$ . 9371)])#@806 Compile the set of patterns in CASES. EXP is the expression that will be matched against the patterns. CASES is a list of elements (PAT . CODEGEN) where CODEGEN is a function that returns the code to use when PAT matches. That code has to be in the form of a cons cell. CODEGEN will be called with at least 2 arguments, VARVALS and COUNT. VARVALS is a list of elements of the form (VAR VAL . RESERVED) where VAR is a variable bound by the pattern and VAL is a duplicable expression that returns the value this variable should be bound to. If the pattern PAT uses `or', CODEGEN may be called multiple times, in which case it may want to generate the code differently to avoid a potential code explosion. For this reason the COUNT argument indicates how many time this CODEGEN is called. (fn EXP CASES) (defalias 'pcase-compile-patterns #[514 "\301!\203\n\202 \302\303!\304C\305C\306\307\310\311$\"!\242\211\203\256\211@\211@AA\304C\211\203q\211@\211@\211\203i\211@\211@\242\236\211\203TAA\203a\211\312\241\266\202b@AAB\242B\240\210\210A\266\202\2027\210A\266\202\202/\210\304\307\313\242\"\211\203\245\211@\211@\307\310\314 #\"A \nG\"@\240\210A\241\266A\266\202\202y\266A\266\202\202!\210\211\203\331\211@\211\242\236\204\322\211@>\204\322\315\316\317@\"\304\211@%\262A\266\202\202\260\210\266\202=\203\343\207\320DC\"\207" [pcase--dontwarn-upats macroexp-copyable-p make-symbol "val" nil 0 pcase--u mapcar make-closure #[257 "\303\302\304@!\"\305\306\300\301$D\207" [V0 V1 V2 pcase--match pcase--macroexpand make-closure #[257 "\300\302\242\236\211\204\302\300C\211\262\302\242B\240\210\303\301\211\242T\240BBAB\241\210\207" [V0 V1 V2 pcase--placeholder] 6 "\n\n(fn VARS)"]] 7 "\n\n(fn CASE)"] used car #[257 "\211\300\236A@\301\242\236AE\207" [V0 V1] 5 "\n\n(fn V)"] macroexp-warn-and-return format "pcase pattern %S shadowed by previous pcase pattern" macroexp-let*] 21 (#$ . 9493)])#@18 (fn EXP CASES) (defalias 'pcase--expand #[514 "\300C\301\302\"\303\304\301\305\"\"\"\306\242\"\207" [nil make-closure #[257 "\211\301\235\203\302\207\303C\304\305\300$\207" [V0 (nil (nil) ('nil)) #[128 "\300\207" ['nil] 2 "\n\n(fn &rest _)"] nil make-closure #[642 "\303\304\305\306\"\"\211\205\307BC\310W\204\311\301!\203)\312\305\313\"\314\301\"BB\207\300\242\204N\300\315\316\317\302\242G\"!\240\210\302\300\242\320\305\321 \"\314\301\"BBD\302\242B\240\210\322\300\242\305\323\"BB\207" [V0 V1 V2 delq nil mapcar #[257 "\3008\205\211@\207" [2] 3 "\n\n(fn VV)"] ignore 2 pcase--small-branch-p let #[257 "\211@A@D\207" [] 3 "\n\n(fn VV)"] append make-symbol format "pcase-%d" lambda car funcall cadr] 12 "\n\n(fn VARVALS COUNT &rest _)"]] 7 "\n\n(fn CODE)"] pcase-compile-patterns mapcar #[257 "\211@\300A!B\207" [V0] 4 "\n\n(fn CASE)"] macroexp-let*] 10 (#$ . 11469)])#@46 Expands all macro-patterns in PAT. (fn PAT) (defalias 'pcase--macroexpand #[257 "\211\242\211\300\267\202)\301!\203\302D\207\207\207\211\303\304A\"B\207\305A@\304\3068!E\207\307!\211\2055\310A\"\211\204H\311\203B\312\202C\313#\207\304!\207" [#s(hash-table size 7 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (nil 8 pred 20 guard 20 quote 20 or 22 and 22 app 30)) pcase--self-quoting-p quote mapcar pcase--macroexpand app 2 pcase--get-macroexpander apply error "Unexpandable %s pattern: %S" "Unknown %s pattern: %S"] 8 (#$ . 12379)])#@273 Define a new kind of pcase PATTERN, by macro expansion. Patterns of the form (NAME ...) will be expanded according to this macro. By convention, DOC should use "EXPVAL" to stand for the result of evaluating EXP (first arg to `pcase'). (fn NAME ARGS [DOC] &rest BODY...) (defalias 'pcase-defmacro '(macro . #[642 "\300\301\302\"!\303\236\211\203\304\"\262\305\306\307BBBD\310\311D\312\311\313\236A@DF\310\311 D\314\315DFF\207" [intern format "%s--pcase-macroexpander" declare remove progn eval-and-compile defun define-symbol-prop quote 'edebug-form-spec debug 'pcase-macroexpander function] 13 (#$ . 12960)])) (byte-code "\300\301\302\303#\304\301\305\306#\210\300\301\307\310#\300\207" [function-put pcase-defmacro lisp-indent-function 2 put edebug-form-spec defun doc-string-elt 3] 5)#@80 Build a MATCH structure, hoisting all `or's and `and's outside. (fn VAL UPAT) (defalias 'pcase--match #[514 "\211\242\300>\203\211@\301\302\303\"A\"B\207\304BB\207" [(or and) mapcar make-closure #[257 "\301\300\"\207" [V0 pcase--match] 4 "\n\n(fn UPAT)"] match] 7 (#$ . 13772)])#@13 (fn CODE) (defalias 'pcase--small-branch-p #[257 "\211G\300U\205*\211@:?\206*\301@\211\203&\211@\211:\203\302\262A\266\202\202\210\211\262\207" [1 t nil] 5 (#$ . 14064)])#@23 (fn TEST THEN ELSE) (defalias 'pcase--if #[771 "\211\300=\203 \301\302DE\207\300=\203\301\302DE\207\303#\207" [:pcase--dontcare progn ignore macroexp-if] 7 (#$ . 14253)])#@539 Expand matcher for rules BRANCHES. Each BRANCH has the form (MATCH CODE . VARS) where CODE is the code generator for that branch. MATCH is the pattern that needs to be matched, of the form: (match VAR . PAT) (and MATCH ...) (or MATCH ...) VARS is the set of vars already bound by earlier matches. It is a list of (NAME VAL . USED) where NAME is the variable's symbol, VAL is the expression to which it should be bound and USED is a boolean recording whether the var has been referenced by earlier parts of the match. (fn BRANCHES) (defalias 'pcase--u #[257 "\300\301\"\211\262\205\211@\211@A\211@A\302C A$\266\205\207" [delq nil pcase--u1] 11 (#$ . 14443)])#@22 (fn MATCH MATCHES) (defalias 'pcase--and #[514 "\211\203\n\300BB\207\207" [and] 5 (#$ . 15123)]) (defconst pcase-mutually-exclusive-predicates '((symbolp . integerp) (symbolp . numberp) (symbolp . consp) (symbolp . arrayp) (symbolp . vectorp) (symbolp . stringp) (symbolp . byte-code-function-p) (symbolp . compiled-function-p) (symbolp . recordp) (integerp . consp) (integerp . arrayp) (integerp . vectorp) (integerp . stringp) (integerp . byte-code-function-p) (integerp . compiled-function-p) (integerp . recordp) (numberp . consp) (numberp . arrayp) (numberp . vectorp) (numberp . stringp) (numberp . byte-code-function-p) (numberp . compiled-function-p) (numberp . recordp) (consp . arrayp) (consp . atom) (consp . vectorp) (consp . stringp) (consp . byte-code-function-p) (consp . compiled-function-p) (consp . recordp) (arrayp . byte-code-function-p) (arrayp . compiled-function-p) (vectorp . byte-code-function-p) (vectorp . compiled-function-p) (vectorp . recordp) (stringp . vectorp) (stringp . recordp) (stringp . byte-code-function-p) (stringp . compiled-function-p)))#@20 (fn PRED1 PRED2) (defalias 'pcase--mutually-exclusive-p #[514 "B\235\206 \211B\235\207" [pcase-mutually-exclusive-predicates] 4 (#$ . 16215)])#@27 (fn SYM SPLITTER MATCH) (defalias 'pcase--split-match #[771 "\211\242\300=\203&A@=\204\211B\207AA!\211@\206A\206$B\207\211\242\301>\203\277\302\211@\303=\203:\304\202;\305@\303=\203F\305\202G\304A\211\203z\211@\306  #\211@=\204d\211@B\262\211A=\204r\211AB\262\210A\266\202\202I\210\211>\203\205\211\202\234\204\215\202\234A\204\227@\202\234@\237B>\203\246\202\275\204\256\202\275A\204\270@\202\275@\237BB\207\211\307>\203\311\211B\207\310\311\"\207" [match (or and) nil or :pcase--fail :pcase--succeed pcase--split-match (:pcase--succeed :pcase--fail) error "Unknown MATCH %s"] 13 (#$ . 16371)])#@26 (fn SYM SPLITTER REST) (defalias 'pcase--split-rest #[771 "\300\211\211\203=\211@\211@A\301  #\211@\302=\204$\211@BB\262\211A\302=\2044\211ABB\262\266A\266\202\202\210\237\237B\207" [nil pcase--split-match :pcase--fail] 13 (#$ . 17043)])#@17 (fn ELEM PAT) (defalias 'pcase--split-equal #[514 "\211\242\300=\203\211A@\232\203\301\207\211\242\300=\203\302\207\211\242\303=\205E\211A@9\205E\211A@\304N\205E\3051C\211A@!\203@\306\202A\3070\207\210\310\207" [quote (:pcase--succeed . :pcase--fail) (:pcase--fail) pred side-effect-free (error) (:pcase--succeed) (:pcase--fail) nil] 4 (#$ . 17310)])#@18 (fn ELEMS PAT) (defalias 'pcase--split-member #[514 "\211\242\300=\203\211A@\235\203\301\207\211\242\300=\203\302\207\211\242\303=\205\\\211A@9\205\\\211A@\304N\205\\\3051V\211A@\306\211\203O\211@!\204H\301\262A\266\202\2029\210\2620\202X\210\301\205\\\307\207" [quote nil (:pcase--fail) pred side-effect-free (error) t (:pcase--succeed)] 8 (#$ . 17682)])#@432 Indicate the overlap or mutual-exclusion between UPAT and PAT. More specifically returns a pair (A . B) where A indicates whether PAT can match when UPAT has matched, and B does the same for the case where UPAT failed to match. A and B can be one of: - nil if we don't know - `:pcase--fail' if UPAT match's result implies that PAT can't match - `:pcase--succeed' if UPAT match's result implies that PAT matches (fn VARS UPAT PAT) (defalias 'pcase--split-pred #[771 "\300\232\203 @\301=\203A@9\204\302A@\"\204 \303\207\242\301=\203GA@\242\304=\203GA@A@\305\301D#\306\211@!A!B\207@\301=\204P\300\207A@\242\304=\203kA@A@\305\301D#\211A@B\207\242\301=\203xA@\202\256\242\307=\204\203\300\202\256A@:\203\216\310\202\256A@;\203\231\311\202\256\312A@!\203\245\312\202\256\313A@!\205\256\313\314A@\"\262\203\273\315\207A@\242\316=\203\363A@A@\317>\203\363\320A@8\242\307=\203\363\242\307=\203\363\320A@8A@A@\235\203\361\321\207\322\207\242\307=\205>A@9\205>A@9\204A@;\204A@\247\205>A@\323N\205>\32411A@A@!C\211\2620\2023\210\300\205>\211@\203=\325\207\326\207" [nil pred macroexp--fgrep (:pcase--succeed . :pcase--fail) not pcase--split-pred #[257 "\211\300\267\202\n\301\207\302\207\303\207" [#s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (:pcase--succeed 6 :pcase--fail 8)) :pcase--fail :pcase--succeed nil] 3 "\n\n(fn X)"] quote consp stringp vectorp compiled-function-p pcase--mutually-exclusive-p (:pcase--fail) pcase--flip (memq member memql) 2 (nil . :pcase--fail) (:pcase--fail) side-effect-free (error) (nil . :pcase--fail) (:pcase--fail)] 10 (#$ . 18068)])#@13 (fn UPAT) (defalias 'pcase--self-quoting-p #[257 "\300!\206 \211\250\206 \211;\207" [keywordp] 3 (#$ . 19760)])#@27 (fn MATCH SYM FUN NSYM) (defalias 'pcase--app-subst-match #[1028 "\242\300=\203.A@=\203,AA\242\301=\203,AAA@\232\203,\302\303AA8\"\207\207\242\304>\203F@\305\306\307$A\"B\207\310>\203N\207\311\312\"\207" [match app pcase--match 2 (or and) mapcar make-closure #[257 "\303\302\301\300$\207" [V0 V1 V2 pcase--app-subst-match] 6 "\n\n(fn MATCH)"] (:pcase--succeed :pcase--fail) error "Unknown MATCH %s"] 11 (#$ . 19882)])#@26 (fn REST SYM FUN NSYM) (defalias 'pcase--app-subst-rest #[1028 "\300\301\302$\"\207" [mapcar make-closure #[257 "\303@\302\301\300$AB\207" [V0 V1 V2 pcase--app-subst-match] 6 "\n\n(fn BRANCH)"]] 10 (#$ . 20336)])#@12 (fn SYM) (defalias 'pcase--mark-used #[257 "\2119\205\n\300\301\302#\207" [put pcase-used t] 5 (#$ . 20563)]) (byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put pcase--mark-used speed -1 put byte-optimizer byte-compile-inline-expand] 5)#@91 Helper function, used internally to avoid (funcall (lambda ...) ...). (fn FUN ARG1 ARG2) (defalias 'pcase--flip '(macro . #[771 "E\207" [] 6 (#$ . 20824)])) (put 'pcase--flip 'edebug-form-spec '(sexp body))#@63 Build a function call to FUN with arg ARG. (fn FUN ARG VARS) (defalias 'pcase--funcall #[771 "9\203 D\207\242\300=\203\300\301A@#D\207\302\303\304\"\"\236\2034\305\306!\211DB\262\262\307!\204?:\204H\310\311DE\202M\312C\"\204R\207\313E\207" [not pcase--funcall mapcar #[257 "\211A\300\241\210\211@A@D\207" [used] 3 "\n\n(fn X)"] macroexp--fgrep gensym "x" functionp funcall function append let*] 8 (#$ . 21040)])#@60 Build an expression that will evaluate EXP. (fn EXP VARS) (defalias 'pcase--eval #[514 "\236\211\203\211A\300\241\210\211A@\207\301\"\211\203 \302\303\304\"\"\207\207" [used macroexp--fgrep macroexp-let* mapcar #[257 "\211A\300\241\210\211@A@D\207" [used] 3 "\n\n(fn X)"]] 8 (#$ . 21492)])#@192 Return code that runs CODE (with VARS) if MATCHES match. Otherwise, it defers to REST which is a list of branches of the form (ELSE-MATCH ELSE-CODE . ELSE-VARS). (fn MATCHES CODE VARS REST) (defalias 'pcase--u1 #[1028 "\204!\207@\300=\203\301!\207@\302=\203\"\303A$\207@@\304=\2038\303\305@AA\"$\207@@\306=\203<@A\211@@\307=\205O\211@A@\310\211\311\203\255\211\203\254\211@\211@\307=\203\240A@=\203\240\211AA\211\242\312=\262\203\240\211AAA@\211\250\203\216\311=\203\226\313\262\202\226\2119\204\226\314\262\211B\262\210\202\245\211B\262A\266\202\202W\210\204\272\315\316!\210\301!\207G\317V\203\377\303\307\320\321\312 DEF\nAB  \204\336 \202\375\322A\203\355\306\237B\202\360@A\"\f\fBB\nB$\207\303\211A\262\242\nAB  \204\315\316!\210 \202:\322 A\203*\306\nB\202- @A\"\f\fBB\nB$\207@@\307=\203\372\211A\262\242\211@\210\310A\211@A\211\323\267\202x\303    $\324=\203k\207\325\326\310\211%\207\266\327\207\211\242\330>\203\314\211@\320=\203\223\2119\205\221\331\332\333#\266\334\335\336 ##\211@A\337@\320=\203\266\340A@ #\202\275\341A@\f\"\303$\301!#\207\2119\203\211\203\2119\205\340\331\332\333#\266\211\236\211\204\372\303\n\nD B\n$\207\211A\342\241\210\303\307\320\343A@DF B\n\n\n$\207\211\242\344=\203]\2119\205&\331\332\333#\266\211A@\345\346!\303\347\3508\"\fB  \351\f $$\332N\204O\207\352\340#DC\"\207\211\242\312=\203\321\2119\205o\331\332\333#\266\211A@\334\335\353\" #\211@A\337\204\215\354D\202\302\250\203\233\343E\202\3029\203\272\355!\203\257\356E\202\302\356\312DE\202\302\357\312DE\303$\301!#\207\211\242\360=\203\365\303\307A@BBC\335\361 \" \304 B\f\fBBC$\207\315\362\"\207\315\363@\"\207" [:pcase--fail pcase--u :pcase--succeed pcase--u1 and append or match nil memq quote memql member error "Please avoid it" 1 pred pcase--flip pcase--and #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (t 346 _ 346 pcase--dontcare 372)) _ macroexp-warn-and-return "Pattern t is deprecated. Use `_' instead" :pcase--dontcare (guard pred) put pcase-used t pcase--split-rest make-closure #[257 "\302\301\300#\207" [V0 V1 pcase--split-pred] 5 "\n\n(fn PAT)"] pcase--if pcase--funcall pcase--eval used eql app gensym "x" pcase--match 2 pcase--app-subst-rest macroexp-let* #[257 "\301\300\"\207" [V0 pcase--split-equal] 4 "\n\n(fn PAT)"] null pcase--self-quoting-p eq equal not #[257 "\301\300!\207" [V0 pcase--u] 3 "\n\n(fn VARS)"] "Unknown pattern `%S'" "Incorrect MATCH %S"] 20 (#$ . 21800)]) (def-edebug-elem-spec 'pcase-QPAT '(&or ("," pcase-PAT) (pcase-QPAT [&rest [¬ ","] pcase-QPAT] . [&or nil pcase-QPAT]) (vector &rest pcase-QPAT) sexp))#@1089 Backquote-style pcase patterns: \=`QPAT QPAT can take the following forms: (QPAT1 . QPAT2) matches if QPAT1 matches the car and QPAT2 the cdr. [QPAT1 QPAT2..QPATn] matches a vector of length n and QPAT1..QPATn match its 0..(n-1)th elements, respectively. ,PAT matches if the `pcase' pattern PAT matches. SYMBOL matches if EXPVAL is `equal' to SYMBOL. KEYWORD likewise for KEYWORD. NUMBER likewise for NUMBER. STRING likewise for STRING. The list or vector QPAT is a template. The predicate formed by a backquote-style pattern is a combination of those formed by any sub-patterns, wrapped in a top-level condition: EXPVAL must be "congruent" with the template. For example: \=`(technical ,forum) The predicate is the logical-AND of: - Is EXPVAL a list of two elements? - Is the first element the symbol `technical'? - True! (The second element can be anything, and for the sake of the body forms, its value is bound to the symbol `forum'.) (fn QPAT) (defalias '\`--pcase-macroexpander #[257 "\211\242\300=\203 \211A@\207\301!\203C\302\303\304\305GE\306G\307\211W\2039\304\310\311E\312 HDEB\262\211T\262\202\266\211\237\262BBB\207\211:\203[\302\313\304\314\312@DE\304\315\312ADEF\207\211;\204j\211\247\204j\2119\203n\316D\207\317\320\"\207" [\, vectorp and (pred vectorp) app length nil 0 pcase--flip aref \` (pred consp) car-safe cdr-safe quote error "Unknown QPAT: %S"] 12 (#$ . 24653)]) (byte-code "\300\301\302\303#\300\304\305\301#\300\207" [define-symbol-prop \`--pcase-macroexpander edebug-form-spec (pcase-QPAT) \` pcase-macroexpander] 5)#@45 Matches if EXPR matches PAT. (fn PAT EXPR) (defalias 'let--pcase-macroexpander #[514 "\300\301\302EE\207" [app lambda (_)] 6 (#$ . 26368)]) (byte-code "\300\301\302\303#\300\304\305\301#\306\307!\207" [define-symbol-prop let--pcase-macroexpander edebug-form-spec (pcase-PAT form) let pcase-macroexpander provide pcase] 5)