Current File : //proc/thread-self/root/kunden/usr/share/emacs/27.2/lisp/emacs-lisp/pcase.elc

;ELC
;;; Compiled
;;; in Emacs version 27.2
;;; 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 '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\303#\210\300\304\302\305#\210\300\306\302\307#\207" [put pcase-PAT edebug-form-spec (&or symbolp ("or" &rest pcase-PAT) ("and" &rest pcase-PAT) ("guard" form) ("let" pcase-PAT form) ("pred" pcase-FUN) ("app" pcase-FUN pcase-PAT) pcase-MACRO sexp) pcase-FUN (&or lambda-expr (functionp &rest form) sexp) pcase-MACRO pcase--edebug-match-macro] 4)
#@15 

(fn CURSOR)
(defalias 'pcase--edebug-match-macro #[257 "\300C\301\302\303\304\305\306!\307\"\310\311%!\210\312\313\242B\"\207" [nil mapatoms make-byte-code 257 "\211\301N\211\205\302
!\205\300\303!\302!B\300\242B\240\207" vconcat vector [pcase-macroexpander get-edebug-spec symbol-name] 6 "\n\n(fn S)" edebug-match &or] 9 (#$ . 973)])
#@1734 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.
  (app FUN PAT)    matches if FUN called on EXPVAL matches PAT.
  (guard BOOLEXP)  matches if BOOLEXP evaluates to non-nil.
  (let PAT EXPR)   matches if EXPR matches PAT.
  (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, EXPR, 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\203

A@\232\203\211AA\202,\302\"\303@BB#\210\211\262
\207" [pcase--memoize gethash pcase--expand puthash] 9 (#$ . 1328)]))
(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!r\211q\210\310\311\312\313\314!\315\"\316$\216
A\206&c\210\317C\320\310\321\322\313\314!\323\"\324\325%!\210\326
\242\236

\327\242\"B\240\266\211\242\203{\211\242
\211\242A\240\210\242\211@
A\300
\302\"\330c\210\331\332!\317%\262
\333
\206t\334\261\266\202I\210\335 \203\212\336
@\"\202\213\211\262
*\262
\207" [documentation pcase raw help-split-fundoc require help-fns generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205	\302\300!\207" vconcat vector [buffer-name kill-buffer] 2 nil mapatoms 257 "\211\301N\211\205\300B\300\242B\240\207" [pcase-macroexpander] 5 "\n\n(fn SYMBOL)" \` delq "\n\n-- " help-fns--signature indirect-function "\n" "Not documented." buffer-string help-add-fundoc-usage] 14])
#@144 The exhaustive version of `pcase' (which see).
If EXP fails to match any of the patterns in CASES, an error is signaled.

(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 (#$ . 4299)]))
(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!\310\"\311\312%\"\313
\314@\315\242\237ABBC\"BB\207" [nil macroexp-parse-body mapcar make-byte-code 257 "\2119\203\207\301\302\303\300\242G\"!\300D\300\242B\240\210\211\207" vconcat vector [make-symbol format "arg%s"] 5 "\n\n(fn PAT)" lambda append pcase-let*] 12 (#$ . 4788)]))
(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\304
A@@\303\"D\305B\"\207" [macroexp-progn pcase--trivial-upat-p macroexp-let* pcase--let* pcase--expand ((pcase--dontcare nil))] 9 (#$ . 5632)])
#@476 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 (i.e. be of compatible structure) to its
respective 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\202\302\"\303B#\210\211\262
\207" [pcase--memoize gethash pcase--let* puthash] 8 (#$ . 5910)]))
(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)
#@581 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 (i.e. be of compatible structure) to its
respective 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\210
A\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 (#$ . 6732)]))
(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!\301
AB\304@DCBBE\207" [pcase--trivial-upat-p dolist gensym "x" pcase-let*] 8 (#$ . 7812)]))
(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)
#@13 

(fn UPAT)
(defalias 'pcase--trivial-upat-p #[257 "\2119\205	\211>?\207" [pcase--dontcare-upats] 3 (#$ . 8735)])
#@18 

(fn EXP CASES)
(defalias 'pcase--expand #[514 "
\301
!\203\211\202\302\303!\304C\304C\305\306\307\310\311\"\312\"\313\314%\304C\315\316\305\317\320\310\311		#\321\"\322\323%	\"!\211\203]\211@\211\242>\204V\211@>\204V\324\325@\"\210
A\266\202\202<\210\326\242\"\266\205
=\203o\211\202v\326DC\"\207" [pcase--dontwarn-upats macroexp-copyable-p make-symbol "val" nil make-byte-code 514 "\211C\301\242\236\211\204 \302\242\"\301\242E\301\242B\240\210\211\262
\202\202\211@
A\211@
A\211@\2119\204`\303\304\305\300\242G\"!\300
\306\307\310\"	BBD\300\242B\240\210
\311\240\210

\307\312\"B\241\210AA
\240\210\262
\313\242!\240\210\307\314\315\316\317\320\f!\321\"\322\323%\"\311BB\262
\266\205\262
\207" vconcat vector [pcase-codegen make-symbol format "pcase-%d" lambda mapcar car funcall cdr copy-sequence make-byte-code 257 "\211@\300\242\236\300\301\300\242\"\240\210\211A\207" vconcat vector [delq] 6 "\n\n(fn PA)"] 16 "\n\n(fn CODE VARS)" pcase--u mapcar 257 "\303\300\304@!\"\305\306\307\310\311\301\302#\312\"\313\314%D\207" [pcase--match pcase--macroexpand make-byte-code 257 "\302\301\242>\204\301\302\301\242B\240\210\303\302A!\203\304\202\300\302A\"\207" vconcat vector [pcase--small-branch-p pcase-codegen] 4 "\n\n(fn VARS)"] 10 "\n\n(fn CASE)" message "Redundant pcase pattern: %S" macroexp-let*] 18 (#$ . 8857)])
#@46 Expands all macro-patterns in PAT.

(fn PAT)
(defalias 'pcase--macroexpand #[257 "\211\242\211\204\300!\203\301D\202k
\202k\211\302\267\202E
\202k\211\303\304A\"B\202k\305\304A@!AABB\202k\306A@\304\3078!E\202k\211\310N\211\205Q\311
A\"\211\204f\312\203^\313\202_\314#\202i\304
!\266\202\207" [pcase--self-quoting-p quote #s(hash-table size 7 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (pred 28 guard 28 quote 28 or 32 and 32 let 42 app 56)) mapcar pcase--macroexpand let app 2 pcase-macroexpander apply error "Unexpandable %s pattern: %S" "Unknown %s pattern: %S"] 8 (#$ . 10250)])
#@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\306BBB\307\310D\311\310\312\236A@DF\307\310	D\313\314DFF\207" [intern format "%s--pcase-macroexpander" declare remove progn defun define-symbol-prop quote 'edebug-form-spec debug 'pcase-macroexpander function] 13 (#$ . 10888)]))
(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\304\305\306!\307\"\310\311%A\"B\207\312BB\207" [(or and) mapcar make-byte-code 257 "\301\300\"\207" vconcat vector [pcase--match] 4 "\n\n(fn UPAT)" match] 10 (#$ . 11679)])
#@18 

(fn CODE VARS)
(defalias 'pcase-codegen #[514 "\211\203
\300\301\302\"BB\207\303B\207" [let mapcar #[257 "\211@
AD\207" [] 3 "\n\n(fn B)"] progn] 6 (#$ . 12011)])
#@13 

(fn CODE)
(defalias 'pcase--small-branch-p #[257 "\211G\300U\205*\211@:?\206*\301
@\211\203&\211@\211:\203\302\262
A\266\202\202\210\211\262
\207" [1 t nil] 5 (#$ . 12186)])
#@23 

(fn TEST THEN ELSE)
(defalias 'pcase--if #[771 "\211\300=\203
\207
\300=\203\301 \210\207\302#\207" [:pcase--dontcare debug macroexp-if] 7 (#$ . 12376)])
#@319 Expand matcher for rules BRANCHES.
Each BRANCH has the form (MATCH CODE . VARS) where
CODE is the code generator for that branch.
VARS is the set of vars already bound by earlier matches.
MATCH is the pattern that needs to be matched, of the form:
  (match VAR . PAT)
  (and MATCH ...)
  (or 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 (#$ . 12546)])
#@22 

(fn MATCH MATCHES)
(defalias 'pcase--and #[514 "\211\203\n\300BB\207
\207" [and] 5 (#$ . 13007)])
(defconst pcase-mutually-exclusive-predicates '((symbolp . integerp) (symbolp . numberp) (symbolp . consp) (symbolp . arrayp) (symbolp . vectorp) (symbolp . stringp) (symbolp . byte-code-function-p) (symbolp . recordp) (integerp . consp) (integerp . arrayp) (integerp . vectorp) (integerp . stringp) (integerp . byte-code-function-p) (integerp . recordp) (numberp . consp) (numberp . arrayp) (numberp . vectorp) (numberp . stringp) (numberp . byte-code-function-p) (numberp . recordp) (consp . arrayp) (consp . atom) (consp . vectorp) (consp . stringp) (consp . byte-code-function-p) (consp . recordp) (arrayp . byte-code-function-p) (vectorp . byte-code-function-p) (vectorp . recordp) (stringp . vectorp) (stringp . recordp) (stringp . byte-code-function-p)))
#@20 

(fn PRED1 PRED2)
(defalias 'pcase--mutually-exclusive-p #[514 "

B\235\206
\211B\235\207" [pcase-mutually-exclusive-predicates] 4 (#$ . 13878)])
#@27 

(fn SYM SPLITTER MATCH)
(defalias 'pcase--split-match #[771 "\211\242\300=\203&
A@=\204\211
B\207

AA!\211@\206

A\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\210
A\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\211
B\207\310\311\"\207" [match (or and) nil or :pcase--fail :pcase--succeed pcase--split-match (:pcase--succeed :pcase--fail) error "Uknown MATCH %s"] 13 (#$ . 14035)])
#@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\266
A\266\202\202\210
\237
\237B\207" [nil pcase--split-match :pcase--fail] 13 (#$ . 14707)])
#@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 (#$ . 14975)])
#@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\262
A\266\202\2029\210\262
0\202X\210\301\205\\\307\207" [quote nil (:pcase--fail) pred side-effect-free (error) t (:pcase--succeed)] 8 (#$ . 15348)])
#@22 

(fn VARS UPAT PAT)
(defalias 'pcase--split-pred #[771 "\300\232\203&@\301=\203A@9\204\"\302\303\304\"A@\"\204&\305\202\323@\301=\203
\242\301=\203:
A@\202p
\242\306=\204E\300\202p
A@:\203P\307\202p
A@;\203[\310\202p\311A@!\203g\311\202p\312A@!\205p\312\313A@\"\262
\203\314\202\323@\301=\205\323
\242\306=\205\323A@9\205\323
A@9\204\251
A@;\204\251
A@\247\205\323A@\315N\205\323\3161\304A@A@!C\211\2620\202\306\210\300\205\323\211@\203\322\317\202\323\320\207" [nil pred pcase--fgrep mapcar car (:pcase--succeed . :pcase--fail) quote consp stringp vectorp byte-code-function-p pcase--mutually-exclusive-p (:pcase--fail) side-effect-free (error) (nil . :pcase--fail) (:pcase--fail)] 8 (#$ . 15734)])
#@65 Check which of the symbols VARS appear in SEXP.

(fn VARS SEXP)
(defalias 'pcase--fgrep #[514 "\300
:\203+\301\211A\262\242\"\211\203'\211@\211>\204 \211B\262
A\266\202\202\210\202

>\203<

>\204<

B\262
\211\207" [nil pcase--fgrep] 7 (#$ . 16493)])
#@13 

(fn UPAT)
(defalias 'pcase--self-quoting-p #[257 "\300
!\206
\211\250\206
\211;\207" [keywordp] 3 (#$ . 16764)])
#@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>\203O@\305\306\307\310\311\312			#\313\"\314\315%A\"B\207\316>\203W\207\317\320\"\207" [match app pcase--match 2 (or and) mapcar make-byte-code 257 "\303
\300\301\302$\207" vconcat vector [pcase--app-subst-match] 6 "\n\n(fn MATCH)" (:pcase--succeed :pcase--fail) error "Uknown MATCH %s"] 14 (#$ . 16887)])
#@26 

(fn REST SYM FUN NSYM)
(defalias 'pcase--app-subst-rest #[1028 "\300\301\302\303\304\305#\306\"\307\310%\"\207" [mapcar make-byte-code 257 "\303
@\300\301\302$
AB\207" vconcat vector [pcase--app-subst-match] 6 "\n\n(fn BRANCH)"] 13 (#$ . 17374)])
#@12 

(fn SYM)
(defalias 'pcase--mark-used #[257 "\2119\205\n\300
\301\302#\207" [put pcase-used t] 5 (#$ . 17636)])
(put 'pcase--mark-used 'byte-optimizer 'byte-compile-inline-expand)
#@91 Helper function, used internally to avoid (funcall (lambda ...) ...).

(fn FUN ARG1 ARG2)
(defalias 'pcase--flip '(macro . #[771 "
E\207" [] 6 (#$ . 17824)]))
(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\300\301\302\"\"\301\303\304\305\306\307!\310\"\311\312%\">\2032\313\314!\211DB\262\262\315!\203B\316\317DE\202G\320C\"\204O\211\202S\321E\207" [pcase--fgrep mapcar car make-byte-code 257 "\211
\300\236AD\207" vconcat vector [] 4 "\n\n(fn VAR)" gensym "x" functionp funcall function append let*] 11 (#$ . 18041)])
#@60 Build an expression that will evaluate EXP.

(fn EXP VARS)
(defalias 'pcase--eval #[514 "

\236\211\203\f\211A\2022\300\301\302\"\"\301\303\304\305\306\307!\310\"\311\312%\"\211\203/\313
\"\2020\266\202\207" [pcase--fgrep mapcar car make-byte-code 257 "\211
\300\236AD\207" vconcat vector [] 4 "\n\n(fn V)" macroexp-let*] 11 (#$ . 18496)])
#@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\240
A@=\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\262
A\266\202\202W\210\204\274\315\316!\210\301!\202?
G\317V\203
\303\307\320\321\312	DEF\nAB		\204\340	\202\377\322A\203\357\306\237B\202\362@A\"\f\fBB\nB$\202?
\303\211A\262\242\nAB		\204 
\315\316!\210	\202>
\322	A\203.
\306\nB\2021
	@A\"\f\fBB\nB$\207@@\307=\203m\211A\262\242\211@
A\211@
A\211\323\267\202}
\303				$
\324=\203p
\211\202t
\325\326\"\262
\202l\327\202l\211\242\330>\203\336
\211@\320=\203\230

\2119\205\226
\331
\332\333#\266\334\335\336\337\340\341
\"\342\"\343\344%#\211@
A\345@\320=\203\304
\346A@
#\202\313
\347A@\f\"\303$\301!#\266\203\202l\2119\203%\211\203%
\2119\205\362
\331
\332\333#\266\211\236\204\f\303		B\nB	$\202l\303\307\320\350\f\236ADF\nB			$\202l\211\242\351=\203g\347\3528\"\353
!\203=\211\202@\354\355!\303\356A@\"\fB$
=\203[\211\202b\357DC\"\266\203\202l\211\242\360=\203\267
\2119\205y\331
\332\333#\266\211A@\361\362!\303\356\3528\"\fB\363\f	$$
\332N\204\245\211\202\262\357\346#DC\"\266\203\202l\211\242\312=\2038
\2119\205\311\331
\332\333#\266\211A@\334\335\336\364\340\341!\365\"\366\344%	#\211@
A\345\204\360\367D\202%\250\203\376\370E\202%9\203\371!\203\350E\202%\350\312DE\202%\372\312DE\303$\301!#\266\204\202l\211\242\373=\203f\303\307A@BBC\335\336\374\340\341\f!\375\"\376\377%	\304
B\f\fBBC$\202l\315\201@\"\207\315\201A@\"\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 348 _ 348 pcase--dontcare 377)) _ macroexp--warn-and-return "Pattern t is deprecated.  Use `_' instead" :pcase--dontcare (guard pred) put pcase-used t pcase--split-rest make-byte-code 257 "\302\300\301#\207" vconcat vector [pcase--split-pred] 5 "\n\n(fn PAT)" pcase--if pcase--funcall pcase--eval eq let 2 macroexp-copyable-p make-symbol "sym" pcase--match macroexp-let* app gensym "x" pcase--app-subst-rest "\301\300\"\207" [pcase--split-equal] 4 null eql pcase--self-quoting-p equal not "\301\300!\207" [pcase--u] 3 "\n\n(fn VARS)" "Unknown pattern `%S'" "Incorrect MATCH %S"] 20 (#$ . 18855)])
(put 'pcase-QPAT 'edebug-form-spec '(&or ("," pcase-PAT) (pcase-QPAT [&rest [&not ","] 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
!\203E\302\303\304\305GE\306G\307\211W\203;\211\304\310\311E\312\nHDEB\262\210\211T\262
\202\266\211\237\262
BBB\207\211:\203]\302\313\304\314\312@DE\304\315\312ADEF\207\211;\204l\211\247\204l\2119\203p\316
D\207\317\320\"\207" [\, vectorp and (pred vectorp) app length nil 0 pcase--flip aref \` (pred consp) car cdr quote error "Unknown QPAT: %S"] 13 (#$ . 21940)])
(byte-code "\300\301\302\303#\300\304\305\301#\306\307!\207" [define-symbol-prop \`--pcase-macroexpander edebug-form-spec (pcase-QPAT) \` pcase-macroexpander provide pcase] 5)