;ELC ;;; Compiled ;;; in Emacs version 25.3.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 'dash) #@127 Create a hash table with the key-value pairs given. Keys are compared with `equal'. (fn (KEY-1 VALUE-1) (KEY-2 VALUE-2) ...) (defalias 'ht '(macro . #[(&rest pairs) "\303\304!\305\306 \"\307\310BC\311\nC\"*BB\207" [table-symbol pairs assignments make-symbol "ht-temp" mapcar #[(pair) "\302 BB\207" [table-symbol pair ht-set!] 3] let ((ht-create)) append] 5 (#$ . 427)])) #@36 Associate KEY in TABLE with VALUE. (defalias 'ht-set! #[(table key value) "\303 \n#\210\304\207" [key value table puthash nil] 4 (#$ . 810)]) (byte-code "\300\301\302\303#\210\304\305\301\"\207" [put ht-set! byte-optimizer byte-compile-inline-expand defalias ht-set] 4) #@204 Create an empty hash table. TEST indicates the function used to compare the hash keys. Default is `equal'. It can be `eq', `eql', `equal' or a user-supplied test created via `define-hash-table-test'. (defalias 'ht-create #[(&optional test) "\301\302\206\303\"\207" [test make-hash-table :test equal] 3 (#$ . 1088)]) (put 'ht-create 'byte-optimizer 'byte-compile-inline-expand) #@236 Create a hash table with initial values according to ALIST. TEST indicates the function used to compare the hash keys. Default is `equal'. It can be `eq', `eql', `equal' or a user-supplied test created via `define-hash-table-test'. (defalias 'ht<-alist #[(alist &optional test) "\306\307\206 \310\")\311\n!\312\211\2039\f@\211@ A\f \f \f \313\f  #\210-\fA\211\204\312 +\207" [test h alist pair --dolist-tail-- value make-hash-table :test equal reverse nil puthash key table] 5 (#$ . 1478)]) (defalias 'ht-from-alist 'ht<-alist) #@236 Create a hash table with initial values according to PLIST. TEST indicates the function used to compare the hash keys. Default is `equal'. It can be `eq', `eql', `equal' or a user-supplied test created via `define-hash-table-test'. (defalias 'ht<-plist #[(plist &optional test) "\306\307\206 \310\")\311\312\n\"\313\211\203;\f@\211@ A@   \314 #\210-\fA\211\204\313 +\207" [test h plist pair --dolist-tail-- value make-hash-table :test equal -partition 2 nil puthash key table] 5 (#$ . 2037)]) (defalias 'ht-from-plist 'ht<-plist) #@115 Look up KEY in TABLE, and return the matching value. If KEY isn't present, return DEFAULT (nil if not specified). (defalias 'ht-get #[(table key &optional default) "\303 \n#\207" [key table default gethash] 4 (#$ . 2603)]) (put 'ht-get 'byte-optimizer 'byte-compile-inline-expand) #@170 Look up KEYS in nested hash tables, starting with TABLE. The lookup for each key should return another hash table, except for the final key, which may return any value. (defalias 'ht-get* #[(table &rest keys) "A\203\304\305 @\306\307 \n#+A#\207 @\306\307 \n#+\207" [keys table default key apply ht-get* nil gethash] 6 (#$ . 2892)]) #@63 Update TABLE according to every key-value pair in FROM-TABLE. (defalias 'ht-update! #[(table from-table) "\301\302\"\210\303\207" [from-table maphash #[(key value) "\303 \n#\207" [key value table puthash] 4] nil] 3 (#$ . 3244)]) (defalias 'ht-update 'ht-update!) #@151 Crete a new tables that includes all the key-value pairs from TABLES. If multiple have tables have the same key, the value in the last table is used. (defalias 'ht-merge #[(&rest tables) "\303\304\305\206 \306\")\307\310\n\"\210 )\207" [test merged tables nil make-hash-table :test equal mapc #[(table) "\302 \"\207" [merged table ht-update!] 3]] 3 (#$ . 3516)]) #@24 Remove KEY from TABLE. (defalias 'ht-remove! #[(table key) "\302 \"\207" [key table remhash] 3 (#$ . 3890)]) (byte-code "\300\301\302\303#\210\304\305\301\"\207" [put ht-remove! byte-optimizer byte-compile-inline-expand defalias ht-remove] 4) #@29 Remove all keys from TABLE. (defalias 'ht-clear! #[(table) "\301!\210\302\207" [table clrhash nil] 2 (#$ . 4140)]) (byte-code "\300\301\302\303#\210\304\305\301\"\207" [put ht-clear! byte-optimizer byte-compile-inline-expand defalias ht-clear] 4) #@135 Apply FUNCTION to each key-value pair of TABLE, and make a list of the results. FUNCTION is called with two arguments, KEY and VALUE. (defalias 'ht-map #[#'table "\302\303\304 \"\210)\207" [results table nil maphash #[(key value) " \n\" B\211\207" [function key value results] 3]] 3 (#$ . 4395)]) #@121 Anaphoric version of `ht-map'. For every key-value pair in TABLE, evaluate FORM with the variables KEY and VALUE bound. (defalias 'ht-amap '(macro . #[(form table) "\302\303\304E E\207" [form table ht-map lambda (key value)] 4 (#$ . 4703)])) #@41 Return a list of all the keys in TABLE. (defalias 'ht-keys #[(table) "\301\302\"\207" [table ht-map #[(key value) "\207" [key] 1]] 3 (#$ . 4952)]) #@43 Return a list of all the values in TABLE. (defalias 'ht-values #[(table) "\301\302\"\207" [table ht-map #[(key value) "\207" [value] 1]] 3 (#$ . 5107)]) #@61 Return a list of two-element lists '(key value) from TABLE. (defalias 'ht-items #[(table) "\301\302\"\207" [table ht-map #[(key value) " D\207" [key value] 2]] 3 (#$ . 5268)]) (defalias 'ht-each 'maphash "Apply FUNCTION to each key-value pair of TABLE.\nReturns nil, used for side-effects only.") #@122 Anaphoric version of `ht-each'. For every key-value pair in TABLE, evaluate FORM with the variables key and value bound. (defalias 'ht-aeach '(macro . #[(form table) "\302\303\304E E\207" [form table ht-each lambda (key value)] 4 (#$ . 5574)])) #@54 Return a copy of TABLE with only the specified KEYS. (defalias 'ht-select-keys #[(table keys) "\305\306\307\310 !\"\n\305\211\203.\f@\311 \312#\312\232\204'\313 \311 \"#\210\fA\211\204\305+\207" [result table keys key --dolist-tail-- nil make-hash-table :test hash-table-test gethash key-not-found puthash] 6 (#$ . 5826)]) #@267 Return a flat list '(key1 value1 key2 value2...) from TABLE. Note that hash tables are unordered, so this cannot be an exact inverse of `ht<-plist'. The following is not guaranteed: (let ((data '(a b c d))) (equalp data (ht->plist (ht<-plist data)))) (defalias 'ht->plist #[(table) "\301\302\303!\"\207" [table apply append ht-items] 4 (#$ . 6171)]) (defalias 'ht-to-plist 'ht->plist) #@62 Return a shallow copy of TABLE (keys and values are shared). (defalias 'ht-copy #[(table) "\301!\207" [table copy-hash-table] 2 (#$ . 6578)]) (put 'ht-copy 'byte-optimizer 'byte-compile-inline-expand) #@276 Return a list of two-element lists '(key . value) from TABLE. Note that hash tables are unordered, so this cannot be an exact inverse of `ht<-alist'. The following is not guaranteed: (let ((data '((a . b) (c . d)))) (equalp data (ht->alist (ht<-alist data)))) (defalias 'ht->alist #[(table) "\301\302\"\207" [table ht-map #[(key value) " B\207" [key value] 2]] 3 (#$ . 6787)]) (byte-code "\300\301\302\"\210\300\303\304\"\210\300\305\304\"\207" [defalias ht-to-alist ht->alist ht\? hash-table-p ht-p] 3) #@34 Return 't if TABLE contains KEY. (defalias 'ht-contains\? #[(table key) " \303\304 \n#+\303=?\207" [table key default ht--not-found gethash] 4 (#$ . 7314)]) (defalias 'ht-contains-p 'ht-contains\?) #@47 Return the actual number of entries in TABLE. (defalias 'ht-size #[(table) "\301!\207" [table hash-table-count] 2 (#$ . 7523)]) (put 'ht-size 'byte-optimizer 'byte-compile-inline-expand) #@63 Return true if the actual number of entries in TABLE is zero. (defalias 'ht-empty\? #[(table) "\301!)\302U\207" [table hash-table-count 0] 2 (#$ . 7717)]) (put 'ht-empty\? 'byte-optimizer 'byte-compile-inline-expand) #@151 Return a hash table containing all entries in TABLE for which FUNCTION returns a truthy value. FUNCTION is called with two arguments, KEY and VALUE. (defalias 'ht-select #[#'table "\303\304\305\206 \306\")\307\310\n\"\210 )\207" [test results table nil make-hash-table :test equal ht-each #[(key value) " \n\"\205 \n\305 \n\f#\210+\306\207" [function key value results table puthash nil] 4]] 3 (#$ . 7944)]) #@150 Return a hash table containing all entries in TABLE for which FUNCTION returns a falsy value. FUNCTION is called with two arguments, KEY and VALUE. (defalias 'ht-reject #[#'table "\303\304\305\206 \306\")\307\310\n\"\210 )\207" [test results table nil make-hash-table :test equal ht-each #[(key value) " \n\"?\205 \n\305 \n\f#\210+\306\207" [function key value results table puthash nil] 4]] 3 (#$ . 8371)]) #@124 Delete entries from TABLE for which FUNCTION returns a falsy value. FUNCTION is called with two arguments, KEY and VALUE. (defalias 'ht-reject! #[#'table "\301\302\"\210\303\207" [table ht-each #[(key value) " \n\"\205 \304 \"\207" [function key value table remhash] 3] nil] 3 (#$ . 8798)]) (defalias 'ht-delete-if 'ht-reject!) #@152 Return (key, value) from TABLE for which FUNCTION returns a truthy value. Return nil otherwise. FUNCTION is called with two arguments, KEY and VALUE. (defalias 'ht-find #[#'table "\3012 \302\303\"0\207" [table break ht-each #[(key value) " \n\"\205 \303\304 \nD\"\207" [function key value throw break] 4]] 3 (#$ . 9138)]) #@100 Return t if TABLE1 and TABLE2 have the same keys and values. Does not compare equality predicates. (defalias 'ht-equal\? #[(table1 table2) "\306!\306 !\307\310!\211G G\232\205s\311\f\311\312\211\203n\203n@ \2047\313\202_\313\314#+ \n\314#+\232)TA\211\204#+\315 !)+\207" [table1 table2 sentinel keys2 keys1 #1=#:all ht-keys make-symbol "ht-sentinel" t 0 nil gethash ---truthy\? it-index #2=#:continue #3=#:list it default key table] 6 (#$ . 9472)]) (byte-code "\300\301\302\"\210\303\304!\207" [defalias ht-equal-p ht-equal\? provide ht] 3)