;ELC   
;;; Compiled by  on Sat Jul 19 11:20:52 2014
;;; from file /Users/daniel/.emacs.d/elpa/dash-20140717.547/dash.el
;;; in Emacs version 24.1.1
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


(custom-declare-group 'dash nil "Customize group for dash.el" :group 'lisp :prefix "dash-")
(defalias 'dash--enable-fontlock #[(symbol value) "\203 \302 \210\303	\"\207" [value symbol dash-enable-font-lock set-default] 3])
#@80 If non-nil, enable fontification of dash functions, macros and
special values.
(custom-declare-variable 'dash-enable-fontlock 'nil '(#$ . 736) :type 'boolean :set 'dash--enable-fontlock :group 'dash)
#@50 Destructive: Set CDR to the cons of CAR and CDR.
(defalias '!cons '(macro . #[(car cdr) "\302\303	EE\207" [cdr car setq cons] 5 (#$ . 942)]))
#@43 Destructive: Set LIST to the cdr of LIST.
(defalias '!cdr '(macro . #[(list) "\301\302DE\207" [list setq cdr] 4 (#$ . 1092)]))(if macro-declaration-function (funcall macro-declaration-function (quote --each) (quote (declare (debug (form body)) (indent 1)))))
#@28 Anaphoric form of `-each'.
(defalias '--each '(macro . #[(list &rest body) "\303\304!\305	D\306B\307\305\310\311DDC\nBB\312\313D\257E)\207" [l list body make-symbol "list" let ((it-index 0)) while it car (setq it-index (1+ it-index)) !cdr] 8 (#$ . 1359)]))
#@74 Call FN with every item in LIST. Return nil, used for side-effects only.
(defalias '-each #[(list fn) "\305\211\205 \n@\f!\210)	T\nA\211\204 \306*\207" [list it-index #1=#:list it fn 0 nil] 3 (#$ . 1628)])(if macro-declaration-function (funcall macro-declaration-function (quote --each-while) (quote (declare (debug (form form body)) (indent 2)))))
(put '-each 'lisp-indent-function 1)
#@34 Anaphoric form of `-each-while'.
(defalias '--each-while '(macro . #[(list pred &rest body) "\305\306!\305\307!\310	\nD\311B\312BB\313\314	E\310\315\316	DDC\317\320D\321\322BB\fBBBE\323\324	D\257E*\207" [c l list pred body make-symbol "list" "continue" let (t) ((it-index 0)) while and it car if not setq (nil) (setq it-index (1+ it-index)) !cdr] 11 (#$ . 2029)]))
#@103 Call FN with every item in LIST while (PRED item) is non-nil.
Return nil, used for side-effects only.
(defalias '-each-while #[(list pred fn) "\306\307\211\205- \n\205- @\f!\204 \310\202! 	\f!\210)	TA\211\204\n \310+\207" [list it-index #1=#:continue #2=#:list it pred t 0 nil fn] 4 (#$ . 2408)])(if macro-declaration-function (funcall macro-declaration-function (quote --dotimes) (quote (declare (debug (form body)) (indent 1)))))
(put '-each-while 'lisp-indent-function 2)
#@106 Repeatedly executes BODY (presumably for side-effects) with `it` bound to integers from 0 through NUM-1.
(defalias '--dotimes '(macro . #[(num &rest body) "\303\304!\305	D\306B\307\310\311E\312\n\313\"BBE)\207" [n num body make-symbol "num" let ((it 0)) while < it append ((setq it (1+ it)))] 7 (#$ . 2903)]))
#@93 Repeatedly calls FN (presumably for side-effects) passing in integers from 0 through NUM-1.
(defalias '-dotimes #[(num fn) "\304	\nW\205 	!\210	T\211\202 *\207" [num it #1=#:num fn 0] 3 (#$ . 3222)])
(put '-dotimes 'lisp-indent-function 1)
#@81 Return a new list consisting of the result of applying FN to the items in LIST.
(defalias '-map #[(fn list) "\302	\"\207" [fn list mapcar] 3 (#$ . 3475)])(if macro-declaration-function (funcall macro-declaration-function (quote --map) (quote (declare (debug (form form))))))
#@27 Anaphoric form of `-map'.
(defalias '--map '(macro . #[(form list) "\302\303\304E	E\207" [form list mapcar lambda (it)] 4 (#$ . 3757)]))(if macro-declaration-function (funcall macro-declaration-function (quote --reduce-from) (quote (declare (debug (form form form))))))
#@35 Anaphoric form of `-reduce-from'.
(defalias '--reduce-from '(macro . #[(form initial-value list) "\303\304DC\305	\306\304\nEE\307BBB\207" [initial-value list form let acc --each setq (acc)] 7 (#$ . 4034)]))
#@287 Return the result of applying FN to INITIAL-VALUE and the
first item in LIST, then applying FN to that result and the 2nd
item, etc. If LIST contains no items, return INITIAL-VALUE and
FN is not called.

In the anaphoric form `--reduce-from', the accumulated value is
exposed as `acc`.
(defalias '-reduce-from #[(fn initial-value list) "\n\306\211\203 \f@	\")T\fA\211\204\n *	)\207" [initial-value acc list it-index #1=#:list it 0 fn] 4 (#$ . 4249)])(if macro-declaration-function (funcall macro-declaration-function (quote --reduce) (quote (declare (debug (form form))))))
#@30 Anaphoric form of `-reduce'.
(defalias '--reduce '(macro . #[(form list) "\303\304!\305	DC\306\307\n\310D\311DF\305\312\nEFE)\207" [lv list form make-symbol "list-value" let if --reduce-from car cdr (acc it)] 9 (#$ . 4842)]))
#@385 Return the result of applying FN to the first 2 items in LIST,
then applying FN to that result and the 3rd item, etc. If LIST
contains no items, FN must accept no arguments as well, and
reduce return the result of calling FN with no arguments. If
LIST has only 1 item, it is returned and FN is not called.

In the anaphoric form `--reduce', the accumulated value is
exposed as `acc`.
(defalias '-reduce #[(fn list) "\203\f \302	@A#\207	 \207" [list fn -reduce-from] 4 (#$ . 5080)])
#@269 Replace conses with FN, nil with INITIAL-VALUE and evaluate
the resulting expression. If LIST is empty, INITIAL-VALUE is
returned and FN is not called.

Note: this function works the same as `-reduce-from' but the
operation associates from right instead of from left.
(defalias '-reduce-r-from #[(fn initial-value list) "\204 	\207\n@\303\n	A#\"\207" [list initial-value fn -reduce-r-from] 6 (#$ . 5572)])(if macro-declaration-function (funcall macro-declaration-function (quote --reduce-r-from) (quote (declare (debug (form form form))))))
#@40 Anaphoric version of `-reduce-r-from'.
(defalias '--reduce-r-from '(macro . #[(form initial-value list) "\303\304\305E	\nF\207" [form initial-value list -reduce-r-from lambda (&optional it acc)] 4 (#$ . 6123)]))
#@468 Replace conses with FN and evaluate the resulting expression.
The final nil is ignored. If LIST contains no items, FN must
accept no arguments as well, and reduce return the result of
calling FN with no arguments. If LIST has only 1 item, it is
returned and FN is not called.

The first argument of FN is the new item, the second is the
accumulated value.

Note: this function works the same as `-reduce' but the operation
associates from right instead of from left.
(defalias '-reduce-r #[(fn list) "\204 	 \207A\204 @\207	@\302	A\"\"\207" [list fn -reduce-r] 5 (#$ . 6343)])(if macro-declaration-function (funcall macro-declaration-function (quote --reduce-r) (quote (declare (debug (form form))))))
#@35 Anaphoric version of `-reduce-r'.
(defalias '--reduce-r '(macro . #[(form list) "\302\303\304E	E\207" [form list -reduce-r lambda (&optional it acc)] 4 (#$ . 7058)]))(if macro-declaration-function (funcall macro-declaration-function (quote --filter) (quote (declare (debug (form form))))))
#@30 Anaphoric form of `-filter'.
(defalias '--filter '(macro . #[(form list) "\303\304!\305C\306	\307\n\310\311EEE\312DF)\207" [r list form make-symbol "result" let --each when !cons it nreverse] 9 (#$ . 7355)]))
#@98 Return a new list of the items in LIST for which PRED returns a non-nil value.

Alias: `-select'
(defalias '-filter #[(pred list) "\306	\307\211\203\" @\f!\203 \fB)\nTA\211\204\n *\237)\207" [#1=#:result list it-index #2=#:list it pred nil 0] 3 (#$ . 7574)])(if macro-declaration-function (funcall macro-declaration-function (quote --remove) (quote (declare (debug (form form))))))
(byte-code "\300\301\302\"\210\300\303\304\"\207" [defalias -select -filter --select --filter] 3)
#@30 Anaphoric form of `-remove'.
(defalias '--remove '(macro . #[(form list) "\302\303D	E\207" [form list --filter not] 3 (#$ . 8073)]))
#@86 Return a new list of the items in LIST for which PRED returns nil.

Alias: `-reject'
(defalias '-remove #[(pred list) "\306	\307\211\203\" @\f!\204 \fB)\nTA\211\204\n *\237)\207" [#1=#:result list it-index #2=#:list it pred nil 0] 3 (#$ . 8213)])(if macro-declaration-function (funcall macro-declaration-function (quote --keep) (quote (declare (debug (form form))))))
(byte-code "\300\301\302\"\210\300\303\304\"\207" [defalias -reject -remove --reject --remove] 3)
#@28 Anaphoric form of `-keep'.
(defalias '--keep '(macro . #[(form list) "\304\305!\304\306!\307	C\310\n\307DC\311\312	EEEE\313	DF*\207" [m r list form make-symbol "result" "mapped" let --each when !cons nreverse] 11 (#$ . 8698)]))
#@79 Return a new list of the non-nil results of applying FN to the items in LIST.
(defalias '-keep #[(fn list) "\306	\307\211\203& @\f!\211\203 B*\nTA\211\204\n *\237)\207" [#1=#:result list it-index #2=#:list it fn nil 0 #3=#:mapped] 3 (#$ . 8938)])(if macro-declaration-function (funcall macro-declaration-function (quote --map-indexed) (quote (declare (debug (form form))))))
#@35 Anaphoric form of `-map-indexed'.
(defalias '--map-indexed '(macro . #[(form list) "\303\304!\305C\306	\307\nEE\310DF)\207" [r list form make-symbol "result" let --each !cons nreverse] 7 (#$ . 9336)]))
#@162 Return a new list consisting of the result of (FN index item) for each item in LIST.

In the anaphoric form `--map-indexed', the index is exposed as `it-index`.
(defalias '-map-indexed #[(fn list) "\306	\307\211\203 @\n\f\"B)\nTA\211\204\n *\237)\207" [#1=#:result list it-index #2=#:list it fn nil 0] 4 (#$ . 9549)])(if macro-declaration-function (funcall macro-declaration-function (quote --map-when) (quote (declare (debug (form form form))))))
#@32 Anaphoric form of `-map-when'.
(defalias '--map-when '(macro . #[(pred rep list) "\304\305!\306C\307	\310\311\n\312BBBEE\313DF)\207" [r list pred rep make-symbol "result" let --each !cons if (it) nreverse] 9 (#$ . 10016)]))
#@248 Return a new list where the elements in LIST that does not match the PRED function
are unchanged, and where the elements in LIST that do match the PRED function are mapped
through the REP function.

Alias: `-replace-where'

See also: `-update-at'
(defalias '-map-when #[(pred rep list) "\306	\307\211\203) @\f!\203 \f!\202 \fB)\nTA\211\204\n *\237)\207" [#1=#:result list it-index #2=#:list it pred nil 0 rep] 3 (#$ . 10252)])
(byte-code "\300\301\302\"\210\300\303\304\"\207" [defalias -replace-where -map-when --replace-where --map-when] 3)
#@104 Replace all OLD items in LIST with NEW.

Elements are compared using `equal'.

See also: `-replace-at'
(defalias '-replace #[(old new list) "\306	\307\211\203' @\211\232\203 \202 \fB)\nTA\211\204\n *\237)\207" [#1=#:result list it-index #2=#:list it old nil 0 new] 3 (#$ . 10818)])
#@94 Take a nested list L and return its contents as a single, flat list.

See also: `-flatten-n'
(defalias '-flatten #[(l) "<\203 A<\203 \301\302\"\207C\207" [l -mapcat -flatten] 3 (#$ . 11122)])
#@60 Flatten NUM levels of a nested LIST.

See also: `-flatten'
(defalias '-flatten-n #[(num list) "\303\304\305\306!\"	\nT#!\207" [it list num -last-item --iterate --mapcat -list] 5 (#$ . 11326)])
#@81 Return a new list with the concatenation of the elements in the supplied LISTS.
(defalias '-concat #[(&rest lists) "\301\302\"\207" [lists apply append] 3 (#$ . 11527)])(if macro-declaration-function (funcall macro-declaration-function (quote --mapcat) (quote (declare (debug (form form))))))
#@30 Anaphoric form of `-mapcat'.
(defalias '--mapcat '(macro . #[(form list) "\302\303\304	EE\207" [form list apply 'append --map] 5 (#$ . 11827)]))
#@104 Return the concatenation of the result of mapping FN over LIST.
Thus function FN should return a list.
(defalias '-mapcat #[(fn list) "\301\302\303\304\"\"\207" [list apply append mapcar #[(it) "	!\207" [fn it] 2]] 5 (#$ . 11980)])
(defalias '-copy 'copy-sequence "Create a shallow copy of LIST.")
#@303 Splice lists generated by FUN in place of elements matching PRED in LIST.

FUN takes the element matching PRED as input.

This function can be used as replacement for `,@' in case you
need to splice several lists at marked positions (for example
with keywords).

See also: `-splice-list', `-insert-at'
(defalias '-splice #[(pred fun list) "\306	\307\211\203J @\f!\203; \f!\211	\307\211\n\2037 \n@\211B)\nT\nA\211\n\204\" +\202? \fB)\nTA\211\204\n *\237)\207" [r list it-index #1=#:list it pred nil 0 fun new #2=#:list] 3 (#$ . 12287)])
#@30 Anaphoric form of `-splice'.
(defalias '--splice '(macro . #[(pred form list) "\303\304\305E\304\306	E\nF\207" [pred form list -splice lambda (it) (it)] 5 (#$ . 12853)]))
#@96 Splice NEW-LIST in place of elements matching PRED in LIST.

See also: `-splice', `-insert-at'
(defalias '-splice-list #[(pred new-list list) "\302\303	#\207" [pred list -splice #[(_) "\207" [new-list] 1]] 4 (#$ . 13031)])
#@35 Anaphoric form of `-splice-list'.
(defalias '--splice-list #[(pred new-list list) "\303\304\305E	\nF\207" [pred new-list list -splice-list lambda (it)] 4 (#$ . 13262)])
#@187 Make a new list from the elements of ARGS.

The last 2 members of ARGS are used as the final cons of the
result so if the final member of ARGS is not a list the result is
a dotted list.
(defalias '-cons* #[(&rest args) "\301\302\"\207" [args -reduce-r cons] 3 (#$ . 13439)])
#@151 Append ELEM to the end of the list.

This is like `cons', but operates on the end of list.

If ELEMENTS is non nil, append these to the list as well.
(defalias '-snoc #[(list elem &rest elements) "\303	C\n#\207" [list elem elements -concat] 4 (#$ . 13722)])(if macro-declaration-function (funcall macro-declaration-function (quote --first) (quote (declare (debug (form form))))))
#@29 Anaphoric form of `-first'.
(defalias '--first '(macro . #[(form list) "\303\304!\305C\306	\307D\310\n\311\312BBEFF)\207" [n list form make-symbol "needle" let --each-while not when setq (it)] 10 (#$ . 14109)]))
#@147 Return the first x in LIST where (PRED x) is non-nil, else nil.

To get the first item in the list no questions asked, use `car'.

Alias: `-find'
(defalias '-first #[(pred list) "\306	\307\310\211\2030 \2030 \f@\203 \306\202% 	!\203% )\nT\fA\211\204\f +)\207" [#1=#:needle list it-index #2=#:continue #3=#:list it nil t 0 pred] 4 (#$ . 14333)])(if macro-declaration-function (funcall macro-declaration-function (quote --last) (quote (declare (debug (form form))))))
(byte-code "\300\301\302\"\210\300\303\304\"\207" [defalias -find -first --find --first] 3)
#@28 Anaphoric form of `-last'.
(defalias '--last '(macro . #[(form list) "\303\304!\305C\306	\307\n\310\311BBEEF)\207" [n list form make-symbol "needle" let --each when setq (it)] 9 (#$ . 14913)]))
#@64 Return the last x in LIST where (PRED x) is non-nil, else nil.
(defalias '-last #[(pred list) "\306	\307\211\203  @\f!\203 \f)\nTA\211\204\n *)\207" [#1=#:needle list it-index #2=#:list it pred nil 0] 3 (#$ . 15117)])
(defalias '-first-item 'car "Return the first item of LIST, or nil on an empty list.")
#@56 Return the last item of LIST, or nil on an empty list.
(defalias '-last-item #[(list) "\301!@\207" [list last] 2 (#$ . 15440)])
#@57 Return a list of all items in list except for the last.
(defalias '-butlast #[(list) "\302	A\203 	@B	A\211\202 \237)\207" [result list nil] 3 (#$ . 15575)])(if macro-declaration-function (funcall macro-declaration-function (quote --count) (quote (declare (debug (form form))))))
#@29 Anaphoric form of `-count'.
(defalias '--count '(macro . #[(pred list) "\303\304!\305\306BC\307	\310\n\311\312DEEEF)\207" [r list pred make-symbol "result" let (0) --each when setq 1+] 10 (#$ . 15867)]))
#@66 Counts the number of items in LIST where (PRED item) is non-nil.
(defalias '-count #[(pred list) "\306	\306\211\203! @\f!\203 T)\nTA\211\204\n *)\207" [#1=#:result list it-index #2=#:list it pred 0] 3 (#$ . 16082)])
(defalias '---truthy\? #[(val) "??\207" [val] 1])(if macro-declaration-function (funcall macro-declaration-function (quote --any\?) (quote (declare (debug (form form))))))
#@28 Anaphoric form of `-any?'.
(defalias '--any\? '(macro . #[(form list) "\302\303	ED\207" [form list ---truthy\? --first] 4 (#$ . 16490)]))
#@100 Return t if (PRED x) is non-nil for any x in LIST, else nil.

Alias: `-any-p', `-some?', `-some-p'
(defalias '-any\? #[(pred list) "\306\307	\310\311\211\2031 \2031 \f@\203 \307\202& \n!\203& )\nT\fA\211\204 +)!\207" [#1=#:needle list it-index #2=#:continue #3=#:list it ---truthy\? nil t 0 pred] 5 (#$ . 16636)])(if macro-declaration-function (funcall macro-declaration-function (quote --all\?) (quote (declare (debug (form form))))))
(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)
#@28 Anaphoric form of `-all?'.
(defalias '--all\? '(macro . #[(form list) "\303\304!\305\306BC\307	\310\nEF\311DF)\207" [a list form make-symbol "all" let (t) --each-while setq ---truthy\?] 8 (#$ . 17295)]))
#@102 Return t if (PRED x) is non-nil for all x in LIST, else nil.

Alias: `-all-p', `-every?', `-every-p'
(defalias '-all\? #[(pred list) "\306	\306\307\211\203, \203, \f@\204 \310\202! \n!)\nT\fA\211\204\f +\311!)\207" [#1=#:all list it-index #2=#:continue #3=#:list it t 0 nil ---truthy\? pred] 4 (#$ . 17511)])(if macro-declaration-function (funcall macro-declaration-function (quote --none\?) (quote (declare (debug (form form))))))
(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)
#@29 Anaphoric form of `-none?'.
(defalias '--none\? '(macro . #[(form list) "\302\303D	E\207" [form list --all\? not] 3 (#$ . 18168)]))
#@76 Return t if (PRED x) is nil for all x in LIST, else nil.

Alias: `-none-p'
(defalias '-none\? #[(pred list) "\306	\306\307\211\203- \203- \f@\204 \310\202\" \n!?)\nT\fA\211\204\f +\311!)\207" [#1=#:all list it-index #2=#:continue #3=#:list it t 0 nil ---truthy\? pred] 4 (#$ . 18307)])(if macro-declaration-function (funcall macro-declaration-function (quote --only-some\?) (quote (declare (debug (form form))))))
(byte-code "\300\301\302\"\210\300\303\304\"\207" [defalias -none-p -none\? --none-p --none\?] 3)
#@34 Anaphoric form of `-only-some?'.
(defalias '--only-some\? '(macro . #[(form list) "\304\305!\304\306!\307	D\310\n\311\312	ED\313\314	\315BB\314\316BBFF\317\312	EDF*\207" [n y list form make-symbol "yes" "no" let --each-while not and if setq (t) (t) ---truthy\?] 11 (#$ . 18840)]))
#@224 Return `t` if at least one item of LIST matches PRED and at least one item of LIST does not match PRED.
Return `nil` both if all items match the predicate or if none of the items match the predicate.

Alias: `-only-some-p'
(defalias '-only-some\? #[(pred list) "\306\211\n\307\310\211\203= \f\203= @\n	\203# \203# \306\2022 \n!\2030 \307\2022 \307)TA\211\204 +\311	\205D !*\207" [#1=#:no #2=#:yes list it-index #3=#:continue #4=#:list nil t 0 ---truthy\? it pred] 4 (#$ . 19135)])
(byte-code "\300\301\302\"\210\300\303\304\"\207" [defalias -only-some-p -only-some\? --only-some-p --only-some\?] 3)
#@253 Return copy of LIST, starting from index FROM to index TO.

FROM or TO may be negative.  These values are then interpreted
modulo the length of the list.

If STEP is a number, only each STEPth item in the resulting
section is returned.  Defaults to 1.
(defalias '-slice #[(list from &optional to step) "G\306\206\n \n\f\206 \307\310W\203 \311\n\"\310W\203' \311\n\"\312\310\f\211\203r \f\203r @W\204K \306\f\202c Y\203c \311Z\f\"\310U\203c 	B)TA\211\2044 +	\237*\207" [list new-list length to step from nil 1 0 mod t it-index #1=#:continue #2=#:list it] 4 (#$ . 19761)])
#@89 Return a new list of the first N items in LIST, or all items if there are fewer than N.
(defalias '-take #[(n list) "\305	\306\nW\203 \f\203 \f@B\fA\nT\211\202 *\237)\207" [result n it #1=#:num list nil 0] 3 (#$ . 20384)])(if macro-declaration-function (funcall macro-declaration-function (quote --take-while) (quote (declare (debug (form form))))))
(defalias '-drop 'nthcdr "Return the tail of LIST without the first N items.")
#@34 Anaphoric form of `-take-while'.
(defalias '--take-while '(macro . #[(form list) "\303\304!\305C\306	\n\307\310EF\311DF)\207" [r list form make-symbol "result" let --each-while !cons it nreverse] 8 (#$ . 20831)]))
#@92 Return a new list of successive items from LIST while (PRED item) returns a non-nil value.
(defalias '-take-while #[(pred list) "\306	\307\310\211\203. \203. \f@	!\204 \306\202# B)\nT\fA\211\204\f +\237)\207" [#1=#:result list it-index #2=#:continue #3=#:list it nil t 0 pred] 4 (#$ . 21055)])(if macro-declaration-function (funcall macro-declaration-function (quote --drop-while) (quote (declare (debug (form form))))))
#@34 Anaphoric form of `-drop-while'.
(defalias '--drop-while '(macro . #[(form list) "\303\304!\305	DC\306\307\305\310\311DDC\nEE\312DEF)\207" [l list form make-symbol "list" let while and it car !cdr] 9 (#$ . 21498)]))
#@89 Return the tail of LIST starting from the first item for which (PRED item) returns nil.
(defalias '-drop-while #[(pred list) "\211\203 	@\n!)\203 	A\211\204 	)\207" [list #1=#:list it pred] 3 (#$ . 21726)])
#@94 Return a list of ((-take N LIST) (-drop N LIST)), in no more than one pass through the list.
(defalias '-split-at #[(n list) "\305	\306\nW\203 \f\203 \f@B\fA\nT\211\202 *\237\f)D\207" [result n it #1=#:num list nil 0] 3 (#$ . 21947)])
#@103 Rotate LIST N places to the right.  With N negative, rotate to the left.
The time complexity is O(n).
(defalias '-rotate #[(n list) "\302V\203 \303\304	\"\305	\"\"\207\303\306[	\"\307[	\"\"\207" [n list 0 append last butlast -drop -take] 5 (#$ . 22201)])
#@93 Return a list with X inserted into LIST at position N.

See also: `-splice', `-splice-list'
(defalias '-insert-at #[(n x list) "\304	\"\211@\n\211A@)B\244)\207" [n list split-list x -split-at] 4 (#$ . 22468)])
#@91 Return a list with element at Nth position in LIST replaced with X.

See also: `-replace'
(defalias '-replace-at #[(n x list) "\304	\"\211@\n\211A@)AB\244)\207" [n list split-list x -split-at] 4 (#$ . 22688)])
#@112 Return a list with element at Nth position in LIST replaced with `(func (nth n list))`.

See also: `-map-when'
(defalias '-update-at #[(n func list) "\305	\"\211@\n\211A@)@!\n\211A@)AB\244)\207" [n list split-list func x -split-at] 4 (#$ . 22909)])(if macro-declaration-function (funcall macro-declaration-function (quote --update-at) (quote (declare (debug (form form form))))))
#@36 Anaphoric version of `-update-at'.
(defalias '--update-at '(macro . #[(n form list) "\303\304\305	E\nF\207" [n form list -update-at lambda (it)] 5 (#$ . 23300)]))
#@104 Return a list with element at Nth position in LIST removed.

See also: `-remove-at-indices', `-remove'
(defalias '-remove-at #[(n list) "\302C	\"\207" [n list -remove-at-indices] 3 (#$ . 23471)])
#@156 Return a list whose elements are elements from LIST without
elements selected as `(nth i list)` for all i
from INDICES.

See also: `-remove-at', `-remove'
(defalias '-remove-at-indices #[(indices list) "\306\307\"\211@\310\311\312\313A#\"B\314	\315\211\203A \f@\316\"\211@\nB\211A@)A*T\fA\211\204 *\nB\317\320\n\237\"+\207" [indices diffs r it-index #1=#:list it -sort < -map 1- -zip-with - nil 0 -split-at apply -concat list split x] 8 (#$ . 23675)])(if macro-declaration-function (funcall macro-declaration-function (quote --split-with) (quote (declare (debug (form form))))))
#@34 Anaphoric form of `-split-with'.
(defalias '--split-with '(macro . #[(pred list) "\305\306!\305\307!\305\310!\311\nD	\312B\313BE\314\315\nE\311\316\317\nDDC\320\321\fD\322\323BB\324\316	E\325\nD\257EE\303\326	D\nEF+\207" [c r l list pred make-symbol "list" "result" "continue" let (nil) (t) while and it car if not setq (nil) !cons !cdr nreverse] 12 (#$ . 24288)]))
#@112 Return a list of ((-take-while PRED LIST) (-drop-while PRED LIST)), in no more than one pass through the list.
(defalias '-split-with #[(pred list) "\306\307\203' 	\203' @\f!\204 \306\202# \f\nBA)\202 \n\237+D\207" [list #1=#:continue #2=#:result #3=#:list it pred nil t] 3 (#$ . 24669)])(if macro-declaration-function (funcall macro-declaration-function (quote -split-on) (quote (declare (debug (form form))))))
#@208 Split the LIST each time ITEM is found.

Unlike `-partition-by', the ITEM is discarded from the results.
Empty lists are also removed from the result.

Comparison is done by `equal'.

See also `-split-when'
(defalias '-split-on '(macro . #[(item list) "\302\303\304\305\306EE	E\207" [item list -split-when lambda (it) equal it] 6 (#$ . 25104)]))(if macro-declaration-function (funcall macro-declaration-function (quote --split-when) (quote (declare (debug (form form))))))
#@37 Anaphoric version of `-split-when'.
(defalias '--split-when '(macro . #[(form list) "\302\303\304E	E\207" [form list -split-when lambda (it)] 4 (#$ . 25584)]))
#@255 Split the LIST on each element where FN returns non-nil.

Unlike `-partition-by', the "matched" element is discarded from
the results.  Empty lists are also removed from the result.

This function can be thought of as a generalization of
`split-string'.
(defalias '-split-when #[(fn list) "\304\211\n\203) \n@!\204 \n@B\202\" \203  \237	B\304\nA\211\204 \2032 \237	B	\237*\207" [s r list fn nil] 3 (#$ . 25752)])(if macro-declaration-function (funcall macro-declaration-function (quote --separate) (quote (declare (debug (form form))))))
#@32 Anaphoric form of `-separate'.
(defalias '--separate '(macro . #[(form list) "\304\305!\304\306!\307	D\310\n\311\312\313	E\312\313EFE\302\314	D\314DEF*\207" [n y list form make-symbol "yes" "no" let --each if !cons it nreverse] 10 (#$ . 26311)]))
#@91 Return a list of ((-filter PRED LIST) (-remove PRED LIST)), in one pass through the list.
(defalias '-separate #[(pred list) "\306\211\n\307\211\203, \f@!\203 	B\202! B)T\fA\211\204\f *	\237\237*D\207" [#1=#:no #2=#:yes list it-index #3=#:list it nil 0 pred] 3 (#$ . 26570)])
#@67 Private: Used by -partition-all-in-steps and -partition-in-steps.
(defalias '---partition-all-in-steps-reversed #[(n step list) "\305W\203\n \306\307!\210\310\311\203\" \312\f\"\nB\313\"\211\204 \n*\207" [step len result list n 1 error "Step must be a positive number, or you're looking at some juicy infinite loops." nil 0 -take -drop] 4 (#$ . 26870)])
#@142 Return a new list with the items in LIST grouped into N-sized sublists at offsets STEP apart.
The last groups may contain less than N items.
(defalias '-partition-all-in-steps #[(n step list) "\303	\n#\237\207" [n step list ---partition-all-in-steps-reversed] 4 (#$ . 27241)])
#@184 Return a new list with the items in LIST grouped into N-sized sublists at offsets STEP apart.
If there are not enough items to make the last group N-sized,
those items are discarded.
(defalias '-partition-in-steps #[(n step list) "\304	\n#\211\203 @GW\203 A\211\204\n \237)\207" [n step list result ---partition-all-in-steps-reversed] 5 (#$ . 27526)])
#@119 Return a new list with the items in LIST grouped into N-sized sublists.
The last group may contain less than N items.
(defalias '-partition-all #[(n list) "\302\211	#\207" [n list -partition-all-in-steps] 4 (#$ . 27894)])
#@162 Return a new list with the items in LIST grouped into N-sized sublists.
If there are not enough items to make the last group N-sized,
those items are discarded.
(defalias '-partition #[(n list) "\302\211	#\207" [n list -partition-in-steps] 4 (#$ . 28124)])(if macro-declaration-function (funcall macro-declaration-function (quote --partition-by) (quote (declare (debug (form form))))))
#@36 Anaphoric form of `-partition-by'.
(defalias '--partition-by '(macro . #[(form list) "\306\307!\306\310!\306\311!\306\312!\306\313!\314DC\315\316\f\317B\320\321DD\322B\nD\323DD\257\324\316\320\321DD	DD\325\326\n	E\327\330D\fE\331\332BB\331\n	E\257\327\320E\333D\257E\327\330D\fE\330\fD\257EE-\207" [l n v s r list 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 form] 17 (#$ . 28517)]))
#@79 Apply FN to each item in LIST, splitting it each time FN returns a new value.
(defalias '-partition-by #[(fn list) "\211\205H \306	@\211C!	A	\203@ 	@!\232\2045 \f\237\nB\306\fB	A*\202 \f\237\nB\211\237-)\207" [list #1=#:list #2=#:result it #3=#:sublist fn nil #4=#:value #5=#:new-value] 3 (#$ . 29040)])(if macro-declaration-function (funcall macro-declaration-function (quote --partition-by-header) (quote (declare (debug (form form))))))
#@43 Anaphoric form of `-partition-by-header'.
(defalias '--partition-by-header '(macro . #[(form list) "\306\307!\306\310!\306\311!\306\312!\306\313!\306\314!\315 DC\316\317\320B\321\322DD\f\323B!D\n\324B\325DD\257\326\317\321\322DD	!DD\327\330	E\316\n\331\332\fDE\333\f\334BB\333\n\335BB\257\333\n\336BBF\331\321\fE\337D\257E\331\332\fDE\332D\257EE.\207" [l n b h s r 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 list form] 19 (#$ . 29516)]))
#@205 Apply FN to the first item in LIST. That is the header
value. Apply FN to each item in LIST, splitting it each time FN
returns the header value, but only after seeing at least one
other value (the body).
(defalias '-partition-by-header #[(fn list) "\211\205V \306	@\211C!\306		A	\203M 	@!\n\n\232\203? 	\203B \f\237\nB\306\211	\202B \307	\fB	A*\202 \f\237\nB\211\237.)\207" [list #1=#:list #2=#:result it #3=#:sublist fn nil t #4=#:header-value #5=#:seen-body\? #6=#:new-value] 3 (#$ . 30129)])(if macro-declaration-function (funcall macro-declaration-function (quote --group-by) (quote (declare (debug (form form))))))
#@32 Anaphoric form of `-group-by'.
(defalias '--group-by '(macro . #[(form list) "\306\307!\306\310!\306\311!\306\312!\313\fDD\314\315\n\316DD\317\nD	D\320\321	EDF\322\320\323\320\324\n\325BBE\326\304	\nEEF\327\330DEFE\313\331DC\332BB\333D\257,\207" [r k v l list form make-symbol "list" "value" "key" "result" let while let* car it kv assoc if setcdr cons ((cdr kv)) push setq cdr rest ((while rest (let ((kv (car rest))) (setcdr kv (nreverse (cdr kv)))) (setq rest (cdr rest)))) nreverse] 13 (#$ . 30784)]))
#@111 Separate LIST into an alist whose keys are FN applied to the
elements of LIST.  Keys are compared by `equal'.
(defalias '-group-by #[(fn list) "\306\n\2037 \n@\211\f!\307	\"\211	\203) 		AB\241\210\2020 D	B\nA,\202 	\211\n\203S \n@\211	\211A\237\241\210)\nA\211\n\204> )	\237*\207" [list #1=#:result #2=#:list #3=#:value it fn nil assoc #4=#:key kv rest] 4 (#$ . 31313)])
#@61 Return a new list of all elements in LIST separated by SEP.
(defalias '-interpose #[(sep list) "\303	\203 	@B	A	\203  	@\nBB	A\211\204 \237)\207" [result list sep nil] 4 (#$ . 31715)])
#@72 Return a new list of the first item in each list, then the second etc.
(defalias '-interleave #[(&rest lists) "\305\306\307	\"\203- 	\310\211\203$ @\211@B)\nTA\211\204 *\311\312	\"\202 \237)\207" [result lists it-index #1=#:list it nil -none\? null 0 -map cdr] 4 (#$ . 31916)])(if macro-declaration-function (funcall macro-declaration-function (quote --zip-with) (quote (declare (debug (form form form))))))
#@107 Anaphoric form of `-zip-with'.

The elements in list1 is bound as `it`, the elements in list2 as `other`.
(defalias '--zip-with '(macro . #[(form list1 list2) "\306\307!\306\310!\306\311!\312\n\313B	D\fDE\314\315	E\312\316\317	DD\320\317DDD\321\nE\322	D\322D\257E\323\nDF+\207" [l2 l1 r list1 list2 form make-symbol "result" "list1" "list2" let (nil) while and it car other !cons !cdr nreverse] 10 (#$ . 32345)]))
#@312 Zip the two lists LIST1 and LIST2 using a function FN.  This
function is applied pairwise taking as first argument element of
LIST1 and as second argument element of LIST2 at corresponding
position.

The anaphoric form `--zip-with' binds the elements from LIST1 as `it`,
and the elements from LIST2 as `other`.
(defalias '-zip-with #[(fn list1 list2) "\306	\203( \n\203( @\n@\"\fBA\nA*\202 \f\237+\207" [list1 list2 #1=#:list2 #2=#:list1 #3=#:result other nil it fn] 3 (#$ . 32776)])
#@338 Zip LISTS together.  Group the head of each list, followed by the
second elements of each list, and so on. The lengths of the returned
groupings are equal to the length of the shortest input list.

If two lists are provided as arguments, return the groupings as a list
of cons cells. Otherwise, return the groupings as a list of lists. 
(defalias '-zip #[(&rest lists) "\302\303\304	\"\203 \305\306	\"B\305\307	\"\202 \237	G\310U\203) \305\311\"\202* )\207" [results lists nil -none\? null mapcar car cdr 2 #[(it) "@\211A@)B\207" [it x] 3]] 3 (#$ . 33286)])
#@148 Zip LISTS, with FILL-VALUE padded onto the shorter lists. The
lengths of the returned groupings are equal to the length of the
longest input list.
(defalias '-zip-fill #[(fill-value &rest lists) "\302\303\302\304	B\"\"\207" [fill-value lists apply -zip -pad] 6 (#$ . 33864)])
#@101 Return an infinite copy of LIST that will cycle through the
elements and repeat from the beginning.
(defalias '-cycle #[(list) "\302\303\"\211\211\244)\207" [list newlist -map identity] 4 (#$ . 34148)])
#@99 Appends FILL-VALUE to the end of each list in LISTS such that they
will all have the same length.
(defalias '-pad #[(fill-value &rest lists) "\303\304\"\305\306\307	\"!\310\311	\"*\207" [lists annotations n -annotate length -max -map car mapcar #[(it) "\303A\304	@Z\n\"\"\207" [it n fill-value append -repeat] 5]] 4 (#$ . 34359)])
#@127 Return a list of cons cells where each cell is FN applied to each
element of LIST paired with the unmodified element of LIST.
(defalias '-annotate #[(fn list) "\302\303	\"	\"\207" [fn list -zip -map] 4 (#$ . 34702)])(if macro-declaration-function (funcall macro-declaration-function (quote --annotate) (quote (declare (debug (form form))))))
#@35 Anaphoric version of `-annotate'.
(defalias '--annotate '(macro . #[(form list) "\302\303\304E	E\207" [form list -annotate lambda (it)] 4 (#$ . 35051)]))
#@139 Helper for `-table' and `-table-flat'.

If a list overflows, carry to the right and reset the list.

Return how many lists were re-seted.
(defalias 'dash--table-carry #[(lists restore-lists &optional re) "@?\205H \306\232?\205H 	@\240\210\211A@)\211@\210AA\240\210)A	A\f\203  \f@\237\fA\f\211A@)B\240\210)\f\307\240\210\fA\202  \207" [lists restore-lists x #1=#:--cl-pop-- re #2=#:--cl-arg1-- (nil) nil] 4 (#$ . 35213)])
#@331 Compute outer product of LISTS using function FN.

The function FN should have the same arity as the number of
supplied lists.

The outer product is computed by applying fn to all possible
combinations created by taking one element from each list in
order.  The dimension of the result is (length lists).

See also: `-table-flat'
(defalias '-table #[(fn &rest lists) "\306!\307!\310\311\312\313G\"\"\n@\2039 \314\f\315\316\"\"		@B\240\210@@\210\211@A\240\210\317	#\210)\202 \307	!@\237+\207" [lists re last-list restore-lists fn item copy-sequence last mapcar #[(it) "\300\207" [nil] 1] number-sequence 1 apply -map car dash--table-carry] 7 (#$ . 35656)])
#@509 Compute flat outer product of LISTS using function FN.

The function FN should have the same arity as the number of
supplied lists.

The outer product is computed by applying fn to all possible
combinations created by taking one element from each list in
order.  The results are flattened, ignoring the tensor structure
of the result.  This is equivalent to calling:

  (-flatten-n (1- (length lists)) (-table fn lists))

but the implementation here is much more efficient.

See also: `-flatten-n', `-table'
(defalias '-table-flat #[(fn &rest lists) "\305!\306!\307\n@\203+ \310\f\311\312\"\"	B@@\210\211@A\240\210\313\"\210\202\n 	\237+\207" [lists re last-list restore-lists fn copy-sequence last nil apply -map car dash--table-carry] 5 (#$ . 36333)])
#@214 Take a function FN and fewer than the normal arguments to FN,
and return a fn that takes a variable number of additional ARGS.
When called, the returned function calls FN with ARGS first and
then additional args.
(defalias '-partial #[(fn &rest args) "\302\303	#\207" [fn args apply apply-partially] 4 (#$ . 37105)])
#@135 Return the index of the first element in the given LIST which
is equal to the query element ELEM, or nil if there is no
such element.
(defalias '-elem-index #[(elem list) "\302	\"@\207" [elem list -elem-indices] 3 (#$ . 37430)])
#@97 Return the indices of all elements in LIST equal to the query
element ELEM, in ascending order.
(defalias '-elem-indices #[(elem list) "\302\303\304\"	\"\207" [elem list -find-indices -partial equal] 4 (#$ . 37666)])
#@95 Return the indices of all elements in LIST satisfying the
predicate PRED, in ascending order.
(defalias '-find-indices #[(pred list) "\306\307\310\311\n\306\211\203( \f@\n!\205 C	B)T\fA\211\204 *	\237)\")\207" [i #1=#:result list it-index #2=#:list it 0 apply append nil pred] 5 (#$ . 37890)])(if macro-declaration-function (funcall macro-declaration-function (quote --find-indices) (quote (declare (debug (form form))))))
#@39 Anaphoric version of `-find-indices'.
(defalias '--find-indices '(macro . #[(form list) "\302\303\304E	E\207" [form list -find-indices lambda (it)] 4 (#$ . 38333)]))
#@150 Take a predicate PRED and a LIST and return the index of the
first element in the list satisfying the predicate, or nil if
there is no such element.
(defalias '-find-index #[(pred list) "\302	\"@\207" [pred list -find-indices] 3 (#$ . 38507)])(if macro-declaration-function (funcall macro-declaration-function (quote --find-index) (quote (declare (debug (form form))))))
#@37 Anaphoric version of `-find-index'.
(defalias '--find-index '(macro . #[(form list) "\302\303\304E	E\207" [form list -find-index lambda (it)] 4 (#$ . 38885)]))
#@149 Take a predicate PRED and a LIST and return the index of the
last element in the list satisfying the predicate, or nil if
there is no such element.
(defalias '-find-last-index #[(pred list) "\302\303	\"!\207" [pred list -last-item -find-indices] 4 (#$ . 39053)])
#@42 Anaphoric version of `-find-last-index'.
(defalias '--find-last-index '(macro . #[(form list) "\302\303\304E	E\207" [form list -find-last-index lambda (it)] 4 (#$ . 39323)]))
#@104 Return a list whose elements are elements from LIST selected
as `(nth i list)` for all i from INDICES.
(defalias '-select-by-indices #[(indices list) "\306	\307\211\203 @\2118B)\nTA\211\204\n *\237)\207" [r indices it-index #1=#:list it list nil 0] 3 (#$ . 39506)])
#@219 Thread the expr through the forms. Insert X as the second item
in the first form, making a list of it if it is not a list
already. If there are more forms, insert the first form as the
second item in second form, etc.
(defalias '-> '(macro . #[(x &optional form &rest more) "\204 	\207\n\204 <\203 @	ABB\207	D\207\303\211	E\nBB\207" [form x more ->] 4 (#$ . 39792)]))
#@215 Thread the expr through the forms. Insert X as the last item
in the first form, making a list of it if it is not a list
already. If there are more forms, insert the first form as the
last item in second form, etc.
(defalias '->> '(macro . #[(x form &rest more) "\204 	<\203 	@\303	A\nC\"B\207	\nD\207\304\211\n	EBB\207" [more form x append ->>] 4 (#$ . 40176)]))
#@213 Thread the expr through the forms. Insert X at the position
signified by the token `it' in the first form. If there are more
forms, insert the first form at the position signified by `it' in
in second form, etc.
(defalias '--> '(macro . #[(x form &rest more) "\204: 	<\2035 \306	\307\211\2030 \f@\211\305=\203! 	\202\" \nB)T\fA\211\204 *\n\237)\207		D\207\310\211		EBB\207" [more form #1=#:result it-index #2=#:list it nil 0 --> x] 5 (#$ . 40550)]))
(byte-code "\300\301\302\303#\210\300\304\302\303#\210\300\305\302\303#\207" [put -> lisp-indent-function 1 ->> -->] 4)
#@154 Grade elements of LIST using COMPARATOR relation, yielding a
permutation vector such that applying this permutation to LIST
sorts it in ascending order.
(defalias '-grade-up #[(comparator list) "\306\307\310\311D\312BBE\313\314\315	\316\317\211\203. @\211\fB\nB)\fTA\211\204 *\n\237)\"\")\207" [comparator comp #1=#:result list it-index #2=#:list lambda (it other) funcall quote ((car it) (car other)) -map cdr -sort nil 0 it] 7 (#$ . 41142)])
#@155 Grade elements of LIST using COMPARATOR relation, yielding a
permutation vector such that applying this permutation to LIST
sorts it in descending order.
(defalias '-grade-down #[(comparator list) "\306\307\310\311D\312BBE\313\314\315	\316\317\211\203. @\211\fB\nB)\fTA\211\204 *\n\237)\"\")\207" [comparator comp #1=#:result list it-index #2=#:list lambda (it other) funcall quote ((car other) (car it)) -map cdr -sort nil 0 it] 7 (#$ . 41607)])(if macro-declaration-function (funcall macro-declaration-function (quote -when-let) (quote (declare (debug ((symbolp form) body)) (indent 1)))))
#@99 If VAL evaluates to non-nil, bind it to VAR and execute body.
VAR-VAL should be a (VAR VAL) pair.
(defalias '-when-let '(macro . #[(var-val &rest body) "@\211A@)\305\nDC\306\fBBE*\207" [var-val x val var body let when] 6 (#$ . 42219)]))(if macro-declaration-function (funcall macro-declaration-function (quote -when-let*) (quote (declare (debug ((&rest (symbolp form)) body)) (indent 1)))))
#@172 If all VALS evaluate to true, bind them to their corresponding
VARS and execute body. VARS-VALS should be a list of (VAR VAL)
pairs (corresponding to bindings of `let*').
(defalias '-when-let* '(macro . #[(vars-vals &rest body) "G\302U\203 \303@	BB\207\303@\304A	BBE\207" [vars-vals body 1 -when-let -when-let*] 5 (#$ . 42624)]))(if macro-declaration-function (funcall macro-declaration-function (quote --when-let) (quote (declare (debug (form body)) (indent 1)))))
#@64 If VAL evaluates to non-nil, bind it to `it' and execute
body.
(defalias '--when-let '(macro . #[(val &rest body) "\302\303DC\304\303	BBE\207" [val body let it when] 5 (#$ . 43101)]))(if macro-declaration-function (funcall macro-declaration-function (quote -if-let) (quote (declare (debug ((symbolp form) form body)) (indent 2)))))
#@113 If VAL evaluates to non-nil, bind it to VAR and do THEN,
otherwise do ELSE. VAR-VAL should be a (VAR VAL) pair.
(defalias '-if-let '(macro . #[(var-val then &rest else) "@\211A@)\306\nDC\307\fBBBE*\207" [var-val x val var then else let if] 7 (#$ . 43441)]))(if macro-declaration-function (funcall macro-declaration-function (quote -if-let*) (quote (declare (debug ((&rest (symbolp form)) form body)) (indent 2)))))
#@190 If all VALS evaluate to true, bind them to their corresponding
VARS and do THEN, otherwise do ELSE. VARS-VALS should be a list
of (VAR VAL) pairs (corresponding to the bindings of `let*').
(defalias '-if-let* '(macro . #[(vars-vals then &rest else) "@AG\305U\203 \306\n\fBBB\202$ \306\n\307	\fBBB\fBBB*\207" [vars-vals rest first-pair then else 1 -if-let -if-let*] 6 (#$ . 43871)]))(if macro-declaration-function (funcall macro-declaration-function (quote --if-let) (quote (declare (debug (form form body)) (indent 2)))))
#@78 If VAL evaluates to non-nil, bind it to `it' and do THEN,
otherwise do ELSE.
(defalias '--if-let '(macro . #[(val then &rest else) "\303\304DC\305\304	\nBBBE\207" [val then else let it if] 6 (#$ . 44407)]))
#@149 Return a new list with all duplicates removed.
The test for equality is done with `equal',
or with `-compare-fn' if that's non-nil.

Alias: `-uniq'
(defalias '-distinct #[(list) "\305	\306\211\203# @\307\f\"\204 \fB)\nTA\211\204\n *\237)\207" [result list it-index #1=#:list it nil 0 -contains\?] 4 (#$ . 44622)])
(defalias '-uniq '-distinct)
#@182 Return a new list containing the elements of LIST1 and elements of LIST2 that are not in LIST1.
The test for equality is done with `equal',
or with `-compare-fn' if that's non-nil.
(defalias '-union #[(list list2) "\306	\307\211\203 @\211B)\nTA\211\204\n *\307\211	\203B 	@\310\f\"\2045 \fB)\nT	A\211	\204& *\237)\207" [result list it-index #1=#:list it list2 nil 0 -contains\? #2=#:list] 4 (#$ . 44985)])
#@174 Return a new list containing only the elements that are members of both LIST and LIST2.
The test for equality is done with `equal',
or with `-compare-fn' if that's non-nil.
(defalias '-intersection #[(list list2) "\306	\307\211\203# @\310\f\"\203 \fB)\nTA\211\204\n *\237)\207" [#1=#:result list it-index #2=#:list it list2 nil 0 -contains\?] 4 (#$ . 45421)])
#@157 Return a new list with only the members of LIST that are not in LIST2.
The test for equality is done with `equal',
or with `-compare-fn' if that's non-nil.
(defalias '-difference #[(list list2) "\306	\307\211\203# @\310\f\"\204 \fB)\nTA\211\204\n *\237)\207" [#1=#:result list it-index #2=#:list it list2 nil 0 -contains\?] 4 (#$ . 45801)])
#@187 Tests for equality use this function or `equal' if this is nil.
It should only be set using dynamic scope with a let, like:

  (let ((-compare-fn =)) (-union numbers1 numbers2 numbers3)
(defvar -compare-fn nil (#$ . 46162))
#@150 Return non-nil if LIST contains ELEMENT.

The test for equality is done with `equal', or with `-compare-fn'
if that's non-nil.

Alias: `-contains-p'
(defalias '-contains\? #[(list element) "\204\n 	\n\235\202: \304=\203 	\n>\202: \305=\203# \306	\n\"\202: \n\211\2038 	@\"\2048 A\211\204) )??\207" [-compare-fn element list lst eq eql memql] 4 (#$ . 46393)])
(defalias '-contains-p '-contains\?)
#@132 Return true if LIST and LIST2 has the same items.

The order of the elements in the lists does not matter.

Alias: `-same-items-p'
(defalias '-same-items\? #[(list list2) "G	G\211\nU\205 \304	\"GU*\207" [list list2 length-b length-a -intersection] 5 (#$ . 46806)])
(defalias '-same-items-p '-same-items\?)
#@68 Return non-nil if PREFIX is prefix of LIST.

Alias: `-is-prefix-p'
(defalias '-is-prefix\? #[(prefix list) "\306\307\211\203+ \n\203+ @@\f\232\204 \310\202  A)	TA\211\204\n +?\207" [list it-index #1=#:continue #2=#:list it prefix t 0 nil] 4 (#$ . 47124)])
#@68 Return non-nil if SUFFIX is suffix of LIST.

Alias: `-is-suffix-p'
(defalias '-is-suffix\? #[(suffix list) "\302\237	\237\"\207" [suffix list -is-prefix\?] 3 (#$ . 47401)])
#@101 Return non-nil if INFIX is infix of LIST.

This operation runs in O(n^2) time

Alias: `-is-infix-p'
(defalias '-is-infix\? #[(infix list) "\303\204 	\203 \304\n	\"	A\202 )\207" [done list infix nil -is-prefix\?] 3 (#$ . 47582)])
(byte-code "\300\301\302\"\210\300\303\304\"\210\300\305\306\"\207" [defalias -is-prefix-p -is-prefix\? -is-suffix-p -is-suffix\? -is-infix-p -is-infix\?] 3)
#@246 Sort LIST, stably, comparing elements using COMPARATOR.
Return the sorted list.  LIST is NOT modified by side effects.
COMPARATOR is called with two elements of LIST, and should return non-nil
if the first element should sort before the second.
(defalias '-sort #[(comparator list) "\302\303!	\"\207" [list comparator sort copy-sequence] 3 (#$ . 47984)])(if macro-declaration-function (funcall macro-declaration-function (quote --sort) (quote (declare (debug (form form))))))
#@28 Anaphoric form of `-sort'.
(defalias '--sort '(macro . #[(form list) "\302\303\304E	E\207" [form list -sort lambda (it other)] 4 (#$ . 48467)]))
#@134 Return a list with ARGS.

If first item of ARGS is already a list, simply return ARGS.  If
not, return a list with ARGS as elements.
(defalias '-list #[(&rest args) "@\211<\203\f 	\202 )\207" [args arg] 2 (#$ . 48620)])
#@72 Return a list with X repeated N times.
Return nil if N is less than 1.
(defalias '-repeat #[(n x) "\305	\306\nW\203 \fB\nT\211\202 *)\207" [ret n it #1=#:num x nil 0] 3 (#$ . 48850)])
#@25 Return the sum of LIST.
(defalias '-sum #[(list) "\301\302\"\207" [list apply +] 3 (#$ . 49050)])
#@29 Return the product of LIST.
(defalias '-product #[(list) "\301\302\"\207" [list apply *] 3 (#$ . 49155)])
#@59 Return the largest value from LIST of numbers or markers.
(defalias '-max #[(list) "\301\302\"\207" [list apply max] 3 (#$ . 49268)])
#@60 Return the smallest value from LIST of numbers or markers.
(defalias '-min #[(list) "\301\302\"\207" [list apply min] 3 (#$ . 49409)])
#@203 Take a comparison function COMPARATOR and a LIST and return
the greatest element of the list by the comparison function.

See also combinator `-on' which can transform the values before
comparing them.
(defalias '-max-by #[(comparator list) "\211\2034 	@	A\306\211\203. \f@\n\"\203! \202\" \n)T\fA\211\204 *\n)\202F \307\211\n\"\203D \202E \n*)\207" [list #1=#:list-value acc it-index #2=#:list it 0 nil comparator] 4 (#$ . 49552)])
#@200 Take a comparison function COMPARATOR and a LIST and return
the least element of the list by the comparison function.

See also combinator `-on' which can transform the values before
comparing them.
(defalias '-min-by #[(comparator list) "\211\2034 	@	A\306\211\203. \f@\n\"\203! \n\202\" )T\fA\211\204 *\n)\202F \307\211\n\"\203D \n\202E *)\207" [list #1=#:list-value acc it-index #2=#:list it 0 nil comparator] 4 (#$ . 50013)])(if macro-declaration-function (funcall macro-declaration-function (quote --max-by) (quote (declare (debug (form form))))))
#@101 Anaphoric version of `-max-by'.

The items for the comparator form are exposed as "it" and "other".
(defalias '--max-by '(macro . #[(form list) "\302\303\304E	E\207" [form list -max-by lambda (it other)] 4 (#$ . 50594)]))(if macro-declaration-function (funcall macro-declaration-function (quote --min-by) (quote (declare (debug (form form))))))
#@101 Anaphoric version of `-min-by'.

The items for the comparator form are exposed as "it" and "other".
(defalias '--min-by '(macro . #[(form list) "\302\303\304E	E\207" [form list -min-by lambda (it other)] 4 (#$ . 50947)]))
#@165 Return a list of iterated applications of FUN to INIT.

This means a list of form:

  (init (fun init) (fun (fun init)) ...)

N is the length of the returned list.
(defalias '-iterate #[(fun init n) "\306U?\205' 	CS\306\fW\203# \n@!\nBT\211\202 *\n\237)\207" [n init r it #1=#:num fun 0] 3 (#$ . 51177)])(if macro-declaration-function (funcall macro-declaration-function (quote --iterate) (quote (declare (debug (form form form))))))
#@34 Anaphoric version of `-iterate'.
(defalias '--iterate '(macro . #[(form init n) "\303\304\305E	\nF\207" [form init n -iterate lambda (it)] 4 (#$ . 51628)]))
#@347 Build a list from SEED using FUN.

This is "dual" operation to `-reduce-r': while -reduce-r
consumes a list to produce a single value, `-unfold' takes a
seed value and builds a (potentially infinite!) list.

FUN should return `nil' to stop the generating process, or a
cons (A . B), where A will be prepended to the result and B is
the new seed.
(defalias '-unfold #[(fun seed) "	!\304\211\203 @\nBA!\211\204\n \n\237*\207" [fun seed r last nil] 3 (#$ . 51793)])(if macro-declaration-function (funcall macro-declaration-function (quote --unfold) (quote (declare (debug (form form))))))
#@33 Anaphoric version of `-unfold'.
(defalias '--unfold '(macro . #[(form seed) "\302\303\304E	E\207" [form seed -unfold lambda (it)] 4 (#$ . 52394)]))
#@81 Return non-nil if CON is true cons pair.
That is (A . B) where B is not a list.
(defalias '-cons-pair\? #[(con) "<\205	 A<?\207" [con] 1 (#$ . 52549)])
#@78 Convert a cons pair to a list with `car' and `cdr' of the pair respectively.
(defalias '-cons-to-list #[(con) "@AD\207" [con] 2 (#$ . 52709)])
#@182 Convert a value to a list.

If the value is a cons pair, make a list with two elements, `car'
and `cdr' of the pair respectively.

If the value is anything else, wrap it in a list.
(defalias '-value-to-list #[(val) "\301!\203\n \302!\207C\207" [val -cons-pair\? -cons-to-list] 2 (#$ . 52861)])
#@391 Apply FN to each element of TREE, and make a list of the results.
If elements of TREE are lists themselves, apply FN recursively to
elements of these nested lists.

Then reduce the resulting lists using FOLDER and initial value
INIT-VALUE. See `-reduce-r-from'.

This is the same as calling `-tree-reduce-from' after `-tree-map'
but is twice as fast as it only traverse the structure once.
(defalias '-tree-mapreduce-from #[(fn folder init-value tree) "\204 \304\207\305!\203 	!\207<\203 \306\n\307\310\"#\207	!\207" [tree fn folder init-value nil -cons-pair\? -reduce-r-from mapcar #[(x) "\304	\n$\207" [fn folder init-value x -tree-mapreduce-from] 5]] 6 (#$ . 53165)])(if macro-declaration-function (funcall macro-declaration-function (quote --tree-mapreduce-from) (quote (declare (debug (form form form form))))))
#@43 Anaphoric form of `-tree-mapreduce-from'.
(defalias '--tree-mapreduce-from '(macro . #[(form folder init-value tree) "\304\305\306E\305\307	E\n\257\207" [form folder init-value tree -tree-mapreduce-from lambda (it) (it acc)] 5 (#$ . 54000)]))
#@386 Apply FN to each element of TREE, and make a list of the results.
If elements of TREE are lists themselves, apply FN recursively to
elements of these nested lists.

Then reduce the resulting lists using FOLDER and initial value
INIT-VALUE. See `-reduce-r-from'.

This is the same as calling `-tree-reduce' after `-tree-map'
but is twice as fast as it only traverse the structure once.
(defalias '-tree-mapreduce #[(fn folder tree) "\204 \303\207\304!\203 	!\207<\203 \305\n\306\307\"\"\207	!\207" [tree fn folder nil -cons-pair\? -reduce-r mapcar #[(x) "\303	\n#\207" [fn folder x -tree-mapreduce] 4]] 5 (#$ . 54253)])(if macro-declaration-function (funcall macro-declaration-function (quote --tree-mapreduce) (quote (declare (debug (form form form))))))
#@38 Anaphoric form of `-tree-mapreduce'.
(defalias '--tree-mapreduce '(macro . #[(form folder tree) "\303\304\305E\304\306	E\nF\207" [form folder tree -tree-mapreduce lambda (it) (it acc)] 5 (#$ . 55024)]))
#@71 Apply FN to each element of TREE while preserving the tree structure.
(defalias '-tree-map #[(fn tree) "\204 \302\207\303!\203 	!\207<\203 \304\305\"\207	!\207" [tree fn nil -cons-pair\? mapcar #[(x) "\302	\"\207" [fn x -tree-map] 3]] 3 (#$ . 55234)])(if macro-declaration-function (funcall macro-declaration-function (quote --tree-map) (quote (declare (debug (form form))))))
#@32 Anaphoric form of `-tree-map'.
(defalias '--tree-map '(macro . #[(form tree) "\302\303\304E	E\207" [form tree -tree-map lambda (it)] 4 (#$ . 55627)]))
#@321 Use FN to reduce elements of list TREE.
If elements of TREE are lists themselves, apply the reduction recursively.

FN is first applied to INIT-VALUE and first element of the list,
then on this result and second element from the list etc.

The initial value is ignored on cons pairs as they always contain
two elements.
(defalias '-tree-reduce-from #[(fn init-value tree) "\204 \303\207\304!\203 \207<\203 \305	\n\306\307\"#\207\207" [tree fn init-value nil -cons-pair\? -reduce-r-from mapcar #[(x) "\303	\n#\207" [fn init-value x -tree-reduce-from] 4]] 6 (#$ . 55786)])(if macro-declaration-function (funcall macro-declaration-function (quote --tree-reduce-from) (quote (declare (debug (form form form))))))
#@40 Anaphoric form of `-tree-reduce-from'.
(defalias '--tree-reduce-from '(macro . #[(form init-value tree) "\303\304\305E	\nF\207" [form init-value tree -tree-reduce-from lambda (it acc)] 4 (#$ . 56511)]))
#@318 Use FN to reduce elements of list TREE.
If elements of TREE are lists themselves, apply the reduction recursively.

FN is first applied to first element of the list and second
element, then on this result and third element from the list etc.

See `-reduce-r' for how exactly are lists of zero or one element handled.
(defalias '-tree-reduce #[(fn tree) "\204 \302\207\303!\203 \207<\203 \304	\305\306\"\"\207\207" [tree fn nil -cons-pair\? -reduce-r mapcar #[(x) "\302	\"\207" [fn x -tree-reduce] 3]] 5 (#$ . 56722)])(if macro-declaration-function (funcall macro-declaration-function (quote --tree-reduce) (quote (declare (debug (form form))))))
#@35 Anaphoric form of `-tree-reduce'.
(defalias '--tree-reduce '(macro . #[(form tree) "\302\303\304E	E\207" [form tree -tree-reduce lambda (it acc)] 4 (#$ . 57384)]))
#@187 Call FUN on each node of TREE that satisfies PRED.

If PRED returns nil, continue descending down this node.  If PRED
returns non-nil, apply FUN to this node and do not descend
further.
(defalias '-tree-map-nodes #[(pred fun tree) "	!\203\n \n	!\207	<\203 \303\304	\"\207	\207" [pred tree fun -map #[(x) "\303	\n#\207" [pred fun x -tree-map-nodes] 4]] 3 (#$ . 57556)])
#@38 Anaphoric form of `-tree-map-nodes'.
(defalias '--tree-map-nodes '(macro . #[(pred form tree) "\303\304\305E\304\306	E\nF\207" [pred form tree -tree-map-nodes lambda (it) (it)] 5 (#$ . 57934)]))
#@336 Return a sequence of the nodes in TREE, in depth-first search order.

BRANCH is a predicate of one argument that returns non-nil if the
passed argument is a branch, that is, a node that can have children.

CHILDREN is a function of one argument that returns the children
of the passed branch node.

Non-branch nodes are simply copied.
(defalias '-tree-seq #[(branch children tree) "	!\205 \303\304\n!\"B\207" [tree branch children -mapcat #[(x) "\303	\n#\207" [branch children x -tree-seq] 4]] 5 (#$ . 58137)])
#@32 Anaphoric form of `-tree-seq'.
(defalias '--tree-seq '(macro . #[(branch children tree) "\303\304\305E\304\306	E\nF\207" [branch children tree -tree-seq lambda (it) (it)] 5 (#$ . 58659)]))
#@194 Create a deep copy of LIST.
The new list has the same elements and structure but all cons are
replaced with new ones.  This is useful when you need to clone a
structure such as plist or alist.
(defalias '-clone #[(list) "\301\302\"\207" [list -tree-map identity] 3 (#$ . 58856)])
#@69 Add syntax highlighting to dash functions, macros and magic values.
(defalias 'dash-enable-font-lock #[nil "\300\301\302\"\207" [eval-after-load "lisp-mode" (progn (let ((new-keywords '("-each" "--each" "-each-while" "--each-while" "-dotimes" "--dotimes" "-map" "--map" "-reduce-from" "--reduce-from" "-reduce" "--reduce" "-reduce-r-from" "--reduce-r-from" "-reduce-r" "--reduce-r" "-filter" "--filter" "-select" "--select" "-remove" "--remove" "-reject" "--reject" "-keep" "--keep" "-map-indexed" "--map-indexed" "-splice" "--splice" "-splice-list" "--splice-list" "-map-when" "--map-when" "-replace-where" "--replace-where" "-replace" "-flatten" "-flatten-n" "-concat" "-mapcat" "--mapcat" "-copy" "-cons*" "-snoc" "-first" "--first" "-find" "--find" "-last" "--last" "-first-item" "-last-item" "-butlast" "-count" "--count" "-any?" "--any?" "-some?" "--some?" "-any-p" "--any-p" "-some-p" "--some-p" "-all?" "--all?" "-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" "-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-by" "--partition-by" "-partition-by-header" "--partition-by-header" "-group-by" "--group-by" "-interpose" "-interleave" "-zip-with" "--zip-with" "-zip" "-zip-fill" "-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" "-grade-up" "-grade-down" "->" "->>" "-->" "-when-let" "-when-let*" "--when-let" "-if-let" "-if-let*" "--if-let" "-distinct" "-uniq" "-union" "-intersection" "-difference" "-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" "-product" "-max" "-min" "-max-by" "--max-by" "-min-by" "--min-by" "-iterate" "--iterate" "-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" "-prodfn")) (special-variables '("it" "it-index" "acc" "other"))) (font-lock-add-keywords 'emacs-lisp-mode `((,(concat "\\_<" (regexp-opt special-variables 'paren) "\\_>") 1 font-lock-variable-name-face)) 'append) (font-lock-add-keywords 'emacs-lisp-mode `((,(concat "(\\s-*" (regexp-opt new-keywords 'paren) "\\_>") 1 font-lock-keyword-face)) 'append)) (--each (buffer-list) (with-current-buffer it (when (and (eq major-mode 'emacs-lisp-mode) (boundp 'font-lock-mode) font-lock-mode) (font-lock-refresh-defaults)))))] 3 (#$ . 59143)])
(provide 'dash)