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/map.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 'seq)
#@540 Build a `pcase' pattern matching map elements.

ARGS is a list of elements to be matched in the map.

Each element of ARGS can be of the form (KEY PAT), in which case KEY is
evaluated and searched for in the map.  The match fails if for any KEY
found in the map, the corresponding PAT doesn't match the value
associated to the KEY.

Each element can also be a SYMBOL, which is an abbreviation of a (KEY
PAT) tuple of the form (\='SYMBOL SYMBOL).

Keys in ARGS not found in the map are ignored, and the match doesn't
fail.

(fn &rest ARGS)
(defalias 'map--pcase-macroexpander #[128 "\300\301\302!BB\207" [and (pred mapp) map--make-pcase-bindings] 5 (#$ . 424)])
(byte-code "\300\301\302\303#\300\304\305\301#\303\207" [define-symbol-prop map--pcase-macroexpander edebug-form-spec nil map pcase-macroexpander] 5)
#@330 Bind the variables in KEYS to the elements of MAP then evaluate BODY.

KEYS can be a list of symbols, in which case each element will be
bound to the looked up value in MAP.

KEYS can also be a list of (KEY VARNAME) pairs, in which case
KEY is an unquoted form.

MAP can be a list, hash-table or array.

(fn KEYS MAP &rest BODY)
(defalias 'map-let '(macro . #[642 "\300\301!DCBB\207" [pcase-let map--make-pcase-patterns] 6 (#$ . 1243)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put map-let lisp-indent-function 2 put edebug-form-spec ((&rest &or symbolp ([form symbolp])) form body)] 5)
#@330 Lookup KEY in MAP and return its associated value.
If KEY is not found, return DEFAULT which defaults to nil.

If MAP is a list, `eql' is used to lookup KEY.  Optional argument
TESTFN, if non-nil, means use its function definition instead of
`eql'.

MAP can be a list, hash-table or array.

(fn MAP KEY &optional DEFAULT TESTFN)
(defalias 'map-elt #[1026 "<\203
\300\301%\207\302!\203\303#\207\304!\2034\305Y\2032\306!W\2032\307\"\207\207\310\311\"\207" [alist-get nil hash-table-p gethash arrayp 0 seq-length seq-elt error "Unsupported map: %s"] 10 (#$ . 1862)])
(byte-code "\300\301\302\303#\300\207" [function-put map-elt gv-expander #[1283 "\300\301D\302\303\304\305\306\n\n\n$\307\"\310\311%\"\207" [gv-get gv-delay-error make-byte-code 514 "\301\304!\203\211\202\305\306!\302\304!\203\211\202\305\307!\303\304!\203'\211\202*\305\310!\311\312	D\313\314\315

E\316\257\300\"\300\317\f\n	F\320\321\322\323\324\"\325\"\326\327%\"F=\203f\211\202m\330DC\"\266\203=\203y\211\202\200\330DC\"\266\203=\203\214\211\202\223\330DC\"\207" vconcat vector [macroexp-const-p make-symbol "key" "default" "testfn" if listp gv-get alist-get gv-synthetic-place nil map-elt make-byte-code 257 "\302\300\301F\207" vconcat vector [map--put] 5 "\n\n(fn V)" macroexp-let*] 20 "\n\n(fn MGETTER MSETTER)"] 16 "\n\n(fn DO MAP KEY &optional DEFAULT TESTFN)"]] 4)
#@283 Associate KEY with VALUE in MAP and return VALUE.
If KEY is already present in MAP, replace the associated value
with VALUE.
When MAP is a list, test equality with TESTFN if non-nil, otherwise use `eql'.

MAP can be a list, hash-table or array.

(fn MAP KEY VALUE &optional TESTFN)
(defalias 'map-put '(macro . #[1027 "\300\301\302\257E\207" [setf map-elt nil] 10 (#$ . 3290)]))
#@190 Delete KEY from MAP and return MAP.
No error is signaled if KEY is not a key of MAP.  If MAP is an
array, store nil at the index KEY.

MAP can be a list, hash-table or array.

(fn MAP KEY)
(defalias 'map-delete #[514 "<\203\211\236\211\203\300\"\262\210\202E\301!\203$\302\"\210\202E\303!\203@\211\304Y\203E\211\305!X\203E\306I\210\202E\307\310\"\210\207" [delq hash-table-p remhash arrayp 0 seq-length nil error "Unsupported map: %s"] 6 (#$ . 3681)])
#@177 Traverse MAP using KEYS and return the looked up value or DEFAULT if nil.

Map can be a nested map composed of alists, hash-tables and arrays.

(fn MAP KEYS &optional DEFAULT)
(defalias 'map-nested-elt #[770 "\300\301#\206	\211\207" [seq-reduce #[514 "\300!\205\n\301\"\207" [mapp map-elt] 5 "\n\n(fn ACC KEY)"]] 7 (#$ . 4165)])
#@84 Return the list of keys in MAP.

MAP can be a list, hash-table or array.

(fn MAP)
(defalias 'map-keys #[257 "\300\301\"\207" [map-apply #[514 "\207" [] 3 "\n\n(fn KEY _)"]] 4 (#$ . 4507)])
#@86 Return the list of values in MAP.

MAP can be a list, hash-table or array.

(fn MAP)
(defalias 'map-values #[257 "\300\301\"\207" [map-apply #[514 "\207" [] 3 "\n\n(fn _ VALUE)"]] 4 (#$ . 4705)])
#@111 Return the elements of MAP as key/value association lists.

MAP can be a list, hash-table or array.

(fn MAP)
(defalias 'map-pairs #[257 "\300\301\"\207" [map-apply cons] 4 (#$ . 4909)])
#@78 Return the length of MAP.

MAP can be a list, hash-table or array.

(fn MAP)
(defalias 'map-length #[257 "\300!G\207" [map-keys] 3 (#$ . 5103)])
#@74 Return a copy of MAP.

MAP can be a list, hash-table or array.

(fn MAP)
(defalias 'map-copy #[257 "\211<\203	\300!\207\301!\203\302!\207\303!\203\300!\207\304\305\"\207" [seq-copy hash-table-p copy-hash-table arrayp error "Unsupported map: %s"] 4 (#$ . 5255)])
#@194 Apply FUNCTION to each element of MAP and return the result as a list.
FUNCTION is called with two arguments, the key and the value.

MAP can be a list, hash-table or array.

(fn FUNCTION MAP)
(defalias 'map-apply #[514 "\211<\203	\300\202!\301!\203\302\202!\303!\203\304\202!\305\306\"\"\207" [map--apply-alist hash-table-p map--apply-hash-table arrayp map--apply-array error "Unsupported map: %s"] 5 (#$ . 5535)])
#@136 Apply FUNCTION to each element of MAP and return nil.
FUNCTION is called with two arguments, the key and the value.

(fn FUNCTION MAP)
(defalias 'map-do #[514 "\211<\203	\300\202!\301!\203\302\202!\303!\203\304\202!\305\306\"\"\207" [map--do-alist hash-table-p maphash arrayp map--do-array error "Unsupported map: %s"] 5 (#$ . 5971)])
#@120 Return the result of applying FUNCTION to each key of MAP.

MAP can be a list, hash-table or array.

(fn FUNCTION MAP)
(defalias 'map-keys-apply #[514 "\300\301\302\303\304\305!\306\"\307\310%\"\207" [map-apply make-byte-code 514 "\300!\207" vconcat vector [] 4 "\n\n(fn KEY _)"] 9 (#$ . 6326)])
#@122 Return the result of applying FUNCTION to each value of MAP.

MAP can be a list, hash-table or array.

(fn FUNCTION MAP)
(defalias 'map-values-apply #[514 "\300\301\302\303\304\305!\306\"\307\310%\"\207" [map-apply make-byte-code 514 "\300!\207" vconcat vector [] 4 "\n\n(fn _ VAL)"] 9 (#$ . 6633)])
#@134 Return an alist of key/val pairs for which (PRED key val) is non-nil in MAP.

MAP can be a list, hash-table or array.

(fn PRED MAP)
(defalias 'map-filter #[514 "\300\301\302\303\304\305\306\307	!\310\"\311\312%\"\"\207" [delq nil map-apply make-byte-code 514 "\300\"\205\nB\207" vconcat vector [] 5 "\n\n(fn KEY VAL)"] 11 (#$ . 6944)])
#@134 Return an alist of the key/val pairs for which (PRED key val) is nil in MAP.

MAP can be a list, hash-table or array.

(fn PRED MAP)
(defalias 'map-remove #[514 "\300\301\302\303\304\305!\306\"\307\310%\"\207" [map-filter make-byte-code 514 "\300\"?\207" vconcat vector [] 5 "\n\n(fn KEY VAL)"] 9 (#$ . 7295)])
#@71 Return non-nil if MAP is a map (list, hash-table or array).

(fn MAP)
(defalias 'mapp #[257 "\211<\206\300!\206\301!\207" [hash-table-p arrayp] 3 (#$ . 7617)])
#@84 Return non-nil if MAP is empty.

MAP can be a list, hash-table or array.

(fn MAP)
(defalias 'map-empty-p #[257 "\211<\203\211?\207\300!\203\301!\302U\207\303!\203\304!\207\305\306\"\207" [hash-table-p hash-table-count 0 arrayp seq-empty-p error "Unsupported map: %s"] 4 (#$ . 7789)])
#@182 If MAP contain KEY return KEY, nil otherwise.
Equality is defined by TESTFN if non-nil or by `equal' if nil.

MAP can be a list, hash-table or array.

(fn MAP KEY &optional TESTFN)
(defalias 'map-contains-key #[770 "\300\301!#\207" [seq-contains map-keys] 7 (#$ . 8092)])
#@134 Return a non-nil if (PRED key val) is non-nil for any key/value pair in MAP.

MAP can be a list, hash-table or array.

(fn PRED MAP)
(defalias 'map-some #[514 "\3002\301\302\303\304\305\306!\307\"\310\311%\"\210\3120\207" [map--break map-apply make-byte-code 514 "\300\"\211\205\f\301\302\"\207" vconcat vector [throw map--break] 6 "\n\n(fn KEY VALUE)" nil] 9 (#$ . 8374)])
#@134 Return non-nil if (PRED key val) is non-nil for all elements of the map MAP.

MAP can be a list, hash-table or array.

(fn PRED MAP)
(defalias 'map-every-p #[514 "\3002\301\302\303\304\305\306!\307\"\310\311%\"\210\3120\207" [map--break map-apply make-byte-code 514 "\300\"\206\301\302\303\"\207" vconcat vector [throw map--break nil] 5 "\n\n(fn KEY VALUE)" t] 9 (#$ . 8764)])
#@127 Merge into a map of type TYPE all the key/value pairs in MAPS.

MAP can be a list, hash-table or array.

(fn TYPE &rest MAPS)
(defalias 'map-merge #[385 "\300\211A\262\242\"C\203'\301\302\303\304\305\306!\307\"\310\311%\211A\262\242\"\210\202\n\211\242\207" [map-into map-apply make-byte-code 514 "\300\242<\203&\211\300\242\236\203\241\202!\300B\211\262\300\242B\240\266\202\202,\301\300\242#\207" vconcat vector [map--put] 8 "\n\n(fn KEY VALUE)"] 10 (#$ . 9157)])
#@237 Merge into a map of type TYPE all the key/value pairs in MAPS.
When two maps contain the same key, call FUNCTION on the two
values and use the value returned by it.
MAP can be a list, hash-table or array.

(fn TYPE FUNCTION &rest MAPS)
(defalias 'map-merge-with #[642 "\300\211A\262\242\"C\301\211B\203.\302\303\304\305\306\307	#\310\"\311\312%\211A\262\242\"\210\202
\242\207" [map-into nil map-apply make-byte-code 514 "\302\301\242<\203@\301\242\236\303\304\305\306\307\300\302\n#\310\"\311\312%\203$A\202%!\2030\241\202;\301B\211\262\301\242B\240\266\202\202]\313\301\242\303\304\305\306\307\300\302\f#\310\"\311\312%\314\301\242#!#\207" vconcat vector [make-byte-code 257 "\211\301=\203\302\207\300\302\"\207" vconcat vector [] 4 "\n\n(fn OLD)" map--put map-elt] 15 "\n\n(fn KEY VALUE)"] 14 (#$ . 9655)])
#@164 Convert the map MAP into a map of type TYPE.

TYPE can be one of the following symbols: list or hash-table.
MAP can be a list, hash-table or array.

(fn MAP TYPE)
(defalias 'map-into #[514 "\211\300\267\202\301!\207\302!\207\303\304\"\207" [#s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (list 6 hash-table 10)) map-pairs map--into-hash-table error "Not a map type name: %S"] 5 (#$ . 10513)])
#@18 

(fn MAP KEY V)
(defalias 'map--put #[771 "<\203\300\"\211\203\211\241\202\301\302\"\207\303!\203$\304#\207\305!\203/I\207\301\306\"\207" [assoc error "No place to change the mapping for %S" hash-table-p puthash arrayp "Unsupported map: %s"] 7 (#$ . 10955)])
#@90 Private function used to apply FUNCTION over MAP, MAP being an alist.

(fn FUNCTION MAP)
(defalias 'map--apply-alist #[514 "\300\301\302\303\304\305!\306\"\307\310%\"\207" [seq-map make-byte-code 257 "\300@A\"\207" vconcat vector [] 4 "\n\n(fn PAIR)"] 9 (#$ . 11243)])
#@94 Private function used to apply FUNCTION over MAP, MAP being a hash-table.

(fn FUNCTION MAP)
(defalias 'map--apply-hash-table #[514 "\300C\301\302\303\304\305\306\"\307\"\310\311%\"\210\211\242\237\207" [nil maphash make-byte-code 514 "\301\300\"\301\242B\240\207" vconcat vector [] 6 "\n\n(fn KEY VALUE)"] 11 (#$ . 11523)])
#@90 Private function used to apply FUNCTION over MAP, MAP being an array.

(fn FUNCTION MAP)
(defalias 'map--apply-array #[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 (#$ . 11861)])
#@82 Private function used to iterate over ALIST using FUNCTION.

(fn FUNCTION ALIST)
(defalias 'map--do-alist #[514 "\300\301\302\303\304\305!\306\"\307\310%\"\207" [seq-do make-byte-code 257 "\300@A\"\207" vconcat vector [] 4 "\n\n(fn PAIR)"] 9 (#$ . 12177)])
#@82 Private function used to iterate over ARRAY using FUNCTION.

(fn FUNCTION ARRAY)
(defalias 'map--do-array #[514 "\300\301\302\303\304\305!\306\"\307\310%\"\207" [seq-do-indexed make-byte-code 514 "\300\"\207" vconcat vector [] 5 "\n\n(fn ELT INDEX)"] 9 (#$ . 12445)])
#@42 Convert MAP into a hash-table.

(fn MAP)
(defalias 'map--into-hash-table #[257 "\300\301\302!\303\304$C\305\306\307\310\311\312!\313\"\314\315%\"\210\211\242\207" [make-hash-table :size map-length :test equal map-apply make-byte-code 514 "\300\242<\203&\211\300\242\236\203\241\202!\300B\211\262\300\242B\240\266\202\202,\301\300\242#\207" vconcat vector [map--put] 8 "\n\n(fn KEY VALUE)"] 9 (#$ . 12724)])
#@80 Return a list of pcase bindings from ARGS to the elements of a map.

(fn ARGS)
(defalias 'map--make-pcase-bindings #[257 "\300\301\"\207" [seq-map #[257 "\211:\203\300\301\302@EA@E\207\300\301\302\303DEE\207" [app pcase--flip map-elt quote] 6 "\n\n(fn ELT)"]] 4 (#$ . 13156)])
#@73 Return a list of `(map ...)' pcase patterns built from ARGS.

(fn ARGS)
(defalias 'map--make-pcase-patterns #[257 "\300\301\302\"B\207" [map seq-map #[257 "\211:\203\211@\300=\203\301!\207\207" [map map--make-pcase-patterns] 3 "\n\n(fn ELT)"]] 5 (#$ . 13446)])
(provide 'map)