.emacs.d.git - Gitblit

Chizi123

2018-11-18 21067e7cbe6d7a0f65ff5c317a96b5c337b0b3d8

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\313D\314 \315BBBBBE\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 \315DD\257\316\310\312\313DDDD\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\315BD\316B\n\317\fDD\257\320\311\313\314DDDD\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)