mirror of https://github.com/Chizi123/.emacs.d.git

Chizi123
2018-11-19 a4b9172aefa91861b587831e06f55b1e19f3f3be
commit | author | age
5cb5f7 1 ;ELC
C 2 ;;; Compiled
3 ;;; in Emacs version 26.1
4 ;;; with all optimizations.
5
6 ;;; This file uses dynamic docstrings, first added in Emacs 19.29.
7
8 ;;; This file does not contain utf-8 non-ASCII characters,
9 ;;; and so can be loaded in Emacs versions earlier than 23.
10
11 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
12 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
13
14
15 (custom-declare-group 'dash nil "Customize group for dash.el" :group 'lisp :prefix "dash-")
16 #@21 
17
18 (fn SYMBOL VALUE)
19 (defalias 'dash--enable-fontlock #[514 "\211\203\300 \210\301\"\207" [dash-enable-font-lock set-default] 5 (#$ . 500)])
20 (byte-code "\300\301\302\303\304DD\305\306\307\310\311\312\313&    \207" [custom-declare-variable dash-enable-fontlock funcall function #[0 "\300\207" [nil] 1] "If non-nil, enable fontification of dash functions, macros and\nspecial values." :type boolean :set dash--enable-fontlock :group dash] 10)
21 #@64 Destructive: Set CDR to the cons of CAR and CDR.
22
23 (fn CAR CDR)
24 (defalias '!cons '(macro . #[514 "\300\301EE\207" [setq cons] 7 (#$ . 947)]))
25 #@54 Destructive: Set LIST to the cdr of LIST.
26
27 (fn LIST)
28 (defalias '!cdr '(macro . #[257 "\300\301DE\207" [setq cdr] 5 (#$ . 1097)]))
29 #@50 Anaphoric form of `-each'.
30
31 (fn LIST &rest BODY)
32 (defalias '--each '(macro . #[385 "\300\301!\302D\303B\304\302\305\306DDCBB\307\310D\257E\207" [make-symbol "list" let ((it-index 0)) while it car (setq it-index (1+ it-index)) !cdr] 11 (#$ . 1235)]))
33 (byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put --each edebug-form-spec (form body) function-put lisp-indent-function 1] 4)
34 #@251 Eval a form, then insert that form as the 2nd argument to other forms.
35 The EVAL-INITIAL-VALUE form is evaluated once. Its result is
36 passed to FORMS, which are then evaluated sequentially. Returns
37 the target form.
38
39 (fn EVAL-INITIAL-VALUE &rest FORMS)
40 (defalias '-doto '(macro . #[385 "\300\301!\302DC\303\304\305\306\307\310\311    !\312\"\313\314%\"C\"BB\207" [make-symbol "value" let append mapcar make-byte-code 257 "\301!\203\302!\300ABB\207\303\304\300E\207" vconcat vector [sequencep -first-item funcall form] 4 "\n\n(fn FORM)"] 13 (#$ . 1643)]))
41 (byte-code "\300\301\302\303#\300\207" [function-put -doto lisp-indent-function 1] 4)
42 #@88 Call FN with every item in LIST. Return nil, used for side-effects only.
43
44 (fn LIST FN)
45 (defalias '-each #[514 "\300\205@!\266\211T\262A\262\202\207" [0] 7 (#$ . 2295)])
46 (byte-code "\300\301\302\303#\210\304\305\306\"\207" [put -each lisp-indent-function 1 defalias --each-indexed --each] 4)
47 #@170 Call (FN index item) for each item in LIST.
48
49 In the anaphoric form `--each-indexed', the index is exposed as symbol `it-index'.
50
51 See also: `-map-indexed'.
52
53 (fn LIST FN)
54 (defalias '-each-indexed #[514 "\300\205@\"\266\211T\262A\262\202\207" [0] 8 (#$ . 2606)])
55 (put '-each-indexed 'lisp-indent-function 1)
56 #@61 Anaphoric form of `-each-while'.
57
58 (fn LIST PRED &rest BODY)
59 (defalias '--each-while '(macro . #[642 "\300\301!\300\302!\303D\304B\305BB\306\307E\303\310\311DDC\312\313 D\314    \315BB BBBE\316\317D\257E\207" [make-symbol "list" "continue" let (t) ((it-index 0)) while and it car if not setq (nil) (setq it-index (1+ it-index)) !cdr] 16 (#$ . 2931)]))
60 (byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put --each-while edebug-form-spec (form form body) function-put lisp-indent-function 2] 4)
61 #@122 Call FN with every item in LIST while (PRED item) is non-nil.
62 Return nil, used for side-effects only.
63
64 (fn LIST PRED FN)
65 (defalias '-each-while #[771 "\300\301\205)\205)@!\204\302\262\202!\210\210\211T\262A\262\202\207" [t 0 nil] 9 (#$ . 3452)])
66 (put '-each-while 'lisp-indent-function 2)
67 #@52 Anaphoric form of `-each-r'.
68
69 (fn LIST &rest BODY)
70 (defalias '--each-r '(macro . #[385 "\300\301!\302\303DD\304\305DD\306BB\307\310\311\312\313\314\315BBEBBBBE\207" [make-symbol "vector" let* vconcat it-index length (it) while (> it-index 0) (setq it-index (1- it-index)) setq it aref (it-index)] 13 (#$ . 3767)]))
71 (byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put --each-r edebug-form-spec (form body) function-put lisp-indent-function 1] 4)
72 #@107 Call FN with every item in LIST in reversed order.
73  Return nil, used for side-effects only.
74
75 (fn LIST FN)
76 (defalias '-each-r #[514 "\300!\211G\301\302V\205S\262H\262!\210\202\207" [vconcat nil 0] 7 (#$ . 4239)])
77 #@63 Anaphoric form of `-each-r-while'.
78
79 (fn LIST PRED &rest BODY)
80 (defalias '--each-r-while '(macro . #[642 "\300\301!\302\303DD\304\305DD\306BB\307\310\311\312\313\314\315BBE\316\317\nD\320\nBBB\257E\207" [make-symbol "vector" let* vconcat it-index length (it) while (> it-index 0) (setq it-index (1- it-index)) setq it aref (it-index) if not (setq it-index -1)] 14 (#$ . 4470)]))
81 (byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put --each-r-while edebug-form-spec (form form body) function-put lisp-indent-function 2] 4)
82 #@131 Call FN with every item in reversed LIST while (PRED item) is non-nil.
83 Return nil, used for side-effects only.
84
85 (fn LIST PRED FN)
86 (defalias '-each-r-while #[771 "\300!\211G\301\302V\205(S\262H\262!\204!\303\262\202!\210\202\207" [vconcat nil 0 -1] 8 (#$ . 5018)])
87 #@134 Repeatedly executes BODY (presumably for side-effects) with symbol `it' bound to integers from 0 through NUM-1.
88
89 (fn NUM &rest BODY)
90 (defalias '--dotimes '(macro . #[385 "\300\301!\302D\303B\304\305\306E\307\310\"BBE\207" [make-symbol "num" let ((it 0)) while < it append ((setq it (1+ it)))] 10 (#$ . 5307)]))
91 (byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put --dotimes edebug-form-spec (form body) function-put lisp-indent-function 1] 4)
92 #@106 Repeatedly calls FN (presumably for side-effects) passing in integers from 0 through NUM-1.
93
94 (fn NUM FN)
95 (defalias '-dotimes #[514 "\300\211W\205!\210\211T\262\202\207" [0] 6 (#$ . 5774)])
96 (put '-dotimes 'lisp-indent-function 1)
97 #@95 Return a new list consisting of the result of applying FN to the items in LIST.
98
99 (fn FN LIST)
100 (defalias '-map #[514 "\300\"\207" [mapcar] 5 (#$ . 6018)])
101 #@43 Anaphoric form of `-map'.
102
103 (fn FORM LIST)
104 (defalias '--map '(macro . #[514 "\300\301\302EE\207" [mapcar lambda (it)] 6 (#$ . 6180)]))
105 (put '--map 'edebug-form-spec '(form form))
106 #@65 Anaphoric form of `-reduce-from'.
107
108 (fn FORM INITIAL-VALUE LIST)
109 (defalias '--reduce-from '(macro . #[771 "\300\301DC\302\303\301EE\304BBB\207" [let acc --each setq (acc)] 10 (#$ . 6366)]))
110 (put '--reduce-from 'edebug-form-spec '(form form form))
111 #@354 Return the result of applying FN to INITIAL-VALUE and the
112 first item in LIST, then applying FN to that result and the 2nd
113 item, etc. If LIST contains no items, return INITIAL-VALUE and
114 do not call FN.
115
116 In the anaphoric form `--reduce-from', the accumulated value is
117 exposed as symbol `acc'.
118
119 See also: `-reduce', `-reduce-r'
120
121 (fn FN INITIAL-VALUE LIST)
122 (defalias '-reduce-from #[771 "\300\203@\"\262\210\211T\262A\262\202\266\211\207" [0] 10 (#$ . 6623)])
123 #@46 Anaphoric form of `-reduce'.
124
125 (fn FORM LIST)
126 (defalias '--reduce '(macro . #[514 "\300\301!\302DC\303\304\305D\306DF\302\307    EFE\207" [make-symbol "list-value" let if --reduce-from car cdr (acc it)] 12 (#$ . 7102)]))
127 (put '--reduce 'edebug-form-spec '(form form))
128 #@404 Return the result of applying FN to the first 2 items in LIST,
129 then applying FN to that result and the 3rd item, etc. If LIST
130 contains no items, return the result of calling FN with no
131 arguments. If LIST contains a single item, return that item
132 and do not call FN.
133
134 In the anaphoric form `--reduce', the accumulated value is
135 exposed as symbol `acc'.
136
137 See also: `-reduce-from', `-reduce-r'
138
139 (fn FN LIST)
140 (defalias '-reduce #[514 "\211\203\f\300@A#\207 \207" [-reduce-from] 6 (#$ . 7383)])
141 #@70 Anaphoric version of `-reduce-r-from'.
142
143 (fn FORM INITIAL-VALUE LIST)
144 (defalias '--reduce-r-from '(macro . #[771 "\300\301DF\207" [--reduce-from reverse] 8 (#$ . 7882)]))
145 (put '--reduce-r-from 'edebug-form-spec '(form form form))
146 #@331 Replace conses with FN, nil with INITIAL-VALUE and evaluate
147 the resulting expression. If LIST is empty, INITIAL-VALUE is
148 returned and FN is not called.
149
150 Note: this function works the same as `-reduce-from' but the
151 operation associates from right instead of from left.
152
153 See also: `-reduce-r', `-reduce'
154
155 (fn FN INITIAL-VALUE LIST)
156 (defalias '-reduce-r-from #[771 "\300!\301\203@\"\262\210\211T\262A\262\202\266\211\207" [reverse 0] 10 (#$ . 8121)])
157 #@51 Anaphoric version of `-reduce-r'.
158
159 (fn FORM LIST)
160 (defalias '--reduce-r '(macro . #[514 "\300\301DE\207" [--reduce reverse] 6 (#$ . 8592)]))
161 (put '--reduce-r 'edebug-form-spec '(form form))
162 #@480 Replace conses with FN and evaluate the resulting expression.
163 The final nil is ignored. If LIST contains no items, return the
164 result of calling FN with no arguments. If LIST contains a single
165 item, return that item and do not call FN.
166
167 The first argument of FN is the new item, the second is the
168 accumulated value.
169
170 Note: this function works the same as `-reduce' but the operation
171 associates from right instead of from left.
172
173 See also: `-reduce-r-from', `-reduce'
174
175 (fn FN LIST)
176 (defalias '-reduce-r #[514 "\211\203:\300!\211\2031\211@A\301\203)@\"\262\210\211T\262A\262\202\266\211\262\2029\302\211\"\266\202\207 \207" [reverse 0 nil] 10 (#$ . 8791)])
177 #@188 Return a list of the intermediate values of the reduction.
178
179 See `-reduce-from' for explanation of the arguments.
180
181 See also: `-reductions', `-reductions-r', `-reduce-r'
182
183 (fn FN INIT LIST)
184 (defalias '-reductions-from #[771 "C\300\203 @@\"B\262\210\211T\262A\262\202\266\211\262\237\207" [0] 10 (#$ . 9475)])
185 #@183 Return a list of the intermediate values of the reduction.
186
187 See `-reduce' for explanation of the arguments.
188
189 See also: `-reductions-from', `-reductions-r', `-reduce-r'
190
191 (fn FN LIST)
192 (defalias '-reductions #[514 "\211\205 \300@A#\207" [-reductions-from] 6 (#$ . 9806)])
193 #@188 Return a list of the intermediate values of the reduction.
194
195 See `-reduce-r-from' for explanation of the arguments.
196
197 See also: `-reductions-r', `-reductions', `-reduce'
198
199 (fn FN INIT LIST)
200 (defalias '-reductions-r-from #[771 "C\300!\301\203\"@@\"B\262\210\211T\262A\262\202\266\211\207" [reverse 0] 10 (#$ . 10086)])
201 #@183 Return a list of the intermediate values of the reduction.
202
203 See `-reduce-r' for explanation of the arguments.
204
205 See also: `-reductions-r-from', `-reductions', `-reduce'
206
207 (fn FN LIST)
208 (defalias '-reductions-r #[514 "\211\2050\300!\211@CA\301\203)@@\"B\262\210\211T\262A\262\202 \266\211\262\262\207" [reverse 0] 10 (#$ . 10425)])
209 #@69 Anaphoric form of `-filter'.
210
211 See also: `--remove'.
212
213 (fn FORM LIST)
214 (defalias '--filter '(macro . #[514 "\300\301!\302C\303\304\305\306EEE\307DF\207" [make-symbol "result" let --each when !cons it nreverse] 12 (#$ . 10778)]))
215 (put '--filter 'edebug-form-spec '(form form))
216 #@145 Return a new list of the items in LIST for which PRED returns a non-nil value.
217
218 Alias: `-select'
219
220 See also: `-keep', `-remove'.
221
222 (fn PRED LIST)
223 (defalias '-filter #[514 "\300\301\203 @!\203\211B\262\210\211T\262A\262\202\266\211\237\207" [nil 0] 8 (#$ . 11065)])
224 (byte-code "\300\301\302\"\210\300\303\304\"\207" [defalias -select -filter --select --filter] 3)
225 #@68 Anaphoric form of `-remove'.
226
227 See also `--filter'.
228
229 (fn FORM LIST)
230 (defalias '--remove '(macro . #[514 "\300\301DE\207" [--filter not] 5 (#$ . 11448)]))
231 (put '--remove 'edebug-form-spec '(form form))
232 #@124 Return a new list of the items in LIST for which PRED returns nil.
233
234 Alias: `-reject'
235
236 See also: `-filter'.
237
238 (fn PRED LIST)
239 (defalias '-remove #[514 "\300\301\203 @!\204\211B\262\210\211T\262A\262\202\266\211\237\207" [nil 0] 8 (#$ . 11657)])
240 (byte-code "\300\301\302\"\210\300\303\304\"\207" [defalias -reject -remove --reject --remove] 3)
241 #@137 Return a new list with the first item matching PRED removed.
242
243 Alias: `-reject-first'
244
245 See also: `-remove', `-map-first'
246
247 (fn PRED LIST)
248 (defalias '-remove-first #[514 "\300\203@!\204@B\262A\262\202\203&\301\237A\"\202(\211\237\207" [nil -concat] 6 (#$ . 12020)])
249 #@52 Anaphoric form of `-remove-first'.
250
251 (fn FORM LIST)
252 (defalias '--remove-first '(macro . #[514 "\300\301\302EE\207" [-remove-first lambda (it)] 6 (#$ . 12308)]))
253 (byte-code "\300\301\302\303#\210\304\305\306\"\210\304\307\301\"\207" [put --remove-first edebug-form-spec (form form) defalias -reject-first -remove-first --reject-first] 4)
254 #@134 Return a new list with the last item matching PRED removed.
255
256 Alias: `-reject-last'
257
258 See also: `-remove', `-map-last'
259
260 (fn PRED LIST)
261 (defalias '-remove-last #[514 "\300\301!\"\237\207" [-remove-first reverse] 6 (#$ . 12653)])
262 #@51 Anaphoric form of `-remove-last'.
263
264 (fn FORM LIST)
265 (defalias '--remove-last '(macro . #[514 "\300\301\302EE\207" [-remove-last lambda (it)] 6 (#$ . 12887)]))
266 (byte-code "\300\301\302\303#\210\304\305\306\"\210\304\307\301\"\207" [put --remove-last edebug-form-spec (form form) defalias -reject-last -remove-last --reject-last] 4)
267 #@92 Remove all occurences of ITEM from LIST.
268
269 Comparison is done with `equal'.
270
271 (fn ITEM LIST)
272 (defalias '-remove-item #[514 "\300\301\203!@\211\232\204\211B\262\210\211T\262A\262\202\266\211\237\207" [nil 0] 8 (#$ . 13224)])
273 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -remove-item pure t side-effect-free] 5)
274 #@44 Anaphoric form of `-keep'.
275
276 (fn FORM LIST)
277 (defalias '--keep '(macro . #[514 "\300\301!\300\302!\303C\304\303    DC\305\306     EEEE\307DF\207" [make-symbol "result" "mapped" let --each when !cons nreverse] 15 (#$ . 13579)]))
278 (put '--keep 'edebug-form-spec '(form form))
279 #@173 Return a new list of the non-nil results of applying FN to the items in LIST.
280
281 If you want to select the original items satisfying a predicate use `-filter'.
282
283 (fn FN LIST)
284 (defalias '-keep #[514 "\300\301\203\"@!\211\203\211B\262\266\211T\262A\262\202\266\211\237\207" [nil 0] 9 (#$ . 13860)])
285 #@49 Return all non-nil elements of LIST.
286
287 (fn LIST)
288 (defalias '-non-nil #[257 "\300\301\"\207" [-remove null] 4 (#$ . 14177)])
289 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -non-nil pure t side-effect-free] 5)
290 #@51 Anaphoric form of `-map-indexed'.
291
292 (fn FORM LIST)
293 (defalias '--map-indexed '(macro . #[514 "\300\301!\302C\303\304EE\305DF\207" [make-symbol "result" let --each !cons nreverse] 10 (#$ . 14414)]))
294 (put '--map-indexed 'edebug-form-spec '(form form))
295 #@211 Return a new list consisting of the result of (FN index item) for each item in LIST.
296
297 In the anaphoric form `--map-indexed', the index is exposed as symbol `it-index'.
298
299 See also: `-each-indexed'.
300
301 (fn FN LIST)
302 (defalias '-map-indexed #[514 "\300\301\203@\"B\262\210\211T\262A\262\202\266\211\237\207" [nil 0] 9 (#$ . 14676)])
303 #@52 Anaphoric form of `-map-when'.
304
305 (fn PRED REP LIST)
306 (defalias '--map-when '(macro . #[771 "\300\301!\302C\303\304\305        \306BBBEE\307DF\207" [make-symbol "result" let --each !cons if (it) nreverse] 13 (#$ . 15024)]))
307 (put '--map-when 'edebug-form-spec '(form form form))
308 #@266 Return a new list where the elements in LIST that do not match the PRED function
309 are unchanged, and where the elements in LIST that do match the PRED function are mapped
310 through the REP function.
311
312 Alias: `-replace-where'
313
314 See also: `-update-at'
315
316 (fn PRED REP LIST)
317 (defalias '-map-when #[771 "\300\301\203'@!\203!\202\211B\262\210\211T\262A\262\202\266\211\237\207" [nil 0] 9 (#$ . 15307)])
318 (byte-code "\300\301\302\"\210\300\303\304\"\207" [defalias -replace-where -map-when --replace-where --map-when] 3)
319 #@145 Replace first item in LIST satisfying PRED with result of REP called on this item.
320
321 See also: `-map-when', `-replace-first'
322
323 (fn PRED REP LIST)
324 (defalias '-map-first #[771 "\300\203@!\204@B\262A\262\202\203+\301\237@!AB\"\202-\211\237\207" [nil -concat] 8 (#$ . 15842)])
325 #@53 Anaphoric form of `-map-first'.
326
327 (fn PRED REP LIST)
328 (defalias '--map-first '(macro . #[771 "\300\301\302E\301\303\304FF\207" [-map-first lambda (it) (it) (ignore it)] 9 (#$ . 16140)]))
329 #@143 Replace last item in LIST satisfying PRED with result of REP called on this item.
330
331 See also: `-map-when', `-replace-last'
332
333 (fn PRED REP LIST)
334 (defalias '-map-last #[771 "\300\301!#\237\207" [-map-first reverse] 8 (#$ . 16336)])
335 #@52 Anaphoric form of `-map-last'.
336
337 (fn PRED REP LIST)
338 (defalias '--map-last '(macro . #[771 "\300\301\302E\301\303\304FF\207" [-map-last lambda (it) (it) (ignore it)] 9 (#$ . 16573)]))
339 #@123 Replace all OLD items in LIST with NEW.
340
341 Elements are compared using `equal'.
342
343 See also: `-replace-at'
344
345 (fn OLD NEW LIST)
346 (defalias '-replace #[771 "\300\301\203%@\211\232\203\202\211B\262\210\211T\262A\262\202\266\211\237\207" [nil 0] 9 (#$ . 16766)])
347 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -replace pure t side-effect-free] 5)
348 #@135 Replace the first occurence of OLD with NEW in LIST.
349
350 Elements are compared using `equal'.
351
352 See also: `-map-first'
353
354 (fn OLD NEW LIST)
355 (defalias '-replace-first #[771 "\300\301\302\303\304\305!\306\"\307\310%\301\302\311\304\305!\306\"\312\310%#\207" [-map-first make-byte-code 257 "\300\232\207" vconcat vector [] 3 "\n\n(fn IT)" "\300\207" 2] 11 (#$ . 17152)])
356 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -replace-first pure t side-effect-free] 5)
357 #@133 Replace the last occurence of OLD with NEW in LIST.
358
359 Elements are compared using `equal'.
360
361 See also: `-map-last'
362
363 (fn OLD NEW LIST)
364 (defalias '-replace-last #[771 "\300\301\302\303\304\305!\306\"\307\310%\301\302\311\304\305!\306\"\312\310%#\207" [-map-last make-byte-code 257 "\300\232\207" vconcat vector [] 3 "\n\n(fn IT)" "\300\207" 2] 11 (#$ . 17640)])
365 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -replace-last pure t side-effect-free] 5)
366 #@46 Anaphoric form of `-mapcat'.
367
368 (fn FORM LIST)
369 (defalias '--mapcat '(macro . #[514 "\300\301\302EE\207" [apply 'append --map] 7 (#$ . 18122)]))
370 (put '--mapcat 'edebug-form-spec '(form form))
371 #@118 Return the concatenation of the result of mapping FN over LIST.
372 Thus function FN should return a list.
373
374 (fn FN LIST)
375 (defalias '-mapcat #[514 "\300\301\302\303\304\305\306\307    !\310\"\311\312%\"\"\207" [apply append mapcar make-byte-code 257 "\300!\207" vconcat vector [] 3 "\n\n(fn IT)"] 11 (#$ . 18320)])
376 #@436 Take a nested list L and return its contents as a single, flat list.
377
378 Note that because `nil' represents a list of zero elements (an
379 empty list), any mention of nil in L will disappear after
380 flattening.  If you need to preserve nils, consider `-flatten-n'
381 or map them to some unique symbol and then map them back.
382
383 Conses of two atoms are considered "terminals", that is, they
384 aren't flattened further.
385
386 See also: `-flatten-n'
387
388 (fn L)
389 (defalias '-flatten #[257 "\211<\203\211A<\203\300\301\"\207\211C\207" [-mapcat -flatten] 4 (#$ . 18637)])
390 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -flatten pure t side-effect-free] 5)
391 #@52 Anaphoric version of `-iterate'.
392
393 (fn FORM INIT N)
394 (defalias '--iterate '(macro . #[771 "\300\301\302EF\207" [-iterate lambda (it)] 7 (#$ . 19297)]))
395 (put '--iterate 'edebug-form-spec '(form form form))
396 #@75 Flatten NUM levels of a nested LIST.
397
398 See also: `-flatten'
399
400 (fn NUM LIST)
401 (defalias '-flatten-n #[514 "\300\301\302T#!\207" [-last-item -iterate #[257 "\300\301\302\303\"\"\207" [apply append mapcar #[257 "\300!\207" [-list] 3 "\n\n(fn IT)"]] 6 "\n\n(fn IT)"]] 7 (#$ . 19509)])
402 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -flatten-n pure t side-effect-free] 5)
403 #@99 Return a new list with the concatenation of the elements in the supplied LISTS.
404
405 (fn &rest LISTS)
406 (defalias '-concat #[128 "\300\301\"\207" [apply append] 4 (#$ . 19906)])
407 (byte-code "\300\301\302\303#\300\301\304\303#\305\306\307\310#\207" [function-put -concat pure t side-effect-free defalias -copy copy-sequence "Create a shallow copy of LIST.\n\n(fn LIST)"] 6)
408 #@323 Splice lists generated by FUN in place of elements matching PRED in LIST.
409
410 FUN takes the element matching PRED as input.
411
412 This function can be used as replacement for `,@' in case you
413 need to splice several lists at marked positions (for example
414 with keywords).
415
416 See also: `-splice-list', `-insert-at'
417
418 (fn PRED FUN LIST)
419 (defalias '-splice #[771 "\300\301\203C@!\2032!\211\301\203-@\211B\262\210\211T\262A\262\202\266\2027\211B\262\210\211T\262A\262\202\266\211\237\207" [nil 0] 13 (#$ . 20280)])
420 #@51 Anaphoric form of `-splice'.
421
422 (fn PRED FORM LIST)
423 (defalias '--splice '(macro . #[771 "\300\301\302E\301\303EF\207" [-splice lambda (it) (it)] 8 (#$ . 20815)]))
424 #@121 Splice NEW-LIST in place of elements matching PRED in LIST.
425
426 See also: `-splice', `-insert-at'
427
428 (fn PRED NEW-LIST LIST)
429 (defalias '-splice-list #[771 "\300\301\302\303\304\305!\306\"\307\310%#\207" [-splice make-byte-code 257 "\300\207" vconcat vector [] 2 "\n\n(fn _)"] 11 (#$ . 20986)])
430 #@60 Anaphoric form of `-splice-list'.
431
432 (fn PRED NEW-LIST LIST)
433 (defalias '--splice-list '(macro . #[771 "\300\301\302EF\207" [-splice-list lambda (it)] 7 (#$ . 21285)]))
434 #@204 Make a new list from the elements of ARGS.
435
436 The last 2 members of ARGS are used as the final cons of the
437 result so if the final member of ARGS is not a list the result is
438 a dotted list.
439
440 (fn &rest ARGS)
441 (defalias '-cons* #[128 "\300\301\"\207" [-reduce-r cons] 4 (#$ . 21461)])
442 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -cons* pure t side-effect-free] 5)
443 #@182 Append ELEM to the end of the list.
444
445 This is like `cons', but operates on the end of list.
446
447 If ELEMENTS is non nil, append these to the list as well.
448
449 (fn LIST ELEM &rest ELEMENTS)
450 (defalias '-snoc #[642 "\300C#\207" [-concat] 7 (#$ . 21852)])
451 #@45 Anaphoric form of `-first'.
452
453 (fn FORM LIST)
454 (defalias '--first '(macro . #[514 "\300\301!\302C\303\304D\305\306\307BBEFF\207" [make-symbol "needle" let --each-while not when setq (it)] 13 (#$ . 22105)]))
455 (put '--first 'edebug-form-spec '(form form))
456 #@163 Return the first x in LIST where (PRED x) is non-nil, else nil.
457
458 To get the first item in the list no questions asked, use `car'.
459
460 Alias: `-find'
461
462 (fn PRED LIST)
463 (defalias '-first #[514 "\300\301\302\203.\203.@\203\300\262\202\"!\203\"\211\262\210\211T\262A\262\202\266\211\207" [nil t 0] 9 (#$ . 22370)])
464 (byte-code "\300\301\302\"\210\300\303\304\"\207" [defalias -find -first --find --first] 3)
465 #@44 Anaphoric form of `-some'.
466
467 (fn FORM LIST)
468 (defalias '--some '(macro . #[514 "\300\301!\302C\303\304D\305    EFF\207" [make-symbol "needle" let --each-while not setq] 11 (#$ . 22796)]))
469 (put '--some 'edebug-form-spec '(form form))
470 #@109 Return (PRED x) for the first LIST item where (PRED x) is non-nil, else nil.
471
472 Alias: `-any'
473
474 (fn PRED LIST)
475 (defalias '-some #[514 "\300\301\302\203*\203*@\203\300\262\202!\262\210\211T\262A\262\202\266\211\207" [nil t 0] 9 (#$ . 23038)])
476 (byte-code "\300\301\302\"\210\300\303\304\"\207" [defalias -any -some --any --some] 3)
477 #@44 Anaphoric form of `-last'.
478
479 (fn FORM LIST)
480 (defalias '--last '(macro . #[514 "\300\301!\302C\303\304\305\306BBEEF\207" [make-symbol "needle" let --each when setq (it)] 12 (#$ . 23393)]))
481 (put '--last 'edebug-form-spec '(form form))
482 #@80 Return the last x in LIST where (PRED x) is non-nil, else nil.
483
484 (fn PRED LIST)
485 (defalias '-last #[514 "\300\301\203@!\203\211\262\210\211T\262A\262\202\266\211\207" [nil 0] 8 (#$ . 23638)])
486 (byte-code "\300\301\302\303#\210\304\301\305\306#\210\304\301\307\310#\210\300\311\312\313#\210\300\314\315\316#\207" [defalias -first-item car "Return the first item of LIST, or nil on an empty list.\n\nSee also: `-second-item', `-last-item'.\n\n(fn LIST)" put byte-opcode byte-car byte-compile byte-compile-one-arg -second-item cadr "Return the second item of LIST, or nil if LIST is too short.\n\nSee also: `-third-item'.\n\n(fn LIST)" -third-item caddr "Return the third item of LIST, or nil if LIST is too short.\n\nSee also: `-fourth-item'.\n\n(fn LIST)"] 4)
487 #@99 Return the fourth item of LIST, or nil if LIST is too short.
488
489 See also: `-fifth-item'.
490
491 (fn LIST)
492 (defalias '-fourth-item #[257 "\211AAA@\207" [] 2 (#$ . 24416)])
493 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -fourth-item pure t side-effect-free] 5)
494 #@97 Return the fifth item of LIST, or nil if LIST is too short.
495
496 See also: `-last-item'.
497
498 (fn LIST)
499 (defalias '-fifth-item #[257 "\211AAAA@\207" [] 2 (#$ . 24696)])
500 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -fifth-item pure t side-effect-free] 5)
501 #@67 Return the last item of LIST, or nil on an empty list.
502
503 (fn LIST)
504 (defalias '-last-item #[257 "\300!@\207" [last] 3 (#$ . 24973)])
505 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -last-item pure t side-effect-free] 5)
506 #@68 Return a list of all items in list except for the last.
507
508 (fn LIST)
509 (defalias '-butlast #[257 "\300!\207" [butlast] 3 (#$ . 25220)])
510 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -butlast pure t side-effect-free] 5)
511 #@45 Anaphoric form of `-count'.
512
513 (fn PRED LIST)
514 (defalias '--count '(macro . #[514 "\300\301!\302\303BC\304\305\306\307    DEEEF\207" [make-symbol "result" let (0) --each when setq 1+] 13 (#$ . 25466)]))
515 (put '--count 'edebug-form-spec '(form form))
516 #@82 Counts the number of items in LIST where (PRED item) is non-nil.
517
518 (fn PRED LIST)
519 (defalias '-count #[514 "\300\300\203@!\203T\262\210\211T\262A\262\202\266\211\207" [0] 8 (#$ . 25723)])
520 #@12 
521
522 (fn VAL)
523 (defalias '---truthy\? #[257 "\211??\207" [] 2 (#$ . 25932)])
524 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put ---truthy\? pure t side-effect-free] 5)
525 #@44 Anaphoric form of `-any?'.
526
527 (fn FORM LIST)
528 (defalias '--any\? '(macro . #[514 "\300\301ED\207" [---truthy\? --some] 6 (#$ . 26121)]))
529 (put '--any\? 'edebug-form-spec '(form form))
530 #@116 Return t if (PRED x) is non-nil for any x in LIST, else nil.
531
532 Alias: `-any-p', `-some?', `-some-p'
533
534 (fn PRED LIST)
535 (defalias '-any\? #[514 "\300\301\302\303\203+\203+@\203\301\262\202!\262\210\211T\262A\262\202\266\211\262!\207" [---truthy\? nil t 0] 10 (#$ . 26310)])
536 (byte-code "\300\301\302\"\210\300\303\304\"\210\300\305\302\"\210\300\306\304\"\210\300\307\302\"\210\300\310\304\"\207" [defalias -some\? -any\? --some\? --any\? -any-p --any-p -some-p --some-p] 3)
537 #@44 Anaphoric form of `-all?'.
538
539 (fn FORM LIST)
540 (defalias '--all\? '(macro . #[514 "\300\301!\302\303BC\304\305    EF\306DF\207" [make-symbol "all" let (t) --each-while setq ---truthy\?] 11 (#$ . 26808)]))
541 (put '--all\? 'edebug-form-spec '(form form))
542 #@118 Return t if (PRED x) is non-nil for all x in LIST, else nil.
543
544 Alias: `-all-p', `-every?', `-every-p'
545
546 (fn PRED LIST)
547 (defalias '-all\? #[514 "\300\300\301\203*\203*@\204\302\262\202!\262\210\211T\262A\262\202\266\303!\207" [t 0 nil ---truthy\?] 9 (#$ . 27066)])
548 (byte-code "\300\301\302\"\210\300\303\304\"\210\300\305\302\"\210\300\306\304\"\210\300\307\302\"\210\300\310\304\"\207" [defalias -every\? -all\? --every\? --all\? -all-p --all-p -every-p --every-p] 3)
549 #@45 Anaphoric form of `-none?'.
550
551 (fn FORM LIST)
552 (defalias '--none\? '(macro . #[514 "\300\301DE\207" [--all\? not] 5 (#$ . 27561)]))
553 (put '--none\? 'edebug-form-spec '(form form))
554 #@92 Return t if (PRED x) is nil for all x in LIST, else nil.
555
556 Alias: `-none-p'
557
558 (fn PRED LIST)
559 (defalias '-none\? #[514 "\300\300\301\203+\203+@\204\302\262\202!?\262\210\211T\262A\262\202\266\303!\207" [t 0 nil ---truthy\?] 9 (#$ . 27745)])
560 (byte-code "\300\301\302\"\210\300\303\304\"\207" [defalias -none-p -none\? --none-p --none\?] 3)
561 #@50 Anaphoric form of `-only-some?'.
562
563 (fn FORM LIST)
564 (defalias '--only-some\? '(macro . #[514 "\300\301!\300\302!\303D\304\305\306ED\307    \310    \311BB\310    \312BBFF\313\306EDF\207" [make-symbol "yes" "no" let --each-while not and if setq (t) (t) ---truthy\?] 15 (#$ . 28110)]))
565 (put '--only-some\? 'edebug-form-spec '(form form))
566 #@240 Return `t` if at least one item of LIST matches PRED and at least one item of LIST does not match PRED.
567 Return `nil` both if all items match the predicate or if none of the items match the predicate.
568
569 Alias: `-only-some-p'
570
571 (fn PRED LIST)
572 (defalias '-only-some\? #[514 "\300\211\301\302\2039\2039@\203\203\300\262\202-!\203*\301\262\202-\301\262\210\211T\262A\262\202\266\303\205A!\207" [nil t 0 ---truthy\?] 10 (#$ . 28454)])
573 (byte-code "\300\301\302\"\210\300\303\304\"\207" [defalias -only-some-p -only-some\? --only-some-p --only-some\?] 3)
574 #@287 Return copy of LIST, starting from index FROM to index TO.
575
576 FROM or TO may be negative.  These values are then interpreted
577 modulo the length of the list.
578
579 If STEP is a number, only each STEPth item in the resulting
580 section is returned.  Defaults to 1.
581
582 (fn LIST FROM &optional TO STEP)
583 (defalias '-slice #[1026 "G\300\206\262\206\301\262\302W\203\303\"\262\302W\203)\303\"\262\304\302\203h\203h@W\204C\300\262\202\\    Y\203\\\303    Z\"\302U\203\\\211B\262\210\211T\262A\262\202,\266\211\237\207" [nil 1 0 mod t] 13 (#$ . 29036)])
584 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -slice pure t side-effect-free] 5)
585 #@126 Return a new list of the first N items in LIST, or all items if there are fewer than N.
586
587 See also: `-take-last'
588
589 (fn N LIST)
590 (defalias '-take #[514 "\300\301\211W\203\203@B\262A\262\211T\262\202\266\211\237\207" [nil 0] 7 (#$ . 29722)])
591 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -take pure t side-effect-free] 5)
592 #@75 Return the last N items of LIST in order.
593
594 See also: `-take'
595
596 (fn N LIST)
597 (defalias '-take-last #[514 "\300\301\"!\207" [copy-sequence last] 6 (#$ . 30085)])
598 (byte-code "\300\301\302\303#\300\301\304\303#\305\306\307\310#\207" [function-put -take-last pure t side-effect-free defalias -drop nthcdr "Return the tail of LIST without the first N items.\n\nSee also: `-drop-last'\n\n(fn N LIST)"] 6)
599 #@84 Remove the last N items of LIST and return a copy.
600
601 See also: `-drop'
602
603 (fn N LIST)
604 (defalias '-drop-last #[514 "\300\"\207" [butlast] 5 (#$ . 30489)])
605 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -drop-last pure t side-effect-free] 5)
606 #@50 Anaphoric form of `-take-while'.
607
608 (fn FORM LIST)
609 (defalias '--take-while '(macro . #[514 "\300\301!\302C\303\304\305EF\306DF\207" [make-symbol "result" let --each-while !cons it nreverse] 11 (#$ . 30757)]))
610 (put '--take-while 'edebug-form-spec '(form form))
611 #@108 Return a new list of successive items from LIST while (PRED item) returns a non-nil value.
612
613 (fn PRED LIST)
614 (defalias '-take-while #[514 "\300\301\302\203,\203,@!\204\300\262\202 \211B\262\210\211T\262A\262\202\266\211\237\207" [nil t 0] 9 (#$ . 31029)])
615 #@50 Anaphoric form of `-drop-while'.
616
617 (fn FORM LIST)
618 (defalias '--drop-while '(macro . #[514 "\300\301!\302DC\303\304\302\305\306DDC    EE\307DEF\207" [make-symbol "list" let while and it car !cdr] 12 (#$ . 31310)]))
619 (put '--drop-while 'edebug-form-spec '(form form))
620 #@105 Return the tail of LIST starting from the first item for which (PRED item) returns nil.
621
622 (fn PRED LIST)
623 (defalias '-drop-while #[514 "\211\211\203\211@!\262\203\211A\262\202\211\207" [] 6 (#$ . 31586)])
624 #@107 Return a list of ((-take N LIST) (-drop N LIST)), in no more than one pass through the list.
625
626 (fn N LIST)
627 (defalias '-split-at #[514 "\300\301\211W\203\203@B\262A\262\211T\262\202\266\211\237D\207" [nil 0] 7 (#$ . 31806)])
628 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -split-at pure t side-effect-free] 5)
629 #@116 Rotate LIST N places to the right.  With N negative, rotate to the left.
630 The time complexity is O(n).
631
632 (fn N LIST)
633 (defalias '-rotate #[514 "\300V\203\301\302\"\303\"\"\207\301\304[\"\305[\"\"\207" [0 append last butlast -drop -take] 7 (#$ . 32161)])
634 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -rotate pure t side-effect-free] 5)
635 #@108 Return a list with X inserted into LIST at position N.
636
637 See also: `-splice', `-splice-list'
638
639 (fn N X LIST)
640 (defalias '-insert-at #[771 "\300\"\211@A@B\244\207" [-split-at] 7 (#$ . 32536)])
641 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -insert-at pure t side-effect-free] 5)
642 #@106 Return a list with element at Nth position in LIST replaced with X.
643
644 See also: `-replace'
645
646 (fn N X LIST)
647 (defalias '-replace-at #[771 "\300\"\211@A@AB\244\207" [-split-at] 7 (#$ . 32845)])
648 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -replace-at pure t side-effect-free] 5)
649 #@130 Return a list with element at Nth position in LIST replaced with `(func (nth n list))`.
650
651 See also: `-map-when'
652
653 (fn N FUNC LIST)
654 (defalias '-update-at #[771 "\300\"\211@A@@!A@AB\244\207" [-split-at] 7 (#$ . 33155)])
655 #@54 Anaphoric version of `-update-at'.
656
657 (fn N FORM LIST)
658 (defalias '--update-at '(macro . #[771 "\300\301\302EF\207" [-update-at lambda (it)] 8 (#$ . 33382)]))
659 (put '--update-at 'edebug-form-spec '(form form form))
660 #@117 Return a list with element at Nth position in LIST removed.
661
662 See also: `-remove-at-indices', `-remove'
663
664 (fn N LIST)
665 (defalias '-remove-at #[514 "\300C\"\207" [-remove-at-indices] 5 (#$ . 33603)])
666 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -remove-at pure t side-effect-free] 5)
667 #@175 Return a list whose elements are elements from LIST without
668 elements selected as `(nth i list)` for all i
669 from INDICES.
670
671 See also: `-remove-at', `-remove'
672
673 (fn INDICES LIST)
674 (defalias '-remove-at-indices #[514 "\300\301\"\211@\302\303\304\305A#\"B\306\307\2038@\310\"\211@B\262\211A@A\262\266\211T\262A\262\202\266B\262\311\312\237\"\207" [-sort < -map 1- -zip-with - nil 0 -split-at apply -concat] 11 (#$ . 33917)])
675 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -remove-at-indices pure t side-effect-free] 5)
676 #@50 Anaphoric form of `-split-with'.
677
678 (fn PRED LIST)
679 (defalias '--split-with '(macro . #[514 "\300\301!\300\302!\300\303!\304D\305B\306BE\307\310E\304\311\312    DDC\313\314\fD\315    \316BB\317\311\fE\320 D\257EE\321\322DEF\207" [make-symbol "list" "result" "continue" let (nil) (t) while and it car if not setq (nil) !cons !cdr list nreverse] 17 (#$ . 34482)]))
680 (put '--split-with 'edebug-form-spec '(form form))
681 #@128 Return a list of ((-take-while PRED LIST) (-drop-while PRED LIST)), in no more than one pass through the list.
682
683 (fn PRED LIST)
684 (defalias '-split-with #[514 "\211\300\301\203&\211\203&@!\204\300\262\202\"\211B\262A\262\210\202\237D\207" [nil t] 8 (#$ . 34911)])
685 #@224 Split the LIST each time ITEM is found.
686
687 Unlike `-partition-by', the ITEM is discarded from the results.
688 Empty lists are also removed from the result.
689
690 Comparison is done by `equal'.
691
692 See also `-split-when'
693
694 (fn ITEM LIST)
695 (defalias '-split-on '(macro . #[514 "\300\301\302\303\304EEE\207" [-split-when lambda (it) equal it] 8 (#$ . 35197)]))
696 (put '-split-on 'edebug-form-spec '(form form))
697 #@53 Anaphoric version of `-split-when'.
698
699 (fn FORM LIST)
700 (defalias '--split-when '(macro . #[514 "\300\301\302EE\207" [-split-when lambda (it)] 6 (#$ . 35597)]))
701 (put '--split-when 'edebug-form-spec '(form form))
702 #@269 Split the LIST on each element where FN returns non-nil.
703
704 Unlike `-partition-by', the "matched" element is discarded from
705 the results.  Empty lists are also removed from the result.
706
707 This function can be thought of as a generalization of
708 `split-string'.
709
710 (fn FN LIST)
711 (defalias '-split-when #[514 "\300\211\203*@!\204@B\262\202#\211\203 \211\237B\262\300\262A\262\202\211\2034\211\237B\262\237\207" [nil] 6 (#$ . 35814)])
712 #@48 Anaphoric form of `-separate'.
713
714 (fn FORM LIST)
715 (defalias '--separate '(macro . #[514 "\300\301!\300\302!\303D\304\305\306\307    E\306\307    EFE\310\311D\311DEF\207" [make-symbol "yes" "no" let --each if !cons it list nreverse] 14 (#$ . 36264)]))
716 (put '--separate 'edebug-form-spec '(form form))
717 #@107 Return a list of ((-filter PRED LIST) (-remove PRED LIST)), in one pass through the list.
718
719 (fn PRED LIST)
720 (defalias '-separate #[514 "\300\211\301\203*@!\203\211B\262\202\211B\262\210\211T\262A\262\202\266\237\237D\207" [nil 0] 9 (#$ . 36573)])
721 #@85 Private: Used by -partition-all-in-steps and -partition-in-steps.
722
723 (fn N STEP LIST)
724 (defalias '---partition-all-in-steps-reversed #[771 "\300W\203\n\301\302!\210\303\203 \304\"B\262\305\"\262\202 \211\207" [1 error "Step must be a positive number, or you're looking at some juicy infinite loops." nil -take -drop] 7 (#$ . 36847)])
725 #@160 Return a new list with the items in LIST grouped into N-sized sublists at offsets STEP apart.
726 The last groups may contain less than N items.
727
728 (fn N STEP LIST)
729 (defalias '-partition-all-in-steps #[771 "\300#\237\207" [---partition-all-in-steps-reversed] 7 (#$ . 37197)])
730 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -partition-all-in-steps pure t side-effect-free] 5)
731 #@202 Return a new list with the items in LIST grouped into N-sized sublists at offsets STEP apart.
732 If there are not enough items to make the last group N-sized,
733 those items are discarded.
734
735 (fn N STEP LIST)
736 (defalias '-partition-in-steps #[771 "\300#\211\203\211@GW\203\211A\262\202\211\237\207" [---partition-all-in-steps-reversed] 7 (#$ . 37599)])
737 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -partition-in-steps pure t side-effect-free] 5)
738 #@132 Return a new list with the items in LIST grouped into N-sized sublists.
739 The last group may contain less than N items.
740
741 (fn N LIST)
742 (defalias '-partition-all #[514 "\300\211#\207" [-partition-all-in-steps] 6 (#$ . 38079)])
743 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -partition-all pure t side-effect-free] 5)
744 #@175 Return a new list with the items in LIST grouped into N-sized sublists.
745 If there are not enough items to make the last group N-sized,
746 those items are discarded.
747
748 (fn N LIST)
749 (defalias '-partition #[514 "\300\211#\207" [-partition-in-steps] 6 (#$ . 38423)])
750 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -partition pure t side-effect-free] 5)
751 #@52 Anaphoric form of `-partition-by'.
752
753 (fn FORM LIST)
754 (defalias '--partition-by '(macro . #[514 "\300\301!\300\302!\300\303!\300\304!\300\305!\306DC\307\310    \311B\312\313DD\n\314B\nD    \315 DD\257\316\310\312\313 DD DD\317\320E\321\322DE\323\324BB\323E\257\321\312E\325 D\257E\321\322\fD E\322 D\257EE\207" [make-symbol "result" "sublist" "value" "new-value" "list" let when let* (nil) it car ((list it)) cdr while unless equal !cons nreverse setq (nil) !cdr] 24 (#$ . 38797)]))
755 (put '--partition-by 'edebug-form-spec '(form form))
756 #@93 Apply FN to each item in LIST, splitting it each time FN returns a new value.
757
758 (fn FN LIST)
759 (defalias '-partition-by #[514 "\211\211\205B\300@\211C!A\211\2038\211@!\232\204,\237B\262\300\262\211\262B\262A\266\203\202\237B\262\237\266\205\207" [nil] 12 (#$ . 39373)])
760 #@59 Anaphoric form of `-partition-by-header'.
761
762 (fn FORM LIST)
763 (defalias '--partition-by-header '(macro . #[514 "\300\301!\300\302!\300\303!\300\304!\300\305!\300\306!\307DC\310\311\n\312B\313\314DD \315B D \316B\n\317\fDD\257\320\311\313\314 DD DD\321\322E\310\323\324DE\325\326BB\325\327BB\257\325\330BBF\323\313E\331 D\257E\323\324 DE\324D\257EE\207" [make-symbol "result" "sublist" "header-value" "seen-body?" "new-value" "list" let when let* (nil) it car ((list it)) (nil) cdr while if equal !cons nreverse setq (nil) (nil) (t) !cdr] 27 (#$ . 39674)]))
764 (put '--partition-by-header 'edebug-form-spec '(form form))
765 #@219 Apply FN to the first item in LIST. That is the header
766 value. Apply FN to each item in LIST, splitting it each time FN
767 returns the header value, but only after seeing at least one
768 other value (the body).
769
770 (fn FN LIST)
771 (defalias '-partition-by-header #[514 "\211\211\205O\300@\211C!\300A\211\203D\211@    !\232\2034\2037\237B\262\300\262\300\262\2027\301\262B\262A\266\203\202\237B\262\237\266\206\207" [nil t] 13 (#$ . 40342)])
772 #@88 Partition directly after each time PRED is true on an element of LIST.
773
774 (fn PRED LIST)
775 (defalias '-partition-after-pred #[514 "\211\205\"\300A\"@!\203@CB\202 @@BAB\262\207" [-partition-after-pred] 5 (#$ . 40806)])
776 #@89 Partition directly before each time PRED is true on an element of LIST.
777
778 (fn PRED LIST)
779 (defalias '-partition-before-pred #[514 "\300\301\302\301!\"\"\237\207" [-map reverse -partition-after-pred] 8 (#$ . 41040)])
780 #@74 Partition directly after each time ITEM appears in LIST.
781
782 (fn ITEM LIST)
783 (defalias '-partition-after-item #[514 "\300\301\302\303\304\305!\306\"\307\310%\"\207" [-partition-after-pred make-byte-code 257 "\211\300\232\207" vconcat vector [] 3 "\n\n(fn ELE)"] 9 (#$ . 41262)])
784 #@75 Partition directly before each time ITEM appears in LIST.
785
786 (fn ITEM LIST)
787 (defalias '-partition-before-item #[514 "\300\301\302\303\304\305!\306\"\307\310%\"\207" [-partition-before-pred make-byte-code 257 "\211\300\232\207" vconcat vector [] 3 "\n\n(fn ELE)"] 9 (#$ . 41546)])
788 #@48 Anaphoric form of `-group-by'.
789
790 (fn FORM LIST)
791 (defalias '--group-by '(macro . #[514 "\300\301!\300\302!\300\303!\304\305\306C\307\310D\304\311\nDDEE\312\313\nD\314    \315BBDD\316\317    \307\320\311 DEE\321\322\f\323BB\324BBF\325BBB\326    FED\207" [make-symbol "n" "k" "grp" nreverse -map lambda cons car cdr --reduce-from let* assoc (acc) if setcdr it push list (it) (acc) (acc) nil] 19 (#$ . 41833)]))
792 (put '--group-by 'edebug-form-spec t)
793 #@125 Separate LIST into an alist whose keys are FN applied to the
794 elements of LIST.  Keys are compared by `equal'.
795
796 (fn FN LIST)
797 (defalias '-group-by #[514 "\300\301\302\303\203;@!\304\"\211\203\"\211AB\241\210\202*DB\262\266\202\262\210\211T\262A\262\202\266\211\262\"\237\207" [-map #[257 "\211@A\237B\207" [] 3 "\n\n(fn N)"] nil 0 assoc] 13 (#$ . 42292)])
798 #@76 Return a new list of all elements in LIST separated by SEP.
799
800 (fn SEP LIST)
801 (defalias '-interpose #[514 "\300\203@B\262A\262\203\"@BB\262A\262\202\211\237\207" [nil] 6 (#$ . 42681)])
802 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -interpose pure t side-effect-free] 5)
803 #@90 Return a new list of the first item in each list, then the second etc.
804
805 (fn &rest LISTS)
806 (defalias '-interleave #[128 "\211\2055\300\301\302\"\2031\303\203&@\211@B\262\210\211T\262A\262\202\266\304\305\"\262\202\211\237\262\207" [nil -none\? null 0 -map cdr] 7 (#$ . 42996)])
807 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -interleave pure t side-effect-free] 5)
808 #@145 Anaphoric form of `-zip-with'.
809
810 The elements in list1 are bound as symbol `it', the elements in list2 as symbol `other'.
811
812 (fn FORM LIST1 LIST2)
813 (defalias '--zip-with '(macro . #[771 "\300\301!\300\302!\300\303!\304\305BDDE\306\307E\304\310\311DD\312\311DDD\313\f\nE\314    D\314    D\257E\315DF\207" [make-symbol "result" "list1" "list2" let (nil) while and it car other !cons !cdr nreverse] 16 (#$ . 43409)]))
814 (put '--zip-with 'edebug-form-spec '(form form form))
815 #@347 Zip the two lists LIST1 and LIST2 using a function FN.  This
816 function is applied pairwise taking as first argument element of
817 LIST1 and as second argument element of LIST2 at corresponding
818 position.
819
820 The anaphoric form `--zip-with' binds the elements from LIST1 as symbol `it',
821 and the elements from LIST2 as symbol `other'.
822
823 (fn FN LIST1 LIST2)
824 (defalias '-zip-with #[771 "\300\203#\211\203#@@\"B\262A\262A\266\203\202\237\207" [nil] 11 (#$ . 43895)])
825 #@492 Zip LISTS together.  Group the head of each list, followed by the
826 second elements of each list, and so on. The lengths of the returned
827 groupings are equal to the length of the shortest input list.
828
829 If two lists are provided as arguments, return the groupings as a list
830 of cons cells. Otherwise, return the groupings as a list of lists.
831
832 Please note! This distinction is being removed in an upcoming 3.0
833 release of Dash. If you rely on this behavior, use -zip-pair instead.
834
835 (fn &rest LISTS)
836 (defalias '-zip #[128 "\211\2052\300\301\302\"\203\303\304\"B\262\303\305\"\262\202\211\237\262G\306U\203/\303\307\"\2020\211\262\207" [nil -none\? null mapcar car cdr 2 #[257 "\211@A@B\207" [] 3 "\n\n(fn IT)"]] 5 (#$ . 44374)])
837 (byte-code "\300\301\302\303#\300\301\304\303#\305\306\301\"\207" [function-put -zip pure t side-effect-free defalias -zip-pair] 5)
838 #@177 Zip LISTS, with FILL-VALUE padded onto the shorter lists. The
839 lengths of the returned groupings are equal to the length of the
840 longest input list.
841
842 (fn FILL-VALUE &rest LISTS)
843 (defalias '-zip-fill #[385 "\300\301\300\302B\"\"\207" [apply -zip -pad] 8 (#$ . 45251)])
844 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -zip-fill pure t side-effect-free] 5)
845 #@241 Unzip LISTS.
846
847 This works just like `-zip' but takes a list of lists instead of
848 a variable number of arguments, such that
849
850   (-unzip (-zip L1 L2 L3 ...))
851
852 is identity (given that the lists are the same length).
853
854 See also: `-zip'
855
856 (fn LISTS)
857 (defalias '-unzip #[257 "\300\301\"\207" [apply -zip] 4 (#$ . 45634)])
858 #@112 Return an infinite copy of LIST that will cycle through the
859 elements and repeat from the beginning.
860
861 (fn LIST)
862 (defalias '-cycle #[257 "\300\301\"\211\244\207" [-map identity] 4 (#$ . 45953)])
863 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -cycle pure t side-effect-free] 5)
864 #@128 Appends FILL-VALUE to the end of each list in LISTS such that they
865 will all have the same length.
866
867 (fn FILL-VALUE &rest LISTS)
868 (defalias '-pad #[385 "\300\301\"\302\303\304\"!\305\306\307\310\311\312    \"\313\"\314\315%\"\207" [-annotate length -max -map car mapcar make-byte-code 257 "\302A\303\301@Z\300\"\"\207" vconcat vector [append -repeat] 6 "\n\n(fn IT)"] 12 (#$ . 46260)])
869 #@141 Return a list of cons cells where each cell is FN applied to each
870 element of LIST paired with the unmodified element of LIST.
871
872 (fn FN LIST)
873 (defalias '-annotate #[514 "\300\301\"\"\207" [-zip -map] 6 (#$ . 46655)])
874 #@51 Anaphoric version of `-annotate'.
875
876 (fn FORM LIST)
877 (defalias '--annotate '(macro . #[514 "\300\301\302EE\207" [-annotate lambda (it)] 6 (#$ . 46879)]))
878 (put '--annotate 'edebug-form-spec '(form form))
879 #@140 Helper for `-table' and `-table-flat'.
880
881 If a list overflows, carry to the right and reset the list.
882
883 (fn LISTS RESTORE-LISTS &optional RE)
884 (defalias 'dash--table-carry #[770 "@\206\300\232?\205C@\240\210\211A@\211AA\240\210\266A\262A\262\211\203\211@\237\211AA@B\240\266\211\301\240\210\211A\262\202\207" [(nil) nil] 8 (#$ . 47088)])
885 #@352 Compute outer product of LISTS using function FN.
886
887 The function FN should have the same arity as the number of
888 supplied lists.
889
890 The outer product is computed by applying fn to all possible
891 combinations created by taking one element from each list in
892 order.  The dimension of the result is (length lists).
893
894 See also: `-table-flat'
895
896 (fn FN &rest LISTS)
897 (defalias '-table #[385 "\300!\301!\302G\303\"@\2031\304\305\306\"\"\211@B\240\266\211@A\240\210\307#\266\202 \301!@\237\207" [copy-sequence last make-list nil apply -map car dash--table-carry] 10 (#$ . 47453)])
898 #@539 Compute flat outer product of LISTS using function FN.
899
900 The function FN should have the same arity as the number of
901 supplied lists.
902
903 The outer product is computed by applying fn to all possible
904 combinations created by taking one element from each list in
905 order.  The results are flattened, ignoring the tensor structure
906 of the result.  This is equivalent to calling:
907
908   (-flatten-n (1- (length lists)) (apply \='-table fn lists))
909
910 but the implementation here is much more efficient.
911
912 See also: `-flatten-n', `-table'
913
914 (fn FN &rest LISTS)
915 (defalias '-table-flat #[385 "\300!\301!\302@\203(\303\304\305\"\"\211B\262\211@A\240\210\306\"\266\202\211\237\207" [copy-sequence last nil apply -map car dash--table-carry] 10 (#$ . 48042)])
916 #@234 Take a function FN and fewer than the normal arguments to FN,
917 and return a fn that takes a variable number of additional ARGS.
918 When called, the returned function calls FN with ARGS first and
919 then additional args.
920
921 (fn FN &rest ARGS)
922 (defalias '-partial #[385 "\300\301#\207" [apply apply-partially] 6 (#$ . 48795)])
923 #@151 Return the index of the first element in the given LIST which
924 is equal to the query element ELEM, or nil if there is no
925 such element.
926
927 (fn ELEM LIST)
928 (defalias '-elem-index #[514 "\300\"@\207" [-elem-indices] 5 (#$ . 49120)])
929 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -elem-index pure t side-effect-free] 5)
930 #@113 Return the indices of all elements in LIST equal to the query
931 element ELEM, in ascending order.
932
933 (fn ELEM LIST)
934 (defalias '-elem-indices #[514 "\300\301\302\"\"\207" [-find-indices -partial equal] 6 (#$ . 49465)])
935 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -elem-indices pure t side-effect-free] 5)
936 #@111 Return the indices of all elements in LIST satisfying the
937 predicate PRED, in ascending order.
938
939 (fn PRED LIST)
940 (defalias '-find-indices #[514 "\300\301\302\303\203$@!\205CB\262\210\211T\262A\262\202\266\211\237\262\"\207" [apply append nil 0] 10 (#$ . 49800)])
941 #@55 Anaphoric version of `-find-indices'.
942
943 (fn FORM LIST)
944 (defalias '--find-indices '(macro . #[514 "\300\301\302EE\207" [-find-indices lambda (it)] 6 (#$ . 50085)]))
945 (put '--find-indices 'edebug-form-spec '(form form))
946 #@186 Take a predicate PRED and a LIST and return the index of the
947 first element in the list satisfying the predicate, or nil if
948 there is no such element.
949
950 See also `-first'.
951
952 (fn PRED LIST)
953 (defalias '-find-index #[514 "\300\"@\207" [-find-indices] 5 (#$ . 50310)])
954 #@53 Anaphoric version of `-find-index'.
955
956 (fn FORM LIST)
957 (defalias '--find-index '(macro . #[514 "\300\301\302EE\207" [-find-index lambda (it)] 6 (#$ . 50579)]))
958 (put '--find-index 'edebug-form-spec '(form form))
959 #@184 Take a predicate PRED and a LIST and return the index of the
960 last element in the list satisfying the predicate, or nil if
961 there is no such element.
962
963 See also `-last'.
964
965 (fn PRED LIST)
966 (defalias '-find-last-index #[514 "\300\301\"!\207" [-last-item -find-indices] 6 (#$ . 50796)])
967 #@58 Anaphoric version of `-find-last-index'.
968
969 (fn FORM LIST)
970 (defalias '--find-last-index '(macro . #[514 "\300\301\302EE\207" [-find-last-index lambda (it)] 6 (#$ . 51083)]))
971 #@123 Return a list whose elements are elements from LIST selected
972 as `(nth i list)` for all i from INDICES.
973
974 (fn INDICES LIST)
975 (defalias '-select-by-indices #[514 "\300\301\203@\2118B\262\210\211T\262A\262\202\266\211\237\207" [nil 0] 8 (#$ . 51264)])
976 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -select-by-indices pure t side-effect-free] 5)
977 #@283 Select COLUMNS from TABLE.
978
979 TABLE is a list of lists where each element represents one row.
980 It is assumed each row has the same length.
981
982 Each row is transformed such that only the specified COLUMNS are
983 selected.
984
985 See also: `-select-column', `-select-by-indices'
986
987 (fn COLUMNS TABLE)
988 (defalias '-select-columns #[514 "\300\301\302\303\304\305!\306\"\307\310%\"\207" [mapcar make-byte-code 257 "\301\300\"\207" vconcat vector [-select-by-indices] 4 "\n\n(fn IT)"] 9 (#$ . 51649)])
989 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -select-columns pure t side-effect-free] 5)
990 #@257 Select COLUMN from TABLE.
991
992 TABLE is a list of lists where each element represents one row.
993 It is assumed each row has the same length.
994
995 The single selected column is returned as a list.
996
997 See also: `-select-columns', `-select-by-indices'
998
999 (fn COLUMN TABLE)
1000 (defalias '-select-column #[514 "\300\301\302\303\304\305\306\307    !\310\"\311\312%\"\"\207" [apply append mapcar make-byte-code 257 "\301\300C\"\207" vconcat vector [-select-by-indices] 4 "\n\n(fn IT)"] 11 (#$ . 52252)])
1001 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -select-column pure t side-effect-free] 5)
1002 #@253 Thread the expr through the forms. Insert X as the second item
1003 in the first form, making a list of it if it is not a list
1004 already. If there are more forms, insert the first form as the
1005 second item in second form, etc.
1006
1007 (fn X &optional FORM &rest MORE)
1008 (defalias '-> '(macro . #[641 "\204\207\211\204<\203@ABB\207D\207\300\211EBB\207" [->] 7 (#$ . 52852)]))
1009 (put '-> 'edebug-form-spec '(form &rest [&or symbolp (sexp &rest form)]))
1010 #@249 Thread the expr through the forms. Insert X as the last item
1011 in the first form, making a list of it if it is not a list
1012 already. If there are more forms, insert the first form as the
1013 last item in second form, etc.
1014
1015 (fn X &optional FORM &rest MORE)
1016 (defalias '->> '(macro . #[641 "\204\207\211\204<\203\300C\"\207D\207\301\211EBB\207" [append ->>] 7 (#$ . 53307)]))
1017 (put '->> 'edebug-form-spec '->)
1018 #@269 Starting with the value of X, thread each expression through FORMS.
1019
1020 Insert X at the position signified by the symbol `it' in the first
1021 form.  If there are more forms, insert the first form at the position
1022 signified by `it' in in second form, etc.
1023
1024 (fn X &rest FORMS)
1025 (defalias '--> '(macro . #[385 "\300\301BBB\207" [-as-> it] 6 (#$ . 53728)]))
1026 (put '--> 'edebug-form-spec '(form body))
1027 #@212 Starting with VALUE, thread VARIABLE through FORMS.
1028
1029 In the first form, bind VARIABLE to VALUE.  In the second form, bind
1030 VARIABLE to the result of the first form, and so forth.
1031
1032 (fn VALUE VARIABLE &rest FORMS)
1033 (defalias '-as-> '(macro . #[642 "\211\204\207\300DC\301@9\203@D\202@ABBBE\207" [let -as->] 9 (#$ . 54125)]))
1034 (put '-as-> 'edebug-form-spec '(form symbolp body))
1035 #@163 When expr is non-nil, thread it through the first form (via `->'),
1036 and when that result is non-nil, through the next form, etc.
1037
1038 (fn X &optional FORM &rest MORE)
1039 (defalias '-some-> '(macro . #[641 "\204\207\300\301!\302\303D\304EEBB\207" [make-symbol "result" -some-> -when-let ->] 10 (#$ . 54520)]))
1040 (put '-some-> 'edebug-form-spec '->)
1041 #@164 When expr is non-nil, thread it through the first form (via `->>'),
1042 and when that result is non-nil, through the next form, etc.
1043
1044 (fn X &optional FORM &rest MORE)
1045 (defalias '-some->> '(macro . #[641 "\204\207\300\301!\302\303D\304EEBB\207" [make-symbol "result" -some->> -when-let ->>] 10 (#$ . 54876)]))
1046 (put '-some->> 'edebug-form-spec '->)
1047 #@164 When expr in non-nil, thread it through the first form (via `-->'),
1048 and when that result is non-nil, through the next form, etc.
1049
1050 (fn X &optional FORM &rest MORE)
1051 (defalias '-some--> '(macro . #[641 "\204\207\300\301!\302\303D\304EEBB\207" [make-symbol "result" -some--> -when-let -->] 10 (#$ . 55237)]))
1052 (put '-some--> 'edebug-form-spec '->)
1053 #@176 Grade elements of LIST using COMPARATOR relation, yielding a
1054 permutation vector such that applying this permutation to LIST
1055 sorts it in ascending order.
1056
1057 (fn COMPARATOR LIST)
1058 (defalias '-grade-up #[514 "\300\301\302\303D\304BBE\305\306\307\310\311\203+@\211BB\262\210\211T\262A\262\202\266\211\237\262\"\"\207" [lambda (it other) funcall quote ((car it) (car other)) -map cdr -sort nil 0] 13 (#$ . 55598)])
1059 #@177 Grade elements of LIST using COMPARATOR relation, yielding a
1060 permutation vector such that applying this permutation to LIST
1061 sorts it in descending order.
1062
1063 (fn COMPARATOR LIST)
1064 (defalias '-grade-down #[514 "\300\301\302\303D\304BBE\305\306\307\310\311\203+@\211BB\262\210\211T\262A\262\202\266\211\237\262\"\"\207" [lambda (it other) funcall quote ((car other) (car it)) -map cdr -sort nil 0] 13 (#$ . 56029)])
1065 #@42 Monotonic counter for generated symbols.
1066 (defvar dash--source-counter 0 (#$ . 56462))
1067 #@87 Generate a new dash-source symbol.
1068
1069 All returned symbols are guaranteed to be unique.
1070 (defalias 'dash--match-make-source-symbol #[0 "\301\302\303\"!T\207" [dash--source-counter make-symbol format "--dash-source-%d--"] 4 (#$ . 56554)])
1071 #@70 Return non-nil if SYMBOL is a symbol and starts with _.
1072
1073 (fn SYMBOL)
1074 (defalias 'dash--match-ignore-place-p #[257 "\2119\205\f\300!\301H\302=\207" [symbol-name 0 95] 3 (#$ . 56798)])
1075 #@75 Helper function generating idiomatic shifting code.
1076
1077 (fn SKIP-CDR SOURCE)
1078 (defalias 'dash--match-cons-skip-cdr #[514 "\300U\203\n\301D\207\302\303\"\304\305T\"EE\207" [0 pop prog1 dash--match-cons-get-car setq dash--match-cons-get-cdr] 9 (#$ . 56988)])
1079 #@81 Helper function generating idiomatic code to get nth car.
1080
1081 (fn SKIP-CDR SOURCE)
1082 (defalias 'dash--match-cons-get-car #[514 "\300U\203\n\301D\207\302U\203\303D\207\304E\207" [0 car 1 cadr nth] 5 (#$ . 57257)])
1083 #@81 Helper function generating idiomatic code to get nth cdr.
1084
1085 (fn SKIP-CDR SOURCE)
1086 (defalias 'dash--match-cons-get-cdr #[514 "\300U\203\207\301U\203\302D\207\303E\207" [0 1 cdr nthcdr] 5 (#$ . 57480)])
1087 #@86 Setup a cons matching environment and call the real matcher.
1088
1089 (fn MATCH-FORM SOURCE)
1090 (defalias 'dash--match-cons #[514 "\300 \301\211:\203\302@!\203T\262\211A\262\202\211:\2031\211A\2041\303@\304\"\"\202K\301V\203B\303\305\"\"\202KD\306\"B\207" [dash--match-make-source-symbol 0 dash--match-ignore-place-p dash--match dash--match-cons-get-car dash--match-cons-get-cdr dash--match-cons-1] 10 (#$ . 57694)])
1091 #@386 Match MATCH-FORM against SOURCE.
1092
1093 MATCH-FORM is a proper or improper list.  Each element of
1094 MATCH-FORM is either a symbol, which gets bound to the respective
1095 value in source or another match form which gets destructured
1096 recursively.
1097
1098 If the cdr of last cons cell in the list is `nil', matching stops
1099 there.
1100
1101 SOURCE is a proper or improper list.
1102
1103 (fn MATCH-FORM SOURCE &optional PROPS)
1104 (defalias 'dash--match-cons-1 #[770 "\300\301\"\206\302:\203cA\203W@9\203,@\303>\203,\304\305!\306\"\"\202u\307@!\203B\310A\311\301T##\202u\312\313@\314\"\"\310A\"\"\202u\313@\315\"\"\202u\316=\203m\316\202u\313\306\"\"\207" [plist-get :skip-cdr 0 (&keys &plist &alist &hash) dash--match-kv dash--match-kv-normalize-match-form dash--match-cons-get-cdr dash--match-ignore-place-p dash--match-cons-1 plist-put -concat dash--match dash--match-cons-skip-cdr dash--match-cons-get-car nil] 11 (#$ . 58137)])
1105 #@59 Return the tail of SEQ starting at START.
1106
1107 (fn SEQ START)
1108 (defalias 'dash--vector-tail #[514 "\300!\203+GZ\301\302\"\302\211W\203(\\HI\210\211T\262\202\266\207;\2054\303O\207" [vectorp make-vector 0 nil] 11 (#$ . 59075)])
1109 #@88 Setup a vector matching environment and call the real matcher.
1110
1111 (fn MATCH-FORM SOURCE)
1112 (defalias 'dash--match-vector #[514 "\300 G\301U\203\302\303H\304\305BB\"\202Q9\203\"\306\"\202Q\307\310\"\311\312\"G\211GSU\205D\313\312\"\302H\304E\"\262\266\202\206Q\211D\306\"B\207" [dash--match-make-source-symbol 1 dash--match 0 aref (0) dash--match-vector-1 mapcar dash--match-ignore-place-p -remove null -find-index] 11 (#$ . 59326)])
1113 #@691 Match MATCH-FORM against SOURCE.
1114
1115 MATCH-FORM is a vector.  Each element of MATCH-FORM is either a
1116 symbol, which gets bound to the respective value in source or
1117 another match form which gets destructured recursively.
1118
1119 If second-from-last place in MATCH-FORM is the symbol &rest, the
1120 next element of the MATCH-FORM is matched against the tail of
1121 SOURCE, starting at index of the &rest symbol.  This is
1122 conceptually the same as the (head . tail) match for improper
1123 lists, where dot plays the role of &rest.
1124
1125 SOURCE is a vector.
1126
1127 If the MATCH-FORM vector is shorter than SOURCE vector, only
1128 the (length MATCH-FORM) places are bound, the rest of the SOURCE
1129 is discarded.
1130
1131 (fn MATCH-FORM SOURCE)
1132 (defalias 'dash--match-vector-1 #[514 "\300G\301W\203aH\2119\203+\211\302=\203+\303TH\304E\"\262\202U\2119\203F\305!\300H\306=\204F\211\307EDC\202U\2119?\205U\303\307E\"B\262T\262\210\202\310\311\237\"\207" [0 nil &rest dash--match dash--vector-tail symbol-name 95 aref -flatten-n 1] 11 (#$ . 59789)])
1133 #@148 Normalize kv PATTERN.
1134
1135 This method normalizes PATTERN to the format expected by
1136 `dash--match-kv'.  See `-let' for the specification.
1137
1138 (fn PATTERN)
1139 (defalias 'dash--match-kv-normalize-match-form #[257 "\211@CC\300C\301\302!\303\304\305\306A    AA#\"\307\310\311\312\313            #\314\"\315\316%\"\210\242\237\207" [nil make-symbol "--dash-fill-placeholder--" -each apply -zip -pad make-byte-code 257 "\211@A\301\242\203\301\303\240\202\260\302=\204>\2119\203,\304!\204,\211\305=\204,\211\303=\203\237\211:\2038\211@\306=\203\237\307!\204\237\304!\203\\\300\300\242B\240\210\300\310\311!\312\303O!\300\242B\240\210\202\231;\203t\300\300\242B\240\210\300\310!\300\242B\240\210\202\231:\203\223@\306=\203\223\300\300\242B\240\210\300A@\300\242B\240\210\202\231\313\314#\210\301\303\240\202\260\300\300\242B\240\210\300\300\242B\240\210\301\305\240\207" vconcat vector [nil keywordp t quote vectorp intern symbol-name 1 error "-let: found key `%s' in kv destructuring but its pattern `%s' is invalid and can not be derived from the key"] 8 "\n\n(fn PAIR)"] 14 (#$ . 60827)])
1140 #@152 Setup a kv matching environment and call the real matcher.
1141
1142 kv can be any key-value store, such as plist, alist or hash-table.
1143
1144 (fn MATCH-FORM SOURCE)
1145 (defalias 'dash--match-kv #[514 "\300 G\301U\203\302A@#\202.9\203\"\302A@#\202.\211D\302A@#B\207" [dash--match-make-source-symbol 3 dash--match-kv-1] 8 (#$ . 61940)])
1146 #@509 Match MATCH-FORM against SOURCE of type TYPE.
1147
1148 MATCH-FORM is a proper list of the form (key1 place1 ... keyN
1149 placeN).  Each placeK is either a symbol, which gets bound to the
1150 value of keyK retrieved from the key-value store, or another
1151 match form which gets destructured recursively.
1152
1153 SOURCE is a key-value store of type TYPE, which can be a plist,
1154 an alist or a hash table.
1155
1156 TYPE is a token specifying the type of the key-value store.
1157 Valid values are &plist, &alist and &hash.
1158
1159 (fn MATCH-FORM SOURCE TYPE)
1160 (defalias 'dash--match-kv-1 #[771 "\300\301\302\303\304\305\306\307        \"\310\"\311\312%\313\314\"\"\"\207" [-flatten-n 1 -map make-byte-code 257 "\211@A@\301\302=\204\301\303=\203\304\300E\2021\301\305=\203'\306\307\300ED\2021\301\310=\2051\311\300E9\203=DC\202A\312\"\207" vconcat vector [&plist &keys plist-get &alist cdr assoc &hash gethash dash--match] 7 "\n\n(fn KV)" -partition 2] 13 (#$ . 62283)])
1161 #@96 Bind a symbol.
1162
1163 This works just like `let', there is no destructuring.
1164
1165 (fn MATCH-FORM SOURCE)
1166 (defalias 'dash--match-symbol #[514 "DC\207" [] 4 (#$ . 63224)])
1167 #@281 Match MATCH-FORM against SOURCE.
1168
1169 This function tests the MATCH-FORM and dispatches to specific
1170 matchers based on the type of the expression.
1171
1172 Key-value stores are disambiguated by placing a token &plist,
1173 &alist or &hash as a first item in the MATCH-FORM.
1174
1175 (fn MATCH-FORM SOURCE)
1176 (defalias 'dash--match #[514 "9\203\n\300\"\207:\203CA:\2030@9\2030A@\301=\2030@\211D\302AA\"B\207@\303>\203>\304\305!\"\207\306\"\207\307!\205rG\310V\203n\311H9\203n\312H\301=\203n\311H\211D\302\313\310\"\"B\207\314\"\207" [dash--match-symbol &as dash--match (&keys &plist &alist &hash) dash--match-kv dash--match-kv-normalize-match-form dash--match-cons vectorp 2 0 1 dash--vector-tail dash--match-vector] 8 (#$ . 63393)])
1177 #@364 Normalize VARLIST so that every binding is a list.
1178
1179 `let' allows specifying a binding which is not a list but simply
1180 the place which is then automatically bound to nil, such that all
1181 three of the following are identical and evaluate to nil.
1182
1183   (let (a) a)
1184   (let ((a)) a)
1185   (let ((a nil)) a)
1186
1187 This function normalizes all of these to the last form.
1188
1189 (fn VARLIST)
1190 (defalias 'dash--normalize-let-varlist #[257 "\300\301\"\207" [mapcar #[257 "\211:\203\207\211\300D\207" [nil] 3 "\n\n(fn IT)"]] 4 (#$ . 64141)])
1191 #@476 Bind variables according to VARLIST then eval BODY.
1192
1193 VARLIST is a list of lists of the form (PATTERN SOURCE).  Each
1194 PATTERN is matched against the SOURCE structurally.  SOURCE is
1195 only evaluated once for each PATTERN.
1196
1197 Each SOURCE can refer to the symbols already bound by this
1198 VARLIST.  This is useful if you want to destructure SOURCE
1199 recursively but also want to name the intermediate structures.
1200
1201 See `-let' for the list of all possible patterns.
1202
1203 (fn VARLIST &rest BODY)
1204 (defalias '-let* '(macro . #[385 "\300!\301\302\303\304\"\"\305BB\207" [dash--normalize-let-varlist apply append mapcar #[257 "\300@A@\"\207" [dash--match] 4 "\n\n(fn IT)"] let*] 8 (#$ . 64660)]))
1205 (byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put -let* edebug-form-spec ((&rest [&or (sexp form) sexp]) body) function-put lisp-indent-function 1] 4)
1206 #@5684 Bind variables according to VARLIST then eval BODY.
1207
1208 VARLIST is a list of lists of the form (PATTERN SOURCE).  Each
1209 PATTERN is matched against the SOURCE "structurally".  SOURCE
1210 is only evaluated once for each PATTERN.  Each PATTERN is matched
1211 recursively, and can therefore contain sub-patterns which are
1212 matched against corresponding sub-expressions of SOURCE.
1213
1214 All the SOURCEs are evalled before any symbols are
1215 bound (i.e. "in parallel").
1216
1217 If VARLIST only contains one (PATTERN SOURCE) element, you can
1218 optionally specify it using a vector and discarding the
1219 outer-most parens.  Thus
1220
1221   (-let ((PATTERN SOURCE)) ..)
1222
1223 becomes
1224
1225   (-let [PATTERN SOURCE] ..).
1226
1227 `-let' uses a convention of not binding places (symbols) starting
1228 with _ whenever it's possible.  You can use this to skip over
1229 entries you don't care about.  However, this is not *always*
1230 possible (as a result of implementation) and these symbols might
1231 get bound to undefined values.
1232
1233 Following is the overview of supported patterns.  Remember that
1234 patterns can be matched recursively, so every a, b, aK in the
1235 following can be a matching construct and not necessarily a
1236 symbol/variable.
1237
1238 Symbol:
1239
1240   a - bind the SOURCE to A.  This is just like regular `let'.
1241
1242 Conses and lists:
1243
1244   (a) - bind `car' of cons/list to A
1245
1246   (a . b) - bind car of cons to A and `cdr' to B
1247
1248   (a b) - bind car of list to A and `cadr' to B
1249
1250   (a1 a2 a3  ...) - bind 0th car of list to A1, 1st to A2, 2nd to A3 ...
1251
1252   (a1 a2 a3 ... aN . rest) - as above, but bind the Nth cdr to REST.
1253
1254 Vectors:
1255
1256   [a] - bind 0th element of a non-list sequence to A (works with
1257         vectors, strings, bit arrays...)
1258
1259   [a1 a2 a3 ...] - bind 0th element of non-list sequence to A0, 1st to
1260                    A1, 2nd to A2, ...
1261                    If the PATTERN is shorter than SOURCE, the values at
1262                    places not in PATTERN are ignored.
1263                    If the PATTERN is longer than SOURCE, an `error' is
1264                    thrown.
1265
1266   [a1 a2 a3 ... &rest rest] - as above, but bind the rest of
1267                               the sequence to REST.  This is
1268                               conceptually the same as improper list
1269                               matching (a1 a2 ... aN . rest)
1270
1271 Key/value stores:
1272
1273   (&plist key0 a0 ... keyN aN) - bind value mapped by keyK in the
1274                                  SOURCE plist to aK.  If the
1275                                  value is not found, aK is nil.
1276                                  Uses `plist-get' to fetch values.
1277
1278   (&alist key0 a0 ... keyN aN) - bind value mapped by keyK in the
1279                                  SOURCE alist to aK.  If the
1280                                  value is not found, aK is nil.
1281                                  Uses `assoc' to fetch values.
1282
1283   (&hash key0 a0 ... keyN aN) - bind value mapped by keyK in the
1284                                 SOURCE hash table to aK.  If the
1285                                 value is not found, aK is nil.
1286                                 Uses `gethash' to fetch values.
1287
1288 Further, special keyword &keys supports "inline" matching of
1289 plist-like key-value pairs, similarly to &keys keyword of
1290 `cl-defun'.
1291
1292   (a1 a2 ... aN &keys key1 b1 ... keyN bK)
1293
1294 This binds N values from the list to a1 ... aN, then interprets
1295 the cdr as a plist (see key/value matching above).
1296
1297 A shorthand notation for kv-destructuring exists which allows the
1298 patterns be optionally left out and derived from the key name in
1299 the following fashion:
1300
1301 - a key :foo is converted into `foo' pattern,
1302 - a key 'bar is converted into `bar' pattern,
1303 - a key "baz" is converted into `baz' pattern.
1304
1305 That is, the entire value under the key is bound to the derived
1306 variable without any further destructuring.
1307
1308 This is possible only when the form following the key is not a
1309 valid pattern (i.e. not a symbol, a cons cell or a vector).
1310 Otherwise the matching proceeds as usual and in case of an
1311 invalid spec fails with an error.
1312
1313 Thus the patterns are normalized as follows:
1314
1315    ;; derive all the missing patterns
1316    (&plist :foo 'bar "baz") => (&plist :foo foo 'bar bar "baz" baz)
1317
1318    ;; we can specify some but not others
1319    (&plist :foo 'bar explicit-bar) => (&plist :foo foo 'bar explicit-bar)
1320
1321    ;; nothing happens, we store :foo in x
1322    (&plist :foo x) => (&plist :foo x)
1323
1324    ;; nothing happens, we match recursively
1325    (&plist :foo (a b c)) => (&plist :foo (a b c))
1326
1327 You can name the source using the syntax SYMBOL &as PATTERN.
1328 This syntax works with lists (proper or improper), vectors and
1329 all types of maps.
1330
1331   (list &as a b c) (list 1 2 3)
1332
1333 binds A to 1, B to 2, C to 3 and LIST to (1 2 3).
1334
1335 Similarly:
1336
1337   (bounds &as beg . end) (cons 1 2)
1338
1339 binds BEG to 1, END to 2 and BOUNDS to (1 . 2).
1340
1341   (items &as first . rest) (list 1 2 3)
1342
1343 binds FIRST to 1, REST to (2 3) and ITEMS to (1 2 3)
1344
1345   [vect &as _ b c] [1 2 3]
1346
1347 binds B to 2, C to 3 and VECT to [1 2 3] (_ avoids binding as usual).
1348
1349   (plist &as &plist :b b) (list :a 1 :b 2 :c 3)
1350
1351 binds B to 2 and PLIST to (:a 1 :b 2 :c 3).  Same for &alist and &hash.
1352
1353 This is especially useful when we want to capture the result of a
1354 computation and destructure at the same time.  Consider the
1355 form (function-returning-complex-structure) returning a list of
1356 two vectors with two items each.  We want to capture this entire
1357 result and pass it to another computation, but at the same time
1358 we want to get the second item from each vector.  We can achieve
1359 it with pattern
1360
1361   (result &as [_ a] [_ b]) (function-returning-complex-structure)
1362
1363 Note: Clojure programmers may know this feature as the ":as
1364 binding".  The difference is that we put the &as at the front
1365 because we need to support improper list binding.
1366
1367 (fn VARLIST &rest BODY)
1368 (defalias '-let '(macro . #[385 "\300!\203\301\302\303H\304H\"BB\207\305!\306\303\2039@\307\310\311\"!A@DB\262\210\211T\262A\262\202\266\211\237\262\312\313\314\"\"\315\316BBE\207" [vectorp let* dash--match 0 1 dash--normalize-let-varlist nil make-symbol format "input%d" mapcar #[257 "\211@@A@D\207" [] 3 "\n\n(fn IT)"] -zip let -let*] 11 (#$ . 65512)]))
1369 (byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put -let edebug-form-spec ([&or (&rest [&or (sexp form) sexp]) (vector [&rest [sexp form]])] body) function-put lisp-indent-function 1] 4)
1370 #@423 Return a lambda which destructures its input as MATCH-FORM and executes BODY.
1371
1372 Note that you have to enclose the MATCH-FORM in a pair of parens,
1373 such that:
1374
1375   (-lambda (x) body)
1376   (-lambda (x y ...) body)
1377
1378 has the usual semantics of `lambda'.  Furthermore, these get
1379 translated into normal lambda, so there is no performance
1380 penalty.
1381
1382 See `-let' for the description of destructuring mechanism.
1383
1384 (fn MATCH-FORM &rest BODY)
1385 (defalias '-lambda '(macro . #[385 ":\204\n\300\301\302\"\207\303\304\"\203\305BB\207\306\307\2038@\211\310\311\312\"!DB\262\210\211T\262A\262\202\266\211\237\262\305\313\314\"\315BBE\207" [signal wrong-type-argument "match-form must be a list" -all\? symbolp lambda nil 0 make-symbol format "input%d" mapcar #[257 "\211A@\207" [] 2 "\n\n(fn IT)"] -let*] 11 (#$ . 71787)]))
1386 (byte-code "\300\301\302\303#\300\301\304\305#\306\301\307\310#\207" [function-put -lambda doc-string-elt 2 lisp-indent-function defun put edebug-form-spec (&define sexp [&optional stringp] [&optional ("interactive" interactive)] def-body)] 6)
1387 #@530 Bind each MATCH-FORM to the value of its VAL.
1388
1389 MATCH-FORM destructuring is done according to the rules of `-let'.
1390
1391 This macro allows you to bind multiple variables by destructuring
1392 the value, so for example:
1393
1394   (-setq (a b) x
1395          (&plist :c c) plist)
1396
1397 expands roughly speaking to the following code
1398
1399   (setq a (car x)
1400         b (cadr x)
1401         c (plist-get plist :c))
1402
1403 Care is taken to only evaluate each VAL once so that in case of
1404 multiple assignments it does not cause unexpected side effects.
1405
1406 (fn [MATCH-FORM VAL]...)
1407 (defalias '-setq '(macro . #[128 "\300G\301\"\302U\203\303\304!\210\305\306\307\301\"\"\310\311\"\312\305\313\"\314\315\302\"\316\317\305\320\"!BE\316\317!BF\207" [mod 2 1 error "Odd number of arguments" -map #[257 "\300@A@\"\207" [dash--match] 4 "\n\n(fn X)"] -partition -mapcat #[257 "\300\301\302\303\203&@\304\305\306@!\"\204\211B\262\210\211T\262A\262\202\266\211\237\262\"\207" [-map #[257 "\211@\211\300\301\302!\303Q!D\207" [make-symbol "--dash-binding-" symbol-name "--"] 7 "\n\n(fn BINDING)"] nil 0 string-prefix-p "--" symbol-name] 11 "\n\n(fn BINDINGS)"] let cadr let* -flatten-n setq -flatten reverse] 12 (#$ . 72858)]))
1408 (byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put -setq edebug-form-spec (&rest sexp form) function-put lisp-indent-function 1] 4)
1409 #@320 If all VALS evaluate to true, bind them to their corresponding
1410 VARS and do THEN, otherwise do ELSE. VARS-VALS should be a list
1411 of (VAR VAL) pairs.
1412
1413 Note: binding is done according to `-let*'.  VALS are evaluated
1414 sequentially, and evaluation stops after the first nil VAL is
1415 encountered.
1416
1417 (fn VARS-VALS THEN &rest ELSE)
1418 (defalias '-if-let* '(macro . #[642 "\300\301\302\303\304\"\"!\305\2036@\211@A@\306DC\307     BBBE\266\202\262\210\211T\262A\262\202\f\266\211\207" [reverse apply append mapcar #[257 "\300@A@\"\207" [dash--match] 4 "\n\n(fn IT)"] 0 let if] 15 (#$ . 74204)]))
1419 (byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put -if-let* edebug-form-spec ((&rest (sexp form)) form body) function-put lisp-indent-function 2] 4)
1420 #@153 If VAL evaluates to non-nil, bind it to VAR and do THEN,
1421 otherwise do ELSE.
1422
1423 Note: binding is done according to `-let'.
1424
1425 (fn (VAR VAL) THEN &rest ELSE)
1426 (defalias '-if-let '(macro . #[642 "\300CBBB\207" [-if-let*] 7 (#$ . 74969)]))
1427 (byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put -if-let edebug-form-spec ((sexp form) form body) function-put lisp-indent-function 2] 4)
1428 #@111 If VAL evaluates to non-nil, bind it to symbol `it' and do THEN,
1429 otherwise do ELSE.
1430
1431 (fn VAL THEN &rest ELSE)
1432 (defalias '--if-let '(macro . #[642 "\300\301DBBB\207" [-if-let it] 7 (#$ . 75364)]))
1433 (byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put --if-let edebug-form-spec (form form body) function-put lisp-indent-function 2] 4)
1434 #@301 If all VALS evaluate to true, bind them to their corresponding
1435 VARS and execute body. VARS-VALS should be a list of (VAR VAL)
1436 pairs.
1437
1438 Note: binding is done according to `-let*'.  VALS are evaluated
1439 sequentially, and evaluation stops after the first nil VAL is
1440 encountered.
1441
1442 (fn VARS-VALS &rest BODY)
1443 (defalias '-when-let* '(macro . #[385 "\300\301BE\207" [-if-let* progn] 6 (#$ . 75718)]))
1444 (byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put -when-let* edebug-form-spec ((&rest (sexp form)) body) function-put lisp-indent-function 1] 4)
1445 #@134 If VAL evaluates to non-nil, bind it to VAR and execute body.
1446
1447 Note: binding is done according to `-let'.
1448
1449 (fn (VAR VAL) &rest BODY)
1450 (defalias '-when-let '(macro . #[385 "\300\301BE\207" [-if-let progn] 6 (#$ . 76277)]))
1451 (byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put -when-let edebug-form-spec ((sexp form) body) function-put lisp-indent-function 1] 4)
1452 #@92 If VAL evaluates to non-nil, bind it to symbol `it' and
1453 execute body.
1454
1455 (fn VAL &rest BODY)
1456 (defalias '--when-let '(macro . #[385 "\300\301BE\207" [--if-let progn] 6 (#$ . 76657)]))
1457 (byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put --when-let edebug-form-spec (form body) function-put lisp-indent-function 1] 4)
1458 #@191 Tests for equality use this function or `equal' if this is nil.
1459 It should only be set using dynamic scope with a let, like:
1460
1461   (let ((-compare-fn #\='=)) (-union numbers1 numbers2 numbers3)
1462 (defvar -compare-fn nil (#$ . 76992))
1463 #@160 Return a new list with all duplicates removed.
1464 The test for equality is done with `equal',
1465 or with `-compare-fn' if that's non-nil.
1466
1467 Alias: `-uniq'
1468
1469 (fn LIST)
1470 (defalias '-distinct #[257 "\300\301\203!@\302\"\204\211B\262\210\211T\262A\262\202\266\211\237\207" [nil 0 -contains\?] 8 (#$ . 77227)])
1471 (defalias '-uniq '-distinct)
1472 #@197 Return a new list containing the elements of LIST and elements of LIST2 that are not in LIST.
1473 The test for equality is done with `equal',
1474 or with `-compare-fn' if that's non-nil.
1475
1476 (fn LIST LIST2)
1477 (defalias '-union #[514 "\301!\302\300!\203\203\202\303\211\304>\203_\305\306\"\307\2038@\310\311#\266\211T\262A\262\202\266\307\203Z@\312\"\204N\211B\262\210\211T\262A\262\202<\266\202\201\307\203@\313\"\204s\211B\262\210\211T\262A\262\202a\266\211\237)\207" [-compare-fn reverse boundp equal (eq eql equal) make-hash-table :test 0 puthash t gethash -contains\?] 12 (#$ . 77576)])
1478 #@191 Return a new list containing only the elements that are members of both LIST and LIST2.
1479 The test for equality is done with `equal',
1480 or with `-compare-fn' if that's non-nil.
1481
1482 (fn LIST LIST2)
1483 (defalias '-intersection #[514 "\300\301\203!@\302\"\203\211B\262\210\211T\262A\262\202\266\211\237\207" [nil 0 -contains\?] 9 (#$ . 78217)])
1484 #@174 Return a new list with only the members of LIST that are not in LIST2.
1485 The test for equality is done with `equal',
1486 or with `-compare-fn' if that's non-nil.
1487
1488 (fn LIST LIST2)
1489 (defalias '-difference #[514 "\300\301\203!@\302\"\204\211B\262\210\211T\262A\262\202\266\211\237\207" [nil 0 -contains\?] 9 (#$ . 78572)])
1490 #@42 Return the power set of LIST.
1491
1492 (fn LIST)
1493 (defalias '-powerset #[257 "\211\204\300\207\301A!\302\303\304\305\306\307\310!\311\"\312\313%\"\"\207" [(nil) -powerset append mapcar make-byte-code 257 "\300@B\207" vconcat vector [] 3 "\n\n(fn X)"] 10 (#$ . 78907)])
1494 #@45 Return the permutations of LIST.
1495
1496 (fn LIST)
1497 (defalias '-permutations #[257 "\211\204\300\207\301\302\303\304\305\306\307\310!\311\"\312\313%\"\"\207" [(nil) apply append mapcar make-byte-code 257 "\301\302\303\304\305\306!\307\"\310\311%\312\313\300\"!\"\207" vconcat vector [mapcar make-byte-code 257 "\300B\207" vconcat vector [] 3 "\n\n(fn PERM)" -permutations remove] 8 "\n\n(fn X)"] 10 (#$ . 79181)])
1498 #@41 Return all prefixes of LIST.
1499
1500 (fn LIST)
1501 (defalias '-inits #[257 "\300\301\302\237!\"\237\207" [-map reverse -tails] 5 (#$ . 79602)])
1502 #@40 Return all suffixes of LIST
1503
1504 (fn LIST)
1505 (defalias '-tails #[257 "\300\301\302#\207" [-reductions-r-from cons nil] 5 (#$ . 79742)])
1506 #@62 Return the longest common prefix of LISTS.
1507
1508 (fn &rest LISTS)
1509 (defalias '-common-prefix #[128 "\211\211\203b\211@A\300\203Z@\301\302\300\203F\203F@\203/\211A\262\n\242\232\2045\301\262\202:\211B\262\210\211T\262A\262\202\266\211\237\262\262\210\211T\262A\262\202\n\266\211\262\202\242\301\211\211\302\300\203\232\203\232@\203\203\211A\262\242\232\204\211\301\262\202\216\211B\262\210\211T\262A\262\202h\266\211\237\262\266\202\207" [0 nil t] 13 (#$ . 79879)])
1510 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -common-prefix pure t side-effect-free] 5)
1511 #@62 Return the longest common suffix of LISTS.
1512
1513 (fn &rest LISTS)
1514 (defalias '-common-suffix #[128 "\300\301\302\303\"\"\237\207" [apply -common-prefix mapcar reverse] 6 (#$ . 80518)])
1515 #@169 Return non-nil if LIST contains ELEMENT.
1516
1517 The test for equality is done with `equal', or with `-compare-fn'
1518 if that's non-nil.
1519
1520 Alias: `-contains-p'
1521
1522 (fn LIST ELEMENT)
1523 (defalias '-contains\? #[514 "\204\n\211\235\202:\301=\203\211>\202:\302=\203#\303\"\202:\211\2037@\"\2047\211A\262\202$\211\262??\207" [-compare-fn eq eql memql] 6 (#$ . 80705)])
1524 (defalias '-contains-p '-contains\?)
1525 #@149 Return true if LIST and LIST2 has the same items.
1526
1527 The order of the elements in the lists does not matter.
1528
1529 Alias: `-same-items-p'
1530
1531 (fn LIST LIST2)
1532 (defalias '-same-items\? #[514 "GGU\205\300\"GU\207" [-intersection] 8 (#$ . 81120)])
1533 (defalias '-same-items-p '-same-items\?)
1534 #@86 Return non-nil if PREFIX is prefix of LIST.
1535
1536 Alias: `-is-prefix-p'
1537
1538 (fn PREFIX LIST)
1539 (defalias '-is-prefix\? #[514 "\211\300\301\203*\203*@@\232\204\302\262\202A\262\210\211T\262A\262\202\266?\207" [t 0 nil] 8 (#$ . 81410)])
1540 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -is-prefix\? pure t side-effect-free] 5)
1541 #@86 Return non-nil if SUFFIX is suffix of LIST.
1542
1543 Alias: `-is-suffix-p'
1544
1545 (fn SUFFIX LIST)
1546 (defalias '-is-suffix\? #[514 "\300\301!\301!\"\207" [-is-prefix\? reverse] 6 (#$ . 81773)])
1547 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -is-suffix\? pure t side-effect-free] 5)
1548 #@118 Return non-nil if INFIX is infix of LIST.
1549
1550 This operation runs in O(n^2) time
1551
1552 Alias: `-is-infix-p'
1553
1554 (fn INFIX LIST)
1555 (defalias '-is-infix\? #[514 "\300\211\204\203\301\"\262A\262\202\211\207" [nil -is-prefix\?] 6 (#$ . 82071)])
1556 (byte-code "\300\301\302\303#\300\301\304\303#\305\306\307\"\210\305\310\311\"\210\305\312\301\"\207" [function-put -is-infix\? pure t side-effect-free defalias -is-prefix-p -is-prefix\? -is-suffix-p -is-suffix\? -is-infix-p] 5)
1557 #@268 Sort LIST, stably, comparing elements using COMPARATOR.
1558 Return the sorted list.  LIST is NOT modified by side effects.
1559 COMPARATOR is called with two elements of LIST, and should return non-nil
1560 if the first element should sort before the second.
1561
1562 (fn COMPARATOR LIST)
1563 (defalias '-sort #[514 "\300\301!\"\207" [sort copy-sequence] 5 (#$ . 82547)])
1564 #@44 Anaphoric form of `-sort'.
1565
1566 (fn FORM LIST)
1567 (defalias '--sort '(macro . #[514 "\300\301\302EE\207" [-sort lambda (it other)] 6 (#$ . 82901)]))
1568 (put '--sort 'edebug-form-spec '(form form))
1569 #@151 Return a list with ARGS.
1570
1571 If first item of ARGS is already a list, simply return ARGS.  If
1572 not, return a list with ARGS as elements.
1573
1574 (fn &rest ARGS)
1575 (defalias '-list #[128 "\211@\211<\203 \211\202\f\207" [] 3 (#$ . 83097)])
1576 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -list pure t side-effect-free] 5)
1577 #@82 Return a list with X repeated N times.
1578 Return nil if N is less than 1.
1579
1580 (fn N X)
1581 (defalias '-repeat #[514 "\300\301\211W\203B\262\211T\262\202\266\211\207" [nil 0] 7 (#$ . 83435)])
1582 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -repeat pure t side-effect-free] 5)
1583 #@36 Return the sum of LIST.
1584
1585 (fn LIST)
1586 (defalias '-sum #[257 "\300\301\"\207" [apply +] 4 (#$ . 83739)])
1587 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -sum pure t side-effect-free] 5)
1588 #@87 Return a list with running sums of items in LIST.
1589
1590 LIST must be non-empty.
1591
1592 (fn LIST)
1593 (defalias '-running-sum #[257 "\211:\204    \300\301!\210\302\303\"\207" [error "LIST must be non-empty" -reductions +] 4 (#$ . 83950)])
1594 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -running-sum pure t side-effect-free] 5)
1595 #@40 Return the product of LIST.
1596
1597 (fn LIST)
1598 (defalias '-product #[257 "\300\301\"\207" [apply *] 4 (#$ . 84289)])
1599 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -product pure t side-effect-free] 5)
1600 #@91 Return a list with running products of items in LIST.
1601
1602 LIST must be non-empty.
1603
1604 (fn LIST)
1605 (defalias '-running-product #[257 "\211:\204    \300\301!\210\302\303\"\207" [error "LIST must be non-empty" -reductions *] 4 (#$ . 84512)])
1606 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -running-product pure t side-effect-free] 5)
1607 #@70 Return the largest value from LIST of numbers or markers.
1608
1609 (fn LIST)
1610 (defalias '-max #[257 "\300\301\"\207" [apply max] 4 (#$ . 84863)])
1611 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -max pure t side-effect-free] 5)
1612 #@71 Return the smallest value from LIST of numbers or markers.
1613
1614 (fn LIST)
1615 (defalias '-min #[257 "\300\301\"\207" [apply min] 4 (#$ . 85110)])
1616 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -min pure t side-effect-free] 5)
1617 #@225 Take a comparison function COMPARATOR and a LIST and return
1618 the greatest element of the list by the comparison function.
1619
1620 See also combinator `-on' which can transform the values before
1621 comparing them.
1622
1623 (fn COMPARATOR LIST)
1624 (defalias '-max-by #[514 "\211\211\2033\211@A\300\203+@\"\203\211\202\262\210\211T\262A\262\202\n\266\211\262\202C\301\211\"\203@\211\202A\266\202\207" [0 nil] 10 (#$ . 85359)])
1625 #@222 Take a comparison function COMPARATOR and a LIST and return
1626 the least element of the list by the comparison function.
1627
1628 See also combinator `-on' which can transform the values before
1629 comparing them.
1630
1631 (fn COMPARATOR LIST)
1632 (defalias '-min-by #[514 "\211\211\2033\211@A\300\203+@\"\203\202\211\262\210\211T\262A\262\202\n\266\211\262\202C\301\211\"\203@\202A\211\266\202\207" [0 nil] 10 (#$ . 85796)])
1633 #@117 Anaphoric version of `-max-by'.
1634
1635 The items for the comparator form are exposed as "it" and "other".
1636
1637 (fn FORM LIST)
1638 (defalias '--max-by '(macro . #[514 "\300\301\302EE\207" [-max-by lambda (it other)] 6 (#$ . 86230)]))
1639 (put '--max-by 'edebug-form-spec '(form form))
1640 #@117 Anaphoric version of `-min-by'.
1641
1642 The items for the comparator form are exposed as "it" and "other".
1643
1644 (fn FORM LIST)
1645 (defalias '--min-by '(macro . #[514 "\300\301\302EE\207" [-min-by lambda (it other)] 6 (#$ . 86505)]))
1646 (put '--min-by 'edebug-form-spec '(form form))
1647 #@182 Return a list of iterated applications of FUN to INIT.
1648
1649 This means a list of form:
1650
1651   (init (fun init) (fun (fun init)) ...)
1652
1653 N is the length of the returned list.
1654
1655 (fn FUN INIT N)
1656 (defalias '-iterate #[771 "\211\300U?\205'CS\300\211W\203!@!B\262\211T\262\202\f\266\211\237\262\207" [0] 8 (#$ . 86780)])
1657 #@139 Compute the (least) fixpoint of FN with initial input LIST.
1658
1659 FN is called at least once, results are compared with `equal'.
1660
1661 (fn FN LIST)
1662 (defalias '-fix #[514 "!\232\204\211\262!\262\202\211\207" [] 5 (#$ . 87104)])
1663 #@43 Anaphoric form of `-fix'.
1664
1665 (fn FORM LIST)
1666 (defalias '--fix '(macro . #[514 "\300\301\302EE\207" [-fix lambda (it)] 6 (#$ . 87339)]))
1667 #@362 Build a list from SEED using FUN.
1668
1669 This is "dual" operation to `-reduce-r': while -reduce-r
1670 consumes a list to produce a single value, `-unfold' takes a
1671 seed value and builds a (potentially infinite!) list.
1672
1673 FUN should return `nil' to stop the generating process, or a
1674 cons (A . B), where A will be prepended to the result and B is
1675 the new seed.
1676
1677 (fn FUN SEED)
1678 (defalias '-unfold #[514 "!\300\203@B\262A!\262\202\211\237\207" [nil] 6 (#$ . 87481)])
1679 #@49 Anaphoric version of `-unfold'.
1680
1681 (fn FORM SEED)
1682 (defalias '--unfold '(macro . #[514 "\300\301\302EE\207" [-unfold lambda (it)] 6 (#$ . 87949)]))
1683 (put '--unfold 'edebug-form-spec '(form form))
1684 #@91 Return non-nil if CON is true cons pair.
1685 That is (A . B) where B is not a list.
1686
1687 (fn CON)
1688 (defalias '-cons-pair\? #[257 "\211<\205    \211A<?\207" [] 2 (#$ . 88149)])
1689 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -cons-pair\? pure t side-effect-free] 5)
1690 #@88 Convert a cons pair to a list with `car' and `cdr' of the pair respectively.
1691
1692 (fn CON)
1693 (defalias '-cons-to-list #[257 "\211@AD\207" [] 3 (#$ . 88431)])
1694 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -cons-to-list pure t side-effect-free] 5)
1695 #@192 Convert a value to a list.
1696
1697 If the value is a cons pair, make a list with two elements, `car'
1698 and `cdr' of the pair respectively.
1699
1700 If the value is anything else, wrap it in a list.
1701
1702 (fn VAL)
1703 (defalias '-value-to-list #[257 "\300!\203\n\301!\207\211C\207" [-cons-pair\? -cons-to-list] 3 (#$ . 88703)])
1704 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -value-to-list pure t side-effect-free] 5)
1705 #@423 Apply FN to each element of TREE, and make a list of the results.
1706 If elements of TREE are lists themselves, apply FN recursively to
1707 elements of these nested lists.
1708
1709 Then reduce the resulting lists using FOLDER and initial value
1710 INIT-VALUE. See `-reduce-r-from'.
1711
1712 This is the same as calling `-tree-reduce-from' after `-tree-map'
1713 but is twice as fast as it only traverse the structure once.
1714
1715 (fn FN FOLDER INIT-VALUE TREE)
1716 (defalias '-tree-mapreduce-from #[1028 "\211\204\300\207\301!\203!\207\211<\203.\302\303\304\305\306\307\310\f\f\f#\311\"\312\313%\"#\207!\207" [nil -cons-pair\? -reduce-r-from mapcar make-byte-code 257 "\303\300\301\302$\207" vconcat vector [-tree-mapreduce-from] 6 "\n\n(fn X)"] 16 (#$ . 89127)])
1717 #@77 Anaphoric form of `-tree-mapreduce-from'.
1718
1719 (fn FORM FOLDER INIT-VALUE TREE)
1720 (defalias '--tree-mapreduce-from '(macro . #[1028 "\300\301\302E\301\303E\257\207" [-tree-mapreduce-from lambda (it) (it acc)] 9 (#$ . 89871)]))
1721 (put '--tree-mapreduce-from 'edebug-form-spec '(form form form form))
1722 #@407 Apply FN to each element of TREE, and make a list of the results.
1723 If elements of TREE are lists themselves, apply FN recursively to
1724 elements of these nested lists.
1725
1726 Then reduce the resulting lists using FOLDER and initial value
1727 INIT-VALUE. See `-reduce-r-from'.
1728
1729 This is the same as calling `-tree-reduce' after `-tree-map'
1730 but is twice as fast as it only traverse the structure once.
1731
1732 (fn FN FOLDER TREE)
1733 (defalias '-tree-mapreduce #[771 "\211\204\300\207\301!\203!\207\211<\203+\302\303\304\305\306\307\310\n\n\"\311\"\312\313%\"\"\207!\207" [nil -cons-pair\? -reduce-r mapcar make-byte-code 257 "\302\300\301#\207" vconcat vector [-tree-mapreduce] 5 "\n\n(fn X)"] 13 (#$ . 90176)])
1734 #@61 Anaphoric form of `-tree-mapreduce'.
1735
1736 (fn FORM FOLDER TREE)
1737 (defalias '--tree-mapreduce '(macro . #[771 "\300\301\302E\301\303EF\207" [-tree-mapreduce lambda (it) (it acc)] 8 (#$ . 90882)]))
1738 (put '--tree-mapreduce 'edebug-form-spec '(form form form))
1739 #@85 Apply FN to each element of TREE while preserving the tree structure.
1740
1741 (fn FN TREE)
1742 (defalias '-tree-map #[514 "\211\204\300\207\301!\203!\207\211<\203&\302\303\304\305\306\307!\310\"\311\312%\"\207!\207" [nil -cons-pair\? mapcar make-byte-code 257 "\301\300\"\207" vconcat vector [-tree-map] 4 "\n\n(fn X)"] 9 (#$ . 91142)])
1743 #@48 Anaphoric form of `-tree-map'.
1744
1745 (fn FORM TREE)
1746 (defalias '--tree-map '(macro . #[514 "\300\301\302EE\207" [-tree-map lambda (it)] 6 (#$ . 91488)]))
1747 (put '--tree-map 'edebug-form-spec '(form form))
1748 #@346 Use FN to reduce elements of list TREE.
1749 If elements of TREE are lists themselves, apply the reduction recursively.
1750
1751 FN is first applied to INIT-VALUE and first element of the list,
1752 then on this result and second element from the list etc.
1753
1754 The initial value is ignored on cons pairs as they always contain
1755 two elements.
1756
1757 (fn FN INIT-VALUE TREE)
1758 (defalias '-tree-reduce-from #[771 "\211\204\300\207\301!\203 \207\211<\203)\302\303\304\305\306\307\310  \"\311\"\312\313%\"#\207\207" [nil -cons-pair\? -reduce-r-from mapcar make-byte-code 257 "\302\300\301#\207" vconcat vector [-tree-reduce-from] 5 "\n\n(fn X)"] 14 (#$ . 91694)])
1759 #@67 Anaphoric form of `-tree-reduce-from'.
1760
1761 (fn FORM INIT-VALUE TREE)
1762 (defalias '--tree-reduce-from '(macro . #[771 "\300\301\302EF\207" [-tree-reduce-from lambda (it acc)] 7 (#$ . 92340)]))
1763 (put '--tree-reduce-from 'edebug-form-spec '(form form form))
1764 #@332 Use FN to reduce elements of list TREE.
1765 If elements of TREE are lists themselves, apply the reduction recursively.
1766
1767 FN is first applied to first element of the list and second
1768 element, then on this result and third element from the list etc.
1769
1770 See `-reduce-r' for how exactly are lists of zero or one element handled.
1771
1772 (fn FN TREE)
1773 (defalias '-tree-reduce #[514 "\211\204\300\207\301!\203 \207\211<\203&\302\303\304\305\306\307\310    !\311\"\312\313%\"\"\207\207" [nil -cons-pair\? -reduce-r mapcar make-byte-code 257 "\301\300\"\207" vconcat vector [-tree-reduce] 4 "\n\n(fn X)"] 11 (#$ . 92599)])
1774 #@51 Anaphoric form of `-tree-reduce'.
1775
1776 (fn FORM TREE)
1777 (defalias '--tree-reduce '(macro . #[514 "\300\301\302EE\207" [-tree-reduce lambda (it acc)] 6 (#$ . 93210)]))
1778 (put '--tree-reduce 'edebug-form-spec '(form form))
1779 #@207 Call FUN on each node of TREE that satisfies PRED.
1780
1781 If PRED returns nil, continue descending down this node.  If PRED
1782 returns non-nil, apply FUN to this node and do not descend
1783 further.
1784
1785 (fn PRED FUN TREE)
1786 (defalias '-tree-map-nodes #[771 "!\203\n!\207\211<\203(\300!\204(\301\302\303\304\305\306\"\307\"\310\311%\"\207\207" [-cons-pair\? -map make-byte-code 257 "\302\300\301#\207" vconcat vector [-tree-map-nodes] 5 "\n\n(fn X)"] 11 (#$ . 93432)])
1787 #@59 Anaphoric form of `-tree-map-nodes'.
1788
1789 (fn PRED FORM TREE)
1790 (defalias '--tree-map-nodes '(macro . #[771 "\300\301\302E\301\303EF\207" [-tree-map-nodes lambda (it) (it)] 8 (#$ . 93902)]))
1791 #@363 Return a sequence of the nodes in TREE, in depth-first search order.
1792
1793 BRANCH is a predicate of one argument that returns non-nil if the
1794 passed argument is a branch, that is, a node that can have children.
1795
1796 CHILDREN is a function of one argument that returns the children
1797 of the passed branch node.
1798
1799 Non-branch nodes are simply copied.
1800
1801 (fn BRANCH CHILDREN TREE)
1802 (defalias '-tree-seq #[771 "\211!\205\300\301\302\303\304\305        \"\306\"\307\310%!\"B\207" [-mapcat make-byte-code 257 "\302\300\301#\207" vconcat vector [-tree-seq] 5 "\n\n(fn X)"] 12 (#$ . 94097)])
1803 #@59 Anaphoric form of `-tree-seq'.
1804
1805 (fn BRANCH CHILDREN TREE)
1806 (defalias '--tree-seq '(macro . #[771 "\300\301\302E\301\303EF\207" [-tree-seq lambda (it) (it)] 8 (#$ . 94673)]))
1807 #@205 Create a deep copy of LIST.
1808 The new list has the same elements and structure but all cons are
1809 replaced with new ones.  This is useful when you need to clone a
1810 structure such as plist or alist.
1811
1812 (fn LIST)
1813 (defalias '-clone #[257 "\300\301\"\207" [-tree-map identity] 4 (#$ . 94856)])
1814 (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -clone pure t side-effect-free] 5)
1815 #@69 Add syntax highlighting to dash functions, macros and magic values.
1816 (defalias 'dash-enable-font-lock #[0 "\300\301\302\"\207" [eval-after-load lisp-mode #[0 "\302\303\304\305\306\307\310\"\311Q\312BC\313#\210\304\305\314\307\310\"\311Q\315BC\313#\266\316 \317\205N@r\211q\210\305=\203A\320\301!\203A    \203A\321 \210)\210\211T\262A\262\202$\207" [major-mode font-lock-mode ("!cons" "!cdr" "-each" "--each" "-each-indexed" "--each-indexed" "-each-while" "--each-while" "-doto" "-dotimes" "--dotimes" "-map" "--map" "-reduce-from" "--reduce-from" "-reduce" "--reduce" "-reduce-r-from" "--reduce-r-from" "-reduce-r" "--reduce-r" "-reductions-from" "-reductions-r-from" "-reductions" "-reductions-r" "-filter" "--filter" "-select" "--select" "-remove" "--remove" "-reject" "--reject" "-remove-first" "--remove-first" "-reject-first" "--reject-first" "-remove-last" "--remove-last" "-reject-last" "--reject-last" "-remove-item" "-non-nil" "-keep" "--keep" "-map-indexed" "--map-indexed" "-splice" "--splice" "-splice-list" "--splice-list" "-map-when" "--map-when" "-replace-where" "--replace-where" "-map-first" "--map-first" "-map-last" "--map-last" "-replace" "-replace-first" "-replace-last" "-flatten" "-flatten-n" "-concat" "-mapcat" "--mapcat" "-copy" "-cons*" "-snoc" "-first" "--first" "-find" "--find" "-some" "--some" "-any" "--any" "-last" "--last" "-first-item" "-second-item" "-third-item" "-fourth-item" "-fifth-item" "-last-item" "-butlast" "-count" "--count" "-any?" "--any?" "-some?" "--some?" "-any-p" "--any-p" "-some-p" "--some-p" "-some->" "-some->>" "-some-->" "-all?" "-all-p" "--all?" "--all-p" "-every?" "--every?" "-all-p" "--all-p" "-every-p" "--every-p" "-none?" "--none?" "-none-p" "--none-p" "-only-some?" "--only-some?" "-only-some-p" "--only-some-p" "-slice" "-take" "-drop" "-drop-last" "-take-last" "-take-while" "--take-while" "-drop-while" "--drop-while" "-split-at" "-rotate" "-insert-at" "-replace-at" "-update-at" "--update-at" "-remove-at" "-remove-at-indices" "-split-with" "--split-with" "-split-on" "-split-when" "--split-when" "-separate" "--separate" "-partition-all-in-steps" "-partition-in-steps" "-partition-all" "-partition" "-partition-after-item" "-partition-after-pred" "-partition-before-item" "-partition-before-pred" "-partition-by" "--partition-by" "-partition-by-header" "--partition-by-header" "-group-by" "--group-by" "-interpose" "-interleave" "-unzip" "-zip-with" "--zip-with" "-zip" "-zip-fill" "-zip-pair" "-cycle" "-pad" "-annotate" "--annotate" "-table" "-table-flat" "-partial" "-elem-index" "-elem-indices" "-find-indices" "--find-indices" "-find-index" "--find-index" "-find-last-index" "--find-last-index" "-select-by-indices" "-select-columns" "-select-column" "-grade-up" "-grade-down" "->" "->>" "-->" "-as->" "-when-let" "-when-let*" "--when-let" "-if-let" "-if-let*" "--if-let" "-let*" "-let" "-lambda" "-distinct" "-uniq" "-union" "-intersection" "-difference" "-powerset" "-permutations" "-inits" "-tails" "-common-prefix" "-common-suffix" "-contains?" "-contains-p" "-same-items?" "-same-items-p" "-is-prefix-p" "-is-prefix?" "-is-suffix-p" "-is-suffix?" "-is-infix-p" "-is-infix?" "-sort" "--sort" "-list" "-repeat" "-sum" "-running-sum" "-product" "-running-product" "-max" "-min" "-max-by" "--max-by" "-min-by" "--min-by" "-iterate" "--iterate" "-fix" "--fix" "-unfold" "--unfold" "-cons-pair?" "-cons-to-list" "-value-to-list" "-tree-mapreduce-from" "--tree-mapreduce-from" "-tree-mapreduce" "--tree-mapreduce" "-tree-map" "--tree-map" "-tree-reduce-from" "--tree-reduce-from" "-tree-reduce" "--tree-reduce" "-tree-seq" "--tree-seq" "-tree-map-nodes" "--tree-map-nodes" "-clone" "-rpartial" "-juxt" "-applify" "-on" "-flip" "-const" "-cut" "-orfn" "-andfn" "-iteratefn" "-fixfn" "-prodfn") ("it" "it-index" "acc" "other") font-lock-add-keywords emacs-lisp-mode "\\_<" regexp-opt paren "\\_>" (1 font-lock-variable-name-face) append "(\\s-*" (1 font-lock-keyword-face) buffer-list 0 boundp font-lock-refresh-defaults] 8]] 3 (#$ . 95251)])
1817 (provide 'dash)