;ELC ;;; Compiled ;;; in Emacs version 28.0.50 ;;; with all optimizations. (custom-declare-group 'dash nil "Customize group for Dash, a modern list library." :group 'extensions :group 'lisp :prefix "dash-") #@64 Destructive: Set CDR to the cons of CAR and CDR. (fn CAR CDR) (defalias '!cons '(macro . #[514 "\300\301EE\207" [setq cons] 7 (#$ . 219)])) (put '!cons 'edebug-form-spec '(form symbolp)) #@54 Destructive: Set LIST to the cdr of LIST. (fn LIST) (defalias '!cdr '(macro . #[257 "\300\301DE\207" [setq cdr] 5 (#$ . 416)])) (put '!cdr 'edebug-form-spec '(symbolp)) #@234 Evaluate BODY for each element of LIST and return nil. Each element of LIST in turn is bound to `it' and its index within LIST to `it-index' before evaluating BODY. This is the anaphoric counterpart to `-each'. (fn LIST &rest BODY) (defalias '--each '(macro . #[385 "\300\301!\300\302!\303D\304B\305BB\306\307\310\311\312 D\313 \211\314\fD\257BBBF\207" [make-symbol "list" "i" let (0) (it it-index) (ignore it it-index) while setq it pop it-index 1+] 17 (#$ . 595)])) (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) #@217 Call FN on each element of LIST. Return nil; this function is intended for side effects. Its anaphoric counterpart is `--each'. For access to the current element's index in LIST, see `-each-indexed'. (fn LIST FN) (defalias '-each #[514 "\300\301\"\210\207" [nil mapc] 6 (#$ . 1222)]) (byte-code "\300\301\302\303#\304\305\306\"\207" [function-put -each lisp-indent-function 1 defalias --each-indexed --each] 4) #@203 Call FN on each index and element of LIST. For each ITEM at INDEX in LIST, call (funcall FN INDEX ITEM). Return nil; this function is intended for side effects. See also: `-map-indexed'. (fn LIST FN) (defalias '-each-indexed #[514 "\300\301\211\205\211A\262\242\262\262T\262\"\210\202\207" [0 nil] 9 (#$ . 1645)]) (byte-code "\300\301\302\303#\300\207" [function-put -each-indexed lisp-indent-function 1] 4) #@392 Evaluate BODY for each item in LIST, while PRED evaluates to non-nil. Each element of LIST in turn is bound to `it' and its index within LIST to `it-index' before evaluating PRED or BODY. Once an element is reached for which PRED evaluates to nil, no further BODY is evaluated. The return value is always nil. This is the anaphoric counterpart to `-each-while'. (fn LIST PRED &rest BODY) (defalias '--each-while '(macro . #[642 "\300\301!\300\302!\300\303!\304D\305B\306BBB\307\310\311\312\313 D\314\n\315 \257 F\312\314\315\n\211\316 D\257 BBBF\207" [make-symbol "list" "i" "elt" let (0) (it it-index) (ignore it it-index) while and setq pop it it-index 1+] 19 (#$ . 2078)])) (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) #@259 Call FN on each ITEM in LIST, while (PRED ITEM) is non-nil. Once an ITEM is reached for which PRED returns nil, FN is no longer called. Return nil; this function is intended for side effects. Its anaphoric counterpart is `--each-while'. (fn LIST PRED FN) (defalias '-each-while #[771 "\300\301\211\211\2053\211A\262\242\262\262\211\262\2053!\2053\262\262T\262!\210\202\207" [0 nil] 10 (#$ . 2937)]) (byte-code "\300\301\302\303#\300\207" [function-put -each-while lisp-indent-function 2] 4) #@294 Evaluate BODY for each element of LIST in reversed order. Each element of LIST in turn, starting at its end, is bound to `it' and its index within LIST to `it-index' before evaluating BODY. The return value is always nil. This is the anaphoric counterpart to `-each-r'. (fn LIST &rest BODY) (defalias '--each-r '(macro . #[385 "\300\301!\300\302!\303\304DD\305DD\306BB\307\310\311\312BB\313\314D\315 \316\317  E\257BBBF\207" [make-symbol "vector" "i" let* vconcat length (it it-index) (ignore it it-index) while > (0) setq 1- it-index it aref] 18 (#$ . 3463)])) (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) #@164 Call FN on each element of LIST in reversed order. Return nil; this function is intended for side effects. Its anaphoric counterpart is `--each-r'. (fn LIST FN) (defalias '-each-r #[514 "\300!\211G\301\211\302V\205 S\262\262H\262!\210\202\207" [vconcat nil 0] 8 (#$ . 4193)]) #@417 Eval BODY for each item in reversed LIST, while PRED evals to non-nil. Each element of LIST in turn, starting at its end, is bound to `it' and its index within LIST to `it-index' before evaluating PRED or BODY. Once an element is reached for which PRED evaluates to nil, no further BODY is evaluated. The return value is always nil. This is the anaphoric counterpart to `-each-r-while'. (fn LIST PRED &rest BODY) (defalias '--each-r-while '(macro . #[642 "\300\301!\300\302!\300\303!\304\305DD\306DD\307BBB\310\311\312\313\314BB\315\316\nD\317 \257\315\320\f\fE\321 \257\f\257\315\317\321 \257 BBBF\207" [make-symbol "vector" "i" "elt" let* vconcat length (it it-index) (ignore it it-index) while when > (0) setq 1- it-index aref it] 18 (#$ . 4492)])) (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) #@270 Call FN on each ITEM in reversed LIST, while (PRED ITEM) is non-nil. Once an ITEM is reached for which PRED returns nil, FN is no longer called. Return nil; this function is intended for side effects. Its anaphoric counterpart is `--each-r-while'. (fn LIST PRED FN) (defalias '-each-r-while #[771 "\300!\211G\301\211\211\302V\2051S\262\262H\262\262!\2051\262\262!\210\202\207" [vconcat nil 0] 10 (#$ . 5435)]) #@305 Evaluate BODY NUM times, presumably for side effects. BODY is evaluated with the local variable `it' temporarily bound to successive integers running from 0, inclusive, to NUM, exclusive. BODY is not evaluated if NUM is less than 1. This is the anaphoric counterpart to `-dotimes'. (fn NUM &rest BODY) (defalias '--dotimes '(macro . #[385 "\300\301!\300\302!\303D\304B\305BB\306\307\310E\311\312\211\313\nD\257BBBF\207" [make-symbol "num" "i" let (0) (it) (ignore it) while < setq it 1+] 15 (#$ . 5879)])) (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) #@263 Call FN NUM times, presumably for side effects. FN is called with a single argument on successive integers running from 0, inclusive, to NUM, exclusive. FN is not called if NUM is less than 1. This function's anaphoric counterpart is `--dotimes'. (fn NUM FN) (defalias '-dotimes #[514 "\300\301W\205\262T\262!\210\202\207" [0 nil] 7 (#$ . 6550)]) (byte-code "\300\301\302\303#\300\207" [function-put -dotimes lisp-indent-function 1] 4) #@128 Apply FN to each item in LIST and return the list of results. This function's anaphoric counterpart is `--map'. (fn FN LIST) (defalias '-map #[514 "\300\"\207" [mapcar] 5 (#$ . 7009)]) #@196 Eval FORM for each item in LIST and return the list of results. Each element of LIST in turn is bound to `it' before evaluating FORM. This is the anaphoric counterpart to `-map'. (fn FORM LIST) (defalias '--map '(macro . #[514 "\300\301\302\303FE\207" [mapcar lambda (it) (ignore it)] 7 (#$ . 7205)])) (put '--map 'edebug-form-spec '(def-form form)) #@569 Accumulate a value by evaluating FORM across LIST. This macro is like `--each' (which see), but it additionally provides an accumulator variable `acc' which it successively binds to the result of evaluating FORM for the current LIST element before processing the next element. For the first element, `acc' is initialized with the result of evaluating INIT. The return value is the resulting value of `acc'. If LIST is empty, FORM is not evaluated, and the return value is the result of INIT. This is the anaphoric counterpart to `-reduce-from'. (fn FORM INIT LIST) (defalias '--reduce-from '(macro . #[771 "\300\301DC\302\303\301EE\304BBB\207" [let acc --each setq (acc)] 10 (#$ . 7565)])) (put '--reduce-from 'edebug-form-spec '(form form form)) #@373 Reduce the function FN across LIST, starting with INIT. Return the result of applying FN to INIT and the first element of LIST, then applying FN to that result and the second element, etc. If LIST is empty, return INIT without calling FN. This function's anaphoric counterpart is `--reduce-from'. For other folds, see also `-reduce' and `-reduce-r'. (fn FN INIT LIST) (defalias '-reduce-from #[771 "\300\301\211\203\"\211A\262\242\262\262T\262\"\262\202\266\207" [0 nil] 11 (#$ . 8326)]) #@364 Accumulate a value by evaluating FORM across LIST. This macro is like `--reduce-from' (which see), except the first element of LIST is taken as INIT. Thus if LIST contains a single item, it is returned without evaluating FORM. If LIST is empty, FORM is evaluated with `it' and `acc' bound to nil. This is the anaphoric counterpart to `-reduce'. (fn FORM LIST) (defalias '--reduce '(macro . #[514 "\300\301!\302DC\303\304\305D\306DF\302\307\310\nFFE\207" [make-symbol "list-value" let if --reduce-from car cdr ((acc nil) (it nil)) (ignore acc it)] 12 (#$ . 8844)])) (put '--reduce 'edebug-form-spec '(form form)) #@426 Reduce the function FN across LIST. Return the result of applying FN to the first two elements of LIST, then applying FN to that result and the third element, etc. If LIST contains a single element, return it without calling FN. If LIST is empty, return the result of calling FN with no arguments. This function's anaphoric counterpart is `--reduce'. For other folds, see also `-reduce-from' and `-reduce-r'. (fn FN LIST) (defalias '-reduce #[514 "\211\203\f\300@A#\207 \207" [-reduce-from] 6 (#$ . 9476)]) #@214 Accumulate a value by evaluating FORM across LIST in reverse. This macro is like `--reduce-from', except it starts from the end of LIST. This is the anaphoric counterpart to `-reduce-r-from'. (fn FORM INIT LIST) (defalias '--reduce-r-from '(macro . #[771 "\300\301DC\302\303\301EE\304BBB\207" [let acc --each-r setq (acc)] 10 (#$ . 9998)])) (put '--reduce-r-from 'edebug-form-spec '(form form form)) #@842 Reduce the function FN across LIST in reverse, starting with INIT. Return the result of applying FN to the last element of LIST and INIT, then applying FN to the second-to-last element and the previous result of FN, etc. That is, the first argument of FN is the current element, and its second argument the accumulated value. If LIST is empty, return INIT without calling FN. This function is like `-reduce-from' but the operation associates from the right rather than left. In other words, it starts from the end of LIST and flips the arguments to FN. Conceptually, it is like replacing the conses in LIST with applications of FN, and its last link with INIT, and evaluating the resulting expression. This function's anaphoric counterpart is `--reduce-r-from'. For other folds, see also `-reduce-r' and `-reduce'. (fn FN INIT LIST) (defalias '-reduce-r-from #[771 "\300!\211G\301\211\302V\203%S\262\262H\262\"\262\202\266\207" [vconcat nil 0] 11 (#$ . 10410)]) #@205 Accumulate a value by evaluating FORM across LIST in reverse order. This macro is like `--reduce', except it starts from the end of LIST. This is the anaphoric counterpart to `-reduce-r'. (fn FORM LIST) (defalias '--reduce-r '(macro . #[514 "\300\301DE\207" [--reduce reverse] 6 (#$ . 11407)])) (put '--reduce-r 'edebug-form-spec '(form form)) #@887 Reduce the function FN across LIST in reverse. Return the result of applying FN to the last two elements of LIST, then applying FN to the third-to-last element and the previous result of FN, etc. That is, the first argument of FN is the current element, and its second argument the accumulated value. If LIST contains a single element, return it without calling FN. If LIST is empty, return the result of calling FN with no arguments. This function is like `-reduce' but the operation associates from the right rather than left. In other words, it starts from the end of LIST and flips the arguments to FN. Conceptually, it is like replacing the conses in LIST with applications of FN, ignoring its last link, and evaluating the resulting expression. This function's anaphoric counterpart is `--reduce-r'. For other folds, see also `-reduce-r-from' and `-reduce'. (fn FN LIST) (defalias '-reduce-r #[514 "\211\2038\300!\211\2033\211@A\301\302\211\2030\211A\262\242\262\262T\262\"\262\202\266\207\302\211\"\207 \207" [reverse 0 nil] 11 (#$ . 11761)]) #@270 Return a list of FORM's intermediate reductions across LIST. That is, a list of the intermediate values of the accumulator when `--reduce-from' (which see) is called with the same arguments. This is the anaphoric counterpart to `-reductions-from'. (fn FORM INIT LIST) (defalias '--reductions-from '(macro . #[771 "\300\301\302\303\304\305F\306BB\307DFD\207" [nreverse --reduce-from cons let ((acc (car acc))) (ignore acc) (acc) list] 10 (#$ . 12851)])) (put '--reductions-from 'edebug-form-spec '(form form form)) #@333 Return a list of FN's intermediate reductions across LIST. That is, a list of the intermediate values of the accumulator when `-reduce-from' (which see) is called with the same arguments. This function's anaphoric counterpart is `--reductions-from'. For other folds, see also `-reductions' and `-reductions-r'. (fn FN INIT LIST) (defalias '-reductions-from #[771 "C\300\301\211\203)\211A\262\242\262\262T\262@\"\262B\262\202\266\211\262\237\207" [0 nil] 12 (#$ . 13377)]) #@255 Return a list of FORM's intermediate reductions across LIST. That is, a list of the intermediate values of the accumulator when `--reduce' (which see) is called with the same arguments. This is the anaphoric counterpart to `-reductions'. (fn FORM LIST) (defalias '--reductions '(macro . #[514 "\300\301!\302DC\303\304\305D\306DF\302\307\310\311 DFFE\207" [make-symbol "list-value" let if --reductions-from car cdr (acc it) (ignore acc it) list] 13 (#$ . 13882)])) (put '--reductions 'edebug-form-spec '(form form)) #@318 Return a list of FN's intermediate reductions across LIST. That is, a list of the intermediate values of the accumulator when `-reduce' (which see) is called with the same arguments. This function's anaphoric counterpart is `--reductions'. For other folds, see also `-reductions' and `-reductions-r'. (fn FN LIST) (defalias '-reductions #[514 "\211\2036\211@CA\300\301\211\203/\211A\262\242\262\262T\262@\"\262B\262\202\f\266\211\262\237\207 C\207" [0 nil] 11 (#$ . 14415)]) #@283 Return a list of FORM's intermediate reductions across reversed LIST. That is, a list of the intermediate values of the accumulator when `--reduce-r-from' (which see) is called with the same arguments. This is the anaphoric counterpart to `-reductions-r-from'. (fn FORM INIT LIST) (defalias '--reductions-r-from '(macro . #[771 "\300\301\302\303\304F\305BB\306DF\207" [--reduce-r-from cons let ((acc (car acc))) (ignore acc) (acc) list] 9 (#$ . 14923)])) (put '--reductions-r-from 'edebug-form-spec '(form form form)) #@346 Return a list of FN's intermediate reductions across reversed LIST. That is, a list of the intermediate values of the accumulator when `-reduce-r-from' (which see) is called with the same arguments. This function's anaphoric counterpart is `--reductions-r-from'. For other folds, see also `-reductions' and `-reductions-r'. (fn FN INIT LIST) (defalias '-reductions-r-from #[771 "C\300!\211G\301\211\302V\203+S\262\262H\262@\"\262B\262\202 \266\207" [vconcat nil 0] 12 (#$ . 15453)]) #@269 Return a list of FORM's intermediate reductions across reversed LIST. That is, a list of the intermediate values of the accumulator when `--reduce-re' (which see) is called with the same arguments. This is the anaphoric counterpart to `-reductions-r'. (fn FORM LIST) (defalias '--reductions-r '(macro . #[514 "\300\301!\302\303DDC\304\305\306\302\307\310 F\311BB\312\313DD\314DF\302\315\316\312 DFFE\207" [make-symbol "list-value" let reverse if --reduce-from cons ((acc (car acc))) (ignore acc) (acc) list car cdr ((acc nil) (it nil)) (ignore acc it)] 13 (#$ . 15967)])) (put '--reductions-r 'edebug-form-spec '(form list)) #@336 Return a list of FN's intermediate reductions across reversed LIST. That is, a list of the intermediate values of the accumulator when `-reduce-r' (which see) is called with the same arguments. This function's anaphoric counterpart is `--reductions-r'. For other folds, see also `-reductions-r-from' and `-reductions'. (fn FN LIST) (defalias '-reductions-r #[514 "\211\203?\300!\211\2039\211@CA\301\302\211\2036\211A\262\242\262\262T\262@\"\262B\262\202\266\207\302\211\"C\207 C\207" [reverse 0 nil] 12 (#$ . 16609)]) #@296 Return a new list of the items in LIST for which FORM evals to non-nil. Each element of LIST in turn is bound to `it' and its index within LIST to `it-index' before evaluating FORM. This is the anaphoric counterpart to `-filter'. For the opposite operation, see also `--remove'. (fn FORM LIST) (defalias '--filter '(macro . #[514 "\300\301!\302C\303\304\305\306EEE\307DF\207" [make-symbol "result" let --each when push it nreverse] 12 (#$ . 17163)])) (put '--filter 'edebug-form-spec '(form form)) #@218 Return a new list of the items in LIST for which PRED returns non-nil. Alias: `-select'. This function's anaphoric counterpart is `--filter'. For similar operations, see also `-keep' and `-remove'. (fn PRED LIST) (defalias '-filter #[514 "\300\301\300\211\203'\211A\262\242\262\262T\262!\203B\262\202\266\211\237\207" [nil 0] 9 (#$ . 17676)]) (byte-code "\300\301\302\"\210\300\303\304\"\207" [defalias -select -filter --select --filter] 3) #@292 Return a new list of the items in LIST for which FORM evals to nil. Each element of LIST in turn is bound to `it' and its index within LIST to `it-index' before evaluating FORM. This is the anaphoric counterpart to `-remove'. For the opposite operation, see also `--filter'. (fn FORM LIST) (defalias '--remove '(macro . #[514 "\300\301DE\207" [--filter not] 5 (#$ . 18149)])) (put '--remove 'edebug-form-spec '(form form)) #@214 Return a new list of the items in LIST for which PRED returns nil. Alias: `-reject'. This function's anaphoric counterpart is `--remove'. For similar operations, see also `-keep' and `-filter'. (fn PRED LIST) (defalias '-remove #[514 "\300\301\300\211\203'\211A\262\242\262\262T\262!\204B\262\202\266\211\237\207" [nil 0] 9 (#$ . 18582)]) (byte-code "\300\301\302\"\210\300\303\304\"\207" [defalias -reject -remove --reject --remove] 3) #@446 Remove the first item from LIST for which FORM evals to non-nil. Each element of LIST in turn is bound to `it' and its index within LIST to `it-index' before evaluating FORM. This is a non-destructive operation, but only the front of LIST leading up to the removed item is a copy; the rest is LIST's original tail. If no item is removed, then the result is a complete copy. This is the anaphoric counterpart to `-remove-first'. (fn FORM LIST) (defalias '--remove-first '(macro . #[514 "\300\301!\300\302!\303DD\304\305D\306\307DEF\310\311\312D\313DE\312DFF\207" [make-symbol "front" "tail" let --each-while not push pop if nconc nreverse cdr] 13 (#$ . 19051)])) (put '--remove-first 'edebug-form-spec '(form form)) #@426 Remove the first item from LIST for which PRED returns non-nil. This is a non-destructive operation, but only the front of LIST leading up to the removed item is a copy; the rest is LIST's original tail. If no item is removed, then the result is a complete copy. Alias: `-reject-first'. This function's anaphoric counterpart is `--remove-first'. See also `-map-first', `-remove-item', and `-remove-last'. (fn PRED LIST) (defalias '-remove-first #[514 "\211\300\301\300\211\211\203=\211A\262\242\262\262\211\262\203=!\204=\262\262T\262\211A\262\242B\262\202\266\203I\211\237A\244\207\211\237\207" [nil 0] 11 (#$ . 19792)]) (byte-code "\300\301\302\"\210\300\303\304\"\207" [defalias -reject-first -remove-first --reject-first --remove-first] 3) #@279 Remove the last item from LIST for which FORM evals to non-nil. Each element of LIST in turn is bound to `it' before evaluating FORM. The result is a copy of LIST regardless of whether an element is removed. This is the anaphoric counterpart to `-remove-last'. (fn FORM LIST) (defalias '--remove-last '(macro . #[514 "\300\301\302DED\207" [nreverse --remove-first reverse] 7 (#$ . 20581)])) (put '--remove-last 'edebug-form-spec '(form form)) #@297 Remove the last item from LIST for which PRED returns non-nil. The result is a copy of LIST regardless of whether an element is removed. Alias: `-reject-last'. This function's anaphoric counterpart is `--remove-last'. See also `-map-last', `-remove-item', and `-remove-first'. (fn PRED LIST) (defalias '-remove-last #[514 "\300!\301\302\301\211\211\203?\211A\262\242\262\262\211\262\203?!\204?\262\262T\262\211A\262\242B\262\202 \266\203O\211\237A\244\266\202\202S\211\237\266\202\237\207" [reverse nil 0] 11 (#$ . 21035)]) (byte-code "\300\301\302\"\210\300\303\304\"\210\300\305\306\307#\207" [defalias -reject-last -remove-last --reject-last --remove-last -remove-item remove "Return a copy of LIST with all occurrences of ITEM removed.\nThe comparison is done with `equal'.\n\n(fn ITEM LIST)"] 4) #@342 Eval FORM for each item in LIST and return the non-nil results. Like `--filter', but returns the non-nil results of FORM instead of the corresponding elements of LIST. Each element of LIST in turn is bound to `it' and its index within LIST to `it-index' before evaluating FORM. This is the anaphoric counterpart to `-keep'. (fn FORM LIST) (defalias '--keep '(macro . #[514 "\300\301!\300\302!\303C\304\303 DC\305\306  EEEE\307DF\207" [make-symbol "result" "mapped" let --each when push nreverse] 15 (#$ . 21881)])) (put '--keep 'edebug-form-spec '(form form)) #@234 Return a new list of the non-nil results of applying FN to each item in LIST. Like `-filter', but returns the non-nil results of FN instead of the corresponding elements of LIST. Its anaphoric counterpart is `--keep'. (fn FN LIST) (defalias '-keep #[514 "\300\301\300\211\203*\211A\262\242\262\262T\262!\211\203&\211B\262\210\202\266\211\237\207" [nil 0] 10 (#$ . 22459)]) #@62 Return a copy of LIST with all nil items removed. (fn LIST) (defalias '-non-nil #[257 "\300\301\300\211\203$\211A\262\242\262\262T\262\203B\262\202\266\211\237\207" [nil 0] 8 (#$ . 22860)]) (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -non-nil pure t side-effect-free] 5) #@321 Eval FORM for each item in LIST and return the list of results. Each element of LIST in turn is bound to `it' and its index within LIST to `it-index' before evaluating FORM. This is like `--map', but additionally makes `it-index' available to FORM. This is the anaphoric counterpart to `-map-indexed'. (fn FORM LIST) (defalias '--map-indexed '(macro . #[514 "\300\301!\302C\303\304EE\305DF\207" [make-symbol "result" let --each push nreverse] 10 (#$ . 23184)])) (put '--map-indexed 'edebug-form-spec '(form form)) #@322 Apply FN to each index and item in LIST and return the list of results. This is like `-map', but FN takes two arguments: the index of the current element within LIST, and the element itself. This function's anaphoric counterpart is `--map-indexed'. For a side-effecting variant, see also `-each-indexed'. (fn FN LIST) (defalias '-map-indexed #[514 "\300\301\300\211\203$\211A\262\242\262\262T\262\"B\262\202\266\211\237\207" [nil 0] 10 (#$ . 23715)]) #@52 Anaphoric form of `-map-when'. (fn PRED REP LIST) (defalias '--map-when '(macro . #[771 "\300\301!\302C\303\304\305  \306BBBEE\307DF\207" [make-symbol "result" let --each !cons if (it) nreverse] 13 (#$ . 24194)])) (put '--map-when 'edebug-form-spec '(form form form)) #@266 Return a new list where the elements in LIST that do 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' (fn PRED REP LIST) (defalias '-map-when #[771 "\300\301\300\211\203.\211A\262\242\262\262T\262!\203&!\202'B\262\202\266\211\237\207" [nil 0] 10 (#$ . 24477)]) (byte-code "\300\301\302\"\210\300\303\304\"\207" [defalias -replace-where -map-when --replace-where --map-when] 3) #@145 Replace first item in LIST satisfying PRED with result of REP called on this item. See also: `-map-when', `-replace-first' (fn PRED REP LIST) (defalias '-map-first #[771 "\300\203@!\204@B\262A\262\202\203)\301\237@!AB\"\207\211\237\207" [nil -concat] 8 (#$ . 25029)]) #@53 Anaphoric form of `-map-first'. (fn PRED REP LIST) (defalias '--map-first '(macro . #[771 "\300\301\302E\301\303\304FF\207" [-map-first lambda (it) (it) (ignore it)] 9 (#$ . 25325)])) (put '--map-first 'edebug-form-spec '(def-form def-form form)) #@143 Replace last item in LIST satisfying PRED with result of REP called on this item. See also: `-map-when', `-replace-last' (fn PRED REP LIST) (defalias '-map-last #[771 "\300\301!#\237\207" [-map-first reverse] 8 (#$ . 25584)]) #@52 Anaphoric form of `-map-last'. (fn PRED REP LIST) (defalias '--map-last '(macro . #[771 "\300\301\302E\301\303\304FF\207" [-map-last lambda (it) (it) (ignore it)] 9 (#$ . 25821)])) (put '--map-last 'edebug-form-spec '(def-form def-form form)) #@123 Replace all OLD items in LIST with NEW. Elements are compared using `equal'. See also: `-replace-at' (fn OLD NEW LIST) (defalias '-replace #[771 "\300\301\300\211\203,\211A\262\242\262\262T\262\232\203$\202%B\262\202\266\211\237\207" [nil 0] 10 (#$ . 26076)]) (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -replace pure t side-effect-free] 5) #@136 Replace the first occurrence of OLD with NEW in LIST. Elements are compared using `equal'. See also: `-map-first' (fn OLD NEW LIST) (defalias '-replace-first #[771 "\300\301\302\"\301\303\"#\207" [-map-first make-closure #[257 "\300\232\207" [V0] 3 "\n\n(fn IT)"] #[257 "\300\207" [V0] 2 "\n\n(fn IT)"]] 8 (#$ . 26476)]) (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -replace-first pure t side-effect-free] 5) #@134 Replace the last occurrence of OLD with NEW in LIST. Elements are compared using `equal'. See also: `-map-last' (fn OLD NEW LIST) (defalias '-replace-last #[771 "\300\301\302\"\301\303\"#\207" [-map-last make-closure #[257 "\300\232\207" [V0] 3 "\n\n(fn IT)"] #[257 "\300\207" [V0] 2 "\n\n(fn IT)"]] 8 (#$ . 26924)]) (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -replace-last pure t side-effect-free] 5) #@46 Anaphoric form of `-mapcat'. (fn FORM LIST) (defalias '--mapcat '(macro . #[514 "\300\301\302EE\207" [apply 'append --map] 7 (#$ . 27366)])) (put '--mapcat 'edebug-form-spec '(form form)) #@118 Return the concatenation of the result of mapping FN over LIST. Thus function FN should return a list. (fn FN LIST) (defalias '-mapcat #[514 "\300\301\302\303\304\"\"\"\207" [apply append mapcar make-closure #[257 "\300!\207" [V0] 3 "\n\n(fn IT)"]] 8 (#$ . 27564)]) #@52 Anaphoric version of `-iterate'. (fn FORM INIT N) (defalias '--iterate '(macro . #[771 "\300\301!\300\302!\303DC\304\305\306BB\307\310 D\311BD\312\313\314 DD\315\316\310E EE\317 DFEE\207" [make-symbol "result" "n" let when > (0) let* it ((list it)) dotimes _ 1- push setq nreverse] 17 (#$ . 27841)])) (put '--iterate 'edebug-form-spec '(form form form)) #@186 Return a list of iterated applications of FUN to INIT. This means a list of the form: (INIT (FUN INIT) (FUN (FUN INIT)) ...) N is the length of the returned list. (fn FUN INIT N) (defalias '-iterate #[771 "\211\211\300V\205-\211CS\300\211W\203'\301!\211\262B\262\210\211T\262\202 \266\211\237\266\202\207" [0 nil] 11 (#$ . 28214)]) #@436 Take a nested list L and return its contents as a single, flat list. Note that because `nil' represents a list of zero elements (an empty list), any mention of nil in L will disappear after flattening. If you need to preserve nils, consider `-flatten-n' or map them to some unique symbol and then map them back. Conses of two atoms are considered "terminals", that is, they aren't flattened further. See also: `-flatten-n' (fn L) (defalias '-flatten #[257 "\211<\203\211A<\203\300\301\"\207\211C\207" [-mapcat -flatten] 4 (#$ . 28573)]) (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -flatten pure t side-effect-free] 5) #@75 Flatten NUM levels of a nested LIST. See also: `-flatten' (fn NUM LIST) (defalias '-flatten-n #[514 "\300\211W\203\301\302\303\304\305\"\"\262\210\211T\262\202\266\207" [0 nil apply append mapcar -list] 10 (#$ . 29233)]) (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -flatten-n pure t side-effect-free] 5) #@99 Return a new list with the concatenation of the elements in the supplied LISTS. (fn &rest LISTS) (defalias '-concat #[128 "\300\301\"\207" [apply append] 4 (#$ . 29582)]) (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) #@323 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' (fn PRED FUN LIST) (defalias '-splice #[771 "\300\301\300\211\203P\211A\262\242\262\262T\262!\203H!\211\301\300\211\203C\211A\262\242\262\262T\262\nB\262\n\202'\266\202B\262\202\266\211\237\207" [nil 0] 15 (#$ . 29956)]) #@51 Anaphoric form of `-splice'. (fn PRED FORM LIST) (defalias '--splice '(macro . #[771 "\300\301\302E\301\303EF\207" [-splice lambda (it) (it)] 8 (#$ . 30524)])) (put '--splice 'edebug-form-spec '(def-form def-form form)) #@121 Splice NEW-LIST in place of elements matching PRED in LIST. See also: `-splice', `-insert-at' (fn PRED NEW-LIST LIST) (defalias '-splice-list #[771 "\300\301\302\"#\207" [-splice make-closure #[257 "\300\207" [V0] 2 "\n\n(fn _)"]] 8 (#$ . 30755)]) #@60 Anaphoric form of `-splice-list'. (fn PRED NEW-LIST LIST) (defalias '--splice-list '(macro . #[771 "\300\301\302EF\207" [-splice-list lambda (it)] 7 (#$ . 31014)])) (put '--splice-list 'edebug-form-spec '(def-form form form)) #@234 Make a new list from the elements of ARGS. The last 2 elements of ARGS are used as the final cons of the result, so if the final element of ARGS is not a list, the result is a dotted list. With no ARGS, return nil. (fn &rest ARGS) (defalias '-cons* #[128 "\211G\211\300Z\233\211A\211\204@\207@\241\210\207" [2] 6 (#$ . 31251)]) (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -cons* pure t side-effect-free] 5) #@182 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. (fn LIST ELEM &rest ELEMENTS) (defalias '-snoc #[642 "\300C#\207" [-concat] 7 (#$ . 31700)]) #@277 Return the first item in LIST for which FORM evals to non-nil. Return nil if no such element is found. Each element of LIST in turn is bound to `it' and its index within LIST to `it-index' before evaluating FORM. This is the anaphoric counterpart to `-first'. (fn FORM LIST) (defalias '--first '(macro . #[514 "\300\301!\302C\303\304\305D\306\307\310BBDEEF\207" [make-symbol "needle" let --each-while or not ignore setq (it)] 13 (#$ . 31954)])) (put '--first 'edebug-form-spec '(form form)) #@254 Return the first item in LIST for which PRED returns non-nil. Return nil if no such element is found. To get the first item in the list no questions asked, use `car'. Alias: `-find'. This function's anaphoric counterpart is `--first'. (fn PRED LIST) (defalias '-first #[514 "\300\301\300\211\211\2037\211A\262\242\262\262\211\262\2037!\203*\300\262\2037\262\262T\262\202\266\207" [nil 0] 10 (#$ . 32460)]) (byte-code "\300\301\302\"\210\300\303\304\"\207" [defalias -find -first --find --first] 3) #@289 Return non-nil if FORM evals to non-nil for at least one item in LIST. If so, return the first such result of FORM. Each element of LIST in turn is bound to `it' and its index within LIST to `it-index' before evaluating FORM. This is the anaphoric counterpart to `-some'. (fn FORM LIST) (defalias '--some '(macro . #[514 "\300\301!\302C\303\304\305 EDEF\207" [make-symbol "needle" let --each-while not setq] 11 (#$ . 32995)])) (put '--some 'edebug-form-spec '(form form)) #@162 Return (PRED x) for the first LIST item where (PRED x) is non-nil, else nil. Alias: `-any'. This function's anaphoric counterpart is `--some'. (fn PRED LIST) (defalias '-some #[514 "\300\301\300\211\211\2033\211A\262\242\262\262\211\262\2033!\211\262\2043\262\262T\262\202\266\207" [nil 0] 10 (#$ . 33481)]) (byte-code "\300\301\302\"\210\300\303\304\"\207" [defalias -any -some --any --some] 3) #@518 Return non-nil if FORM evals to non-nil for all items in LIST. If so, return the last such result of FORM. Otherwise, once an item is reached for which FORM yields nil, return nil without evaluating FORM for any further LIST elements. Each element of LIST in turn is bound to `it' and its index within LIST to `it-index' before evaluating FORM. This macro is like `--every-p', but on success returns the last non-nil result of FORM instead of just t. This is the anaphoric counterpart to `-every'. (fn FORM LIST) (defalias '--every '(macro . #[514 "\300\301!\302\303BC\304\305EEF\207" [make-symbol "all" let (t) --each-while setq] 10 (#$ . 33912)])) (put '--every 'edebug-form-spec '(form form)) #@411 Return non-nil if PRED returns non-nil for all items in LIST. If so, return the last such result of PRED. Otherwise, once an item is reached for which PRED returns nil, return nil without calling PRED on any further LIST elements. This function is like `-every-p', but on success returns the last non-nil result of PRED instead of just t. This function's anaphoric counterpart is `--every'. (fn PRED LIST) (defalias '-every #[514 "\300\301\302\211\211\2033\211A\262\242\262\262\211\262\2033!\211\262\2033\262\262T\262\202\266\207" [t 0 nil] 10 (#$ . 34625)]) #@44 Anaphoric form of `-last'. (fn FORM LIST) (defalias '--last '(macro . #[514 "\300\301!\302C\303\304\305\306BBEEF\207" [make-symbol "needle" let --each when setq (it)] 12 (#$ . 35219)])) (put '--last 'edebug-form-spec '(form form)) #@80 Return the last x in LIST where (PRED x) is non-nil, else nil. (fn PRED LIST) (defalias '-last #[514 "\300\301\300\211\203%\211A\262\242\262\262T\262!\203\262\202\266\207" [nil 0] 9 (#$ . 35464)]) (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!\203$\316\202%\317\320#\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 fboundp caddr #[257 "\211AA@\207" [] 2 "\n\n(fn LIST)"] "Return the third item of LIST, or nil if LIST is too short.\n\nSee also: `-fourth-item'.\n\n(fn LIST)"] 4) #@99 Return the fourth item of LIST, or nil if LIST is too short. See also: `-fifth-item'. (fn LIST) (defalias '-fourth-item #[257 "\211AAA@\207" [] 2 (#$ . 36329)]) (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -fourth-item pure t side-effect-free] 5) #@97 Return the fifth item of LIST, or nil if LIST is too short. See also: `-last-item'. (fn LIST) (defalias '-fifth-item #[257 "\211AAAA@\207" [] 2 (#$ . 36609)]) (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -fifth-item pure t side-effect-free] 5) #@67 Return the last item of LIST, or nil on an empty list. (fn LIST) (defalias '-last-item #[257 "\300!@\207" [last] 3 (#$ . 36886)]) (byte-code "\303\300\304\305#\303\300\306\305#\307\310!\203\303\300\311\312#\210\202'\313\301 \302 \314\315 D\nE$\210\303\207" [-last-item x val function-put pure t side-effect-free fboundp gv-define-setter gv-expander #[385 "\300\301\302$\207" [gv--defsetter -last-item #[514 "\300\301DE\207" [setcar last] 5 "\n\n(fn VAL X)"]] 7 "\n\n(fn DO &rest ARGS)"] defsetf setcar last] 9) #@68 Return a list of all items in list except for the last. (fn LIST) (defalias '-butlast #[257 "\300!\207" [butlast] 3 (#$ . 37413)]) (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -butlast pure t side-effect-free] 5) #@45 Anaphoric form of `-count'. (fn PRED LIST) (defalias '--count '(macro . #[514 "\300\301!\302\303BC\304\305\306\307 DEEEF\207" [make-symbol "result" let (0) --each when setq 1+] 13 (#$ . 37659)])) (put '--count 'edebug-form-spec '(form form)) #@82 Counts the number of items in LIST where (PRED item) is non-nil. (fn PRED LIST) (defalias '-count #[514 "\300\300\301\211\203&\211A\262\242\262\262T\262!\203T\262\202\266\207" [0 nil] 9 (#$ . 37916)]) #@53 Return OBJ as a boolean value (t or nil). (fn OBJ) (defalias '---truthy\? #[257 "\211\205\300\207" [t] 2 (#$ . 38144)]) (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put ---truthy\? pure t side-effect-free] 5) #@44 Anaphoric form of `-any?'. (fn FORM LIST) (defalias '--any\? '(macro . #[514 "\300\301E\302BB\207" [and --some (t)] 6 (#$ . 38383)])) (put '--any\? 'edebug-form-spec '(form form)) #@116 Return t if (PRED x) is non-nil for any x in LIST, else nil. Alias: `-any-p', `-some?', `-some-p' (fn PRED LIST) (defalias '-any\? #[514 "\300\301\300\211\211\2033\211A\262\242\262\262\211\262\2033!\211\262\2043\262\262T\262\202\266\211\262\205<\302\207" [nil 0 t] 10 (#$ . 38573)]) (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) #@534 Return t if FORM evals to non-nil for all items in LIST. Otherwise, once an item is reached for which FORM yields nil, return nil without evaluating FORM for any further LIST elements. Each element of LIST in turn is bound to `it' and its index within LIST to `it-index' before evaluating FORM. The similar macro `--every' is more widely useful, since it returns the last non-nil result of FORM instead of just t on success. Alias: `--all-p', `--every-p', `--every?'. This is the anaphoric counterpart to `-all?'. (fn FORM LIST) (defalias '--all\? '(macro . #[514 "\300\301E\302BB\207" [and --every (t)] 6 (#$ . 39092)])) (put '--all\? 'edebug-form-spec '(form form)) #@431 Return t if (PRED X) is non-nil for all X in LIST, else nil. In the latter case, stop after the first X for which (PRED X) is nil, without calling PRED on any subsequent elements of LIST. The similar function `-every' is more widely useful, since it returns the last non-nil result of PRED instead of just t on success. Alias: `-all-p', `-every-p', `-every?'. This function's anaphoric counterpart is `--all?'. (fn PRED LIST) (defalias '-all\? #[514 "\300\301\302\211\211\2033\211A\262\242\262\262\211\262\2033!\211\262\2033\262\262T\262\202\266\211\262\205<\300\207" [t 0 nil] 10 (#$ . 39773)]) (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) #@45 Anaphoric form of `-none?'. (fn FORM LIST) (defalias '--none\? '(macro . #[514 "\300\301DE\207" [--all\? not] 5 (#$ . 40610)])) (put '--none\? 'edebug-form-spec '(form form)) #@92 Return t if (PRED x) is nil for all x in LIST, else nil. Alias: `-none-p' (fn PRED LIST) (defalias '-none\? #[514 "\300\301\302\211\211\2034\211A\262\242\262\262\211\262\2034!?\211\262\2034\262\262T\262\202\266\211\262\205=\300\207" [t 0 nil] 10 (#$ . 40794)]) (byte-code "\300\301\302\"\210\300\303\304\"\207" [defalias -none-p -none\? --none-p --none\?] 3) #@50 Anaphoric form of `-only-some?'. (fn FORM LIST) (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 (#$ . 41188)])) (put '--only-some\? 'edebug-form-spec '(form form)) #@240 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' (fn PRED LIST) (defalias '-only-some\? #[514 "\300\211\301\300\211\211\203C\211A\262\242\262\262\211\262\203C\203&\204C\262\262T\262!\203=\302\262\202\302\262\202\266\303\205K!\207" [nil 0 t ---truthy\?] 11 (#$ . 41532)]) (byte-code "\300\301\302\"\210\300\303\304\"\207" [defalias -only-some-p -only-some\? --only-some-p --only-some\?] 3) #@287 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. (fn LIST FROM &optional TO STEP) (defalias '-slice #[1026 "G\300\206\262\206\301\262\302W\203\303\"\262\302W\203)\303\"\262\302\300\211\211\203r\211A\262\242\262\262\211\262\203r\211 W\203r\262\262T\262\211\nY\203.\303\nZ \"\302U\203.B\262\202.\266\211\237\207" [nil 1 0 mod] 14 (#$ . 42139)]) (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -slice pure t side-effect-free] 5) #@350 Take successive items from LIST for which FORM evals to non-nil. Each element of LIST in turn is bound to `it' and its index within LIST to `it-index' before evaluating FORM. Return a new list of the successive elements from the start of LIST for which FORM evaluates to non-nil. This is the anaphoric counterpart to `-take-while'. (fn FORM LIST) (defalias '--take-while '(macro . #[514 "\300\301!\302C\303\304\305EF\306DF\207" [make-symbol "result" let --each-while push it nreverse] 11 (#$ . 42850)])) (put '--take-while 'edebug-form-spec '(form form)) #@322 Take successive items from LIST for which PRED returns non-nil. PRED is a function of one argument. Return a new list of the successive elements from the start of LIST for which PRED returns non-nil. This function's anaphoric counterpart is `--take-while'. For another variant, see also `-drop-while'. (fn PRED LIST) (defalias '-take-while #[514 "\300\301\300\211\211\2036\211A\262\242\262\262\211\262\2036!\2036\262\262T\262B\262\202\266\211\237\207" [nil 0] 10 (#$ . 43421)]) #@347 Drop successive items from LIST for which FORM evals to non-nil. Each element of LIST in turn is bound to `it' and its index within LIST to `it-index' before evaluating FORM. Return the tail (not a copy) of LIST starting from its first element for which FORM evaluates to nil. This is the anaphoric counterpart to `-drop-while'. (fn FORM LIST) (defalias '--drop-while '(macro . #[514 "\300\301!\302DC\303\304DFF\207" [make-symbol "list" let --each-while pop] 10 (#$ . 43938)])) (put '--drop-while 'edebug-form-spec '(form form)) #@319 Drop successive items from LIST for which PRED returns non-nil. PRED is a function of one argument. Return the tail (not a copy) of LIST starting from its first element for which PRED returns nil. This function's anaphoric counterpart is `--drop-while'. For another variant, see also `-take-while'. (fn PRED LIST) (defalias '-drop-while #[514 "\211\211\300\301\211\211\2034\211A\262\242\262\262\211\262\2034!\2034\262\262T\262A\262\202\266\207" [0 nil] 10 (#$ . 44484)]) #@171 Return a copy of the first N items in LIST. Return a copy of LIST if it contains N items or fewer. Return nil if N is zero or less. See also: `-take-last'. (fn N LIST) (defalias '-take #[514 "\300\301\300\211\211\2036\211A\262\242\262\262\211\262\2036\211W\2036\262\262T\262B\262\202\266\211\237\207" [nil 0] 10 (#$ . 44991)]) (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -take pure t side-effect-free] 5) #@174 Return a copy of the last N items of LIST in order. Return a copy of LIST if it contains N items or fewer. Return nil if N is zero or less. See also: `-take'. (fn N LIST) (defalias '-take-last #[514 "\300\301\"!\207" [copy-sequence last] 6 (#$ . 45458)]) (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 (not a copy) of LIST without the first N items.\nReturn nil if LIST contains N items or fewer.\nReturn LIST if N is zero or less.\n\nFor another variant, see also `-drop-last'.\n\n(fn N LIST)"] 6) #@172 Return a copy of LIST without its last N items. Return a copy of LIST if N is zero or less. Return nil if LIST contains N items or fewer. See also: `-drop'. (fn N LIST) (defalias '-drop-last #[514 "\300\301!\"\207" [nbutlast copy-sequence] 5 (#$ . 46078)]) (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -drop-last pure t side-effect-free] 5) #@354 Split LIST into two sublists after the Nth element. The result is a list of two elements (TAKE DROP) where TAKE is a new list of the first N elements of LIST, and DROP is the remaining elements of LIST (not a copy). TAKE and DROP are like the results of `-take' and `-drop', respectively, but the split is done in a single list traversal. (fn N LIST) (defalias '-split-at #[514 "\300\301\300\211\211\203<\211A\262\242\262\262\211\262\203<\211W\203<\262\262T\262\211A\262\242B\262\202\266\211\237D\207" [nil 0] 10 (#$ . 46455)]) (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -split-at pure t side-effect-free] 5) #@102 Rotate LIST N places to the right (left if N is negative). The time complexity is O(n). (fn N LIST) (defalias '-rotate #[514 "\211\204\300\207\301U\203\302!\207\211G\303\"Z\304\233\305\"\"\207" [nil 0 copy-sequence mod append -take] 10 (#$ . 47130)]) (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -rotate pure t side-effect-free] 5) #@108 Return a list with X inserted into LIST at position N. See also: `-splice', `-splice-list' (fn N X LIST) (defalias '-insert-at #[771 "\300\"\211@A@B\244\207" [-split-at] 7 (#$ . 47510)]) (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -insert-at pure t side-effect-free] 5) #@106 Return a list with element at Nth position in LIST replaced with X. See also: `-replace' (fn N X LIST) (defalias '-replace-at #[771 "\300\"\211@A@AB\244\207" [-split-at] 7 (#$ . 47819)]) (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -replace-at pure t side-effect-free] 5) #@130 Return a list with element at Nth position in LIST replaced with `(func (nth n list))`. See also: `-map-when' (fn N FUNC LIST) (defalias '-update-at #[771 "\300\"\211@A@@!A@AB\244\207" [-split-at] 7 (#$ . 48129)]) #@54 Anaphoric version of `-update-at'. (fn N FORM LIST) (defalias '--update-at '(macro . #[771 "\300\301\302EF\207" [-update-at lambda (it)] 8 (#$ . 48356)])) (put '--update-at 'edebug-form-spec '(form def-form form)) #@117 Return a list with element at Nth position in LIST removed. See also: `-remove-at-indices', `-remove' (fn N LIST) (defalias '-remove-at #[514 "\300C\"\207" [-remove-at-indices] 5 (#$ . 48581)]) (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -remove-at pure t side-effect-free] 5) #@175 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' (fn INDICES LIST) (defalias '-remove-at-indices #[514 "\300\301\"\211@\302\303\304\305A#\"B\306\307\306\211\203?\211A\262\242\262\262T\262\310 \"\211@B\262\211A@A\262 \210\202\266B\262\311\312\237\"\207" [-sort < -map 1- -zip-with - nil 0 -split-at apply -concat] 12 (#$ . 48895)]) (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -remove-at-indices pure t side-effect-free] 5) #@50 Anaphoric form of `-split-with'. (fn PRED LIST) (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 (#$ . 49482)])) (put '--split-with 'edebug-form-spec '(form form)) #@128 Return a list of ((-take-while PRED LIST) (-drop-while PRED LIST)), in no more than one pass through the list. (fn PRED LIST) (defalias '-split-with #[514 "\211\300\301\203&\211\203&@!\204\300\266\202\202\211B\262A\262\210\202\237D\207" [nil t] 8 (#$ . 49911)]) #@224 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' (fn ITEM LIST) (defalias '-split-on '(macro . #[514 "\300\301\302\303\304EEE\207" [-split-when lambda (it) equal it] 8 (#$ . 50199)])) (put '-split-on 'edebug-form-spec '(def-form form)) #@53 Anaphoric version of `-split-when'. (fn FORM LIST) (defalias '--split-when '(macro . #[514 "\300\301\302EE\207" [-split-when lambda (it)] 6 (#$ . 50603)])) (put '--split-when 'edebug-form-spec '(def-form form)) #@269 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'. (fn FN LIST) (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 (#$ . 50824)]) #@48 Anaphoric form of `-separate'. (fn FORM LIST) (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 (#$ . 51274)])) (put '--separate 'edebug-form-spec '(form form)) #@107 Return a list of ((-filter PRED LIST) (-remove PRED LIST)), in one pass through the list. (fn PRED LIST) (defalias '-separate #[514 "\300\211\301\300\211\2031\211A\262\242\262\262T\262!\203)B\262\202B\262\202\266\237\237D\207" [nil 0] 10 (#$ . 51583)]) #@80 Used by `-partition-all-in-steps' and `-partition-in-steps'. (fn N STEP LIST) (defalias 'dash--partition-all-in-steps-reversed #[771 "\300W\203 \301\302\303D\"\210\304\203\"\305\"B\262\233\262\202\207" [1 signal wrong-type-argument "Step size < 1 results in juicy infinite loops" nil -take] 7 (#$ . 51871)]) #@160 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. (fn N STEP LIST) (defalias '-partition-all-in-steps #[771 "\300#\237\207" [dash--partition-all-in-steps-reversed] 7 (#$ . 52201)]) (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -partition-all-in-steps pure t side-effect-free] 5) #@202 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. (fn N STEP LIST) (defalias '-partition-in-steps #[771 "\300#\211\203\211@GW\203\211A\262\202\211\237\207" [dash--partition-all-in-steps-reversed] 7 (#$ . 52606)]) (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -partition-in-steps pure t side-effect-free] 5) #@132 Return a new list with the items in LIST grouped into N-sized sublists. The last group may contain less than N items. (fn N LIST) (defalias '-partition-all #[514 "\300\211#\207" [-partition-all-in-steps] 6 (#$ . 53089)]) (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -partition-all pure t side-effect-free] 5) #@175 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. (fn N LIST) (defalias '-partition #[514 "\300\211#\207" [-partition-in-steps] 6 (#$ . 53433)]) (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -partition pure t side-effect-free] 5) #@52 Anaphoric form of `-partition-by'. (fn FORM LIST) (defalias '--partition-by '(macro . #[514 "\300\301!\300\302!\300\303!\300\304!\300\305!\306DC\307\310 \311B\312\313DD\n\314B\nD \315 DD\257\316\310\312\313 DD DD\317\320E\321\322DE\323\324BB\323E\257\321\312E\325 D\257E\321\322\fD E\322 D\257EE\207" [make-symbol "result" "sublist" "value" "new-value" "list" let when let* (nil) it car ((list it)) cdr while unless equal !cons nreverse setq (nil) !cdr] 24 (#$ . 53807)])) (put '--partition-by 'edebug-form-spec '(form form)) #@93 Apply FN to each item in LIST, splitting it each time FN returns a new value. (fn FN LIST) (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 (#$ . 54383)]) #@59 Anaphoric form of `-partition-by-header'. (fn FORM LIST) (defalias '--partition-by-header '(macro . #[514 "\300\301!\300\302!\300\303!\300\304!\300\305!\300\306!\307DC\310\311\n\312B\313\314DD \315B D \316B\n\317\fDD\257\320\311\313\314 DD DD\321\322E\310\323\324DE\325\326BB\325\327BB\257\325\330BBF\323\313E\331 D\257E\323\324 DE\324D\257EE\207" [make-symbol "result" "sublist" "header-value" "seen-body?" "new-value" "list" let when let* (nil) it car ((list it)) (nil) cdr while if equal !cons nreverse setq (nil) (nil) (t) !cdr] 27 (#$ . 54684)])) (put '--partition-by-header 'edebug-form-spec '(form form)) #@219 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). (fn FN LIST) (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 (#$ . 55352)]) #@221 Partition LIST after each element for which FORM evaluates to non-nil. Each element of LIST in turn is bound to `it' before evaluating FORM. This is the anaphoric counterpart to `-partition-after-pred'. (fn FORM LIST) (defalias '--partition-after-pred '(macro . #[514 "\300\301!\300\302!\300\303!\304DE\305\306\307\310E\305\f\307\311 D\fE\312 \313BBFF\305\307\311 D\nEE\311D\257E\207" [make-symbol "list" "result" "sublist" let when --each push it nreverse setq (nil)] 18 (#$ . 55817)])) #@151 Partition LIST after each element for which PRED returns non-nil. This function's anaphoric counterpart is `--partition-after-pred'. (fn PRED LIST) (defalias '-partition-after-pred #[514 "\211\300\211\205E\301\300\211\2037\211A\262\242\262\262T\262B\262!\203 \237B\262\300\262\202 \266\211\203C\211\237B\262\237\207" [nil 0] 11 (#$ . 56334)]) #@89 Partition directly before each time PRED is true on an element of LIST. (fn PRED LIST) (defalias '-partition-before-pred #[514 "\300\301\302\301!\"\"\237\207" [-map reverse -partition-after-pred] 8 (#$ . 56715)]) #@74 Partition directly after each time ITEM appears in LIST. (fn ITEM LIST) (defalias '-partition-after-item #[514 "\300\301\302\"\"\207" [-partition-after-pred make-closure #[257 "\211\300\232\207" [V0] 3 "\n\n(fn ELE)"]] 6 (#$ . 56937)]) #@75 Partition directly before each time ITEM appears in LIST. (fn ITEM LIST) (defalias '-partition-before-item #[514 "\300\301\302\"\"\207" [-partition-before-pred make-closure #[257 "\211\300\232\207" [V0] 3 "\n\n(fn ELE)"]] 6 (#$ . 57182)]) #@48 Anaphoric form of `-group-by'. (fn FORM LIST) (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 (#$ . 57430)])) (put '--group-by 'edebug-form-spec t) #@125 Separate LIST into an alist whose keys are FN applied to the elements of LIST. Keys are compared by `equal'. (fn FN LIST) (defalias '-group-by #[514 "\300\301\302\303\302\211\203B\211A\262\242\262\262T\262!\304\"\211\2031\211AB\241\210\2029DB\262\266\202\262\202\266\211\262\"\237\207" [-map #[257 "\211@A\237B\207" [] 3 "\n\n(fn N)"] nil 0 assoc] 14 (#$ . 57889)]) #@76 Return a new list of all elements in LIST separated by SEP. (fn SEP LIST) (defalias '-interpose #[514 "\300\203@C\262A\262\203!@BB\262A\262\202\211\237\207" [nil] 6 (#$ . 58296)]) (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -interpose pure t side-effect-free] 5) #@90 Return a new list of the first item in each list, then the second etc. (fn &rest LISTS) (defalias '-interleave #[128 "\211\205;\300\301\302\"\2037\303\300\211\203,\211A\262\242\262\262T\262@B\262\202\266\304\305\"\262\202\211\237\262\207" [nil -none\? null 0 -map cdr] 8 (#$ . 58609)]) (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -interleave pure t side-effect-free] 5) #@145 Anaphoric form of `-zip-with'. The elements in list1 are bound as symbol `it', the elements in list2 as symbol `other'. (fn FORM LIST1 LIST2) (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 (#$ . 59037)])) (put '--zip-with 'edebug-form-spec '(form form form)) #@347 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 symbol `it', and the elements from LIST2 as symbol `other'. (fn FN LIST1 LIST2) (defalias '-zip-with #[771 "\300\203#\211\203#@@\"B\262A\262A\266\203\202\237\207" [nil] 11 (#$ . 59523)]) #@380 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. The return value is always list of lists, which is a difference from `-zip-pair' which returns a cons-cell in case two input lists are provided. See also: `-zip' (fn &rest LISTS) (defalias '-zip-lists #[128 "\211\205!\300\301\302\"\203\303\304\"B\262\303\305\"\262\202\211\237\262\207" [nil -none\? null mapcar car cdr] 5 (#$ . 60002)]) (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -zip-lists pure t side-effect-free] 5) #@476 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. Use `-zip-lists' if you need the return value to always be a list of lists. Alias: `-zip-pair' See also: `-zip-lists' (fn &rest LISTS) (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 (#$ . 60667)]) (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) #@177 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. (fn FILL-VALUE &rest LISTS) (defalias '-zip-fill #[385 "\300\301\300\302B\"\"\207" [apply -zip -pad] 8 (#$ . 61528)]) (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -zip-fill pure t side-effect-free] 5) #@371 Unzip LISTS. This works just like `-zip' but takes a list of lists instead of a variable number of arguments, such that (-unzip (-zip L1 L2 L3 ...)) is identity (given that the lists are the same length). Note in particular that calling this on a list of two lists will return a list of cons-cells such that the above identity works. See also: `-zip' (fn LISTS) (defalias '-unzip #[257 "\300\301\"\207" [apply -zip] 4 (#$ . 61911)]) #@140 Return an infinite circular copy of LIST. The returned list cycles through the elements of LIST and repeats from the beginning. (fn LIST) (defalias '-cycle #[257 "\300\301\"\211\244\207" [append nil] 4 (#$ . 62360)]) (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -cycle pure t side-effect-free] 5) #@128 Appends FILL-VALUE to the end of each list in LISTS such that they will all have the same length. (fn FILL-VALUE &rest LISTS) (defalias '-pad #[385 "\300\301\"\302\303\304\"!\305\306\307#\"\207" [-annotate length -max -map car mapcar make-closure #[257 "\302A\303\301@Z\300\"\"\207" [V0 V1 append -repeat] 6 "\n\n(fn IT)"]] 9 (#$ . 62692)]) #@141 Return a list of cons cells where each cell is FN applied to each element of LIST paired with the unmodified element of LIST. (fn FN LIST) (defalias '-annotate #[514 "\300\301\"\"\207" [-zip -map] 6 (#$ . 63049)]) #@51 Anaphoric version of `-annotate'. (fn FORM LIST) (defalias '--annotate '(macro . #[514 "\300\301\302EE\207" [-annotate lambda (it)] 6 (#$ . 63273)])) (put '--annotate 'edebug-form-spec '(def-form form)) #@140 Helper for `-table' and `-table-flat'. If a list overflows, carry to the right and reset the list. (fn LISTS RESTORE-LISTS &optional RE) (defalias 'dash--table-carry #[770 "@\206\300\232?\205A@\240\210\211A@AA\240\266A\262A\262\211\203\211@\237\211AA@B\240\266\211\301\240\210\211A\262\202\207" [(nil) nil] 8 (#$ . 63486)]) #@352 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' (fn FN &rest LISTS) (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 (#$ . 63843)]) #@539 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)) (apply \='-table fn lists)) but the implementation here is much more efficient. See also: `-flatten-n', `-table' (fn FN &rest LISTS) (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 (#$ . 64432)]) #@151 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. (fn ELEM LIST) (defalias '-elem-index #[514 "\300\"@\207" [-elem-indices] 5 (#$ . 65185)]) (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -elem-index pure t side-effect-free] 5) #@113 Return the indices of all elements in LIST equal to the query element ELEM, in ascending order. (fn ELEM LIST) (defalias '-elem-indices #[514 "\300\301\302\"\"\207" [-find-indices -partial equal] 6 (#$ . 65530)]) (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -elem-indices pure t side-effect-free] 5) #@111 Return the indices of all elements in LIST satisfying the predicate PRED, in ascending order. (fn PRED LIST) (defalias '-find-indices #[514 "\300\301\302\303\302\211\203*\211A\262\242\262\262T\262!\205#\211CB\262\202\266\211\237\262\"\207" [apply append nil 0] 11 (#$ . 65865)]) #@55 Anaphoric version of `-find-indices'. (fn FORM LIST) (defalias '--find-indices '(macro . #[514 "\300\301\302EE\207" [-find-indices lambda (it)] 6 (#$ . 66171)])) (put '--find-indices 'edebug-form-spec '(def-form form)) #@186 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. See also `-first'. (fn PRED LIST) (defalias '-find-index #[514 "\300\"@\207" [-find-indices] 5 (#$ . 66400)]) #@53 Anaphoric version of `-find-index'. (fn FORM LIST) (defalias '--find-index '(macro . #[514 "\300\301\302EE\207" [-find-index lambda (it)] 6 (#$ . 66669)])) (put '--find-index 'edebug-form-spec '(def-form form)) #@184 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. See also `-last'. (fn PRED LIST) (defalias '-find-last-index #[514 "\300\301\"!\207" [-last-item -find-indices] 6 (#$ . 66890)]) #@58 Anaphoric version of `-find-last-index'. (fn FORM LIST) (defalias '--find-last-index '(macro . #[514 "\300\301\302EE\207" [-find-last-index lambda (it)] 6 (#$ . 67177)])) (put '--find-last-index 'edebug-form-spec '(def-form form)) #@123 Return a list whose elements are elements from LIST selected as `(nth i list)` for all i from INDICES. (fn INDICES LIST) (defalias '-select-by-indices #[514 "\300\301\300\211\203#\211A\262\242\262\262T\2628B\262\202\266\211\237\207" [nil 0] 9 (#$ . 67418)]) (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -select-by-indices pure t side-effect-free] 5) #@283 Select COLUMNS from TABLE. TABLE is a list of lists where each element represents one row. It is assumed each row has the same length. Each row is transformed such that only the specified COLUMNS are selected. See also: `-select-column', `-select-by-indices' (fn COLUMNS TABLE) (defalias '-select-columns #[514 "\300\301\302\"\"\207" [mapcar make-closure #[257 "\301\300\"\207" [V0 -select-by-indices] 4 "\n\n(fn IT)"]] 6 (#$ . 67819)]) (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -select-columns pure t side-effect-free] 5) #@257 Select COLUMN from TABLE. TABLE is a list of lists where each element represents one row. It is assumed each row has the same length. The single selected column is returned as a list. See also: `-select-columns', `-select-by-indices' (fn COLUMN TABLE) (defalias '-select-column #[514 "\300\301\302\303\304\"\"\"\207" [apply append mapcar make-closure #[257 "\301\300C\"\207" [V0 -select-by-indices] 4 "\n\n(fn IT)"]] 8 (#$ . 68384)]) (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -select-column pure t side-effect-free] 5) #@253 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. (fn X &optional FORM &rest MORE) (defalias '-> '(macro . #[641 "\204\207\211\204<\203@ABB\207D\207\300\211EBB\207" [->] 7 (#$ . 68946)])) (put '-> 'edebug-form-spec '(form &rest [&or symbolp (sexp &rest form)])) #@249 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. (fn X &optional FORM &rest MORE) (defalias '->> '(macro . #[641 "\204\207\211\204<\203\300C\"\207D\207\301\211EBB\207" [append ->>] 7 (#$ . 69401)])) (put '->> 'edebug-form-spec '->) #@269 Starting with the value of X, thread each expression through FORMS. Insert X at the position signified by the symbol `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. (fn X &rest FORMS) (defalias '--> '(macro . #[385 "\300\301BBB\207" [-as-> it] 6 (#$ . 69822)])) (put '--> 'edebug-form-spec '(form body)) #@212 Starting with VALUE, thread VARIABLE through FORMS. In the first form, bind VARIABLE to VALUE. In the second form, bind VARIABLE to the result of the first form, and so forth. (fn VALUE VARIABLE &rest FORMS) (defalias '-as-> '(macro . #[642 "\211\204\207\300DC\301@9\203@D\202@ABBBE\207" [let -as->] 9 (#$ . 70219)])) (put '-as-> 'edebug-form-spec '(form symbolp body)) #@163 When expr is non-nil, thread it through the first form (via `->'), and when that result is non-nil, through the next form, etc. (fn X &optional FORM &rest MORE) (defalias '-some-> '(macro . #[641 "\204\207\300\301!\302\303D\304EEBB\207" [make-symbol "result" -some-> -when-let ->] 10 (#$ . 70614)])) (byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put -some-> edebug-form-spec -> function-put lisp-indent-function 1] 4) #@164 When expr is non-nil, thread it through the first form (via `->>'), and when that result is non-nil, through the next form, etc. (fn X &optional FORM &rest MORE) (defalias '-some->> '(macro . #[641 "\204\207\300\301!\302\303D\304EEBB\207" [make-symbol "result" -some->> -when-let ->>] 10 (#$ . 71066)])) (byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put -some->> edebug-form-spec -> function-put lisp-indent-function 1] 4) #@239 Thread EXPR through FORMS via `-->', while the result is non-nil. When EXPR evaluates to non-nil, thread the result through the first of FORMS, and when that result is non-nil, thread it through the next form, etc. (fn EXPR &rest FORMS) (defalias '-some--> '(macro . #[385 "\211\204\207\300\301!\302\303D\304@EEABB\207" [make-symbol "result" -some--> -when-let -->] 9 (#$ . 71523)])) (byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put -some--> edebug-form-spec (form &rest &or symbolp consp) function-put lisp-indent-function 1] 4) #@257 Evaluate INIT and pass it as argument to FORMS with `->'. The RESULT of evaluating INIT is threaded through each of FORMS individually using `->', which see. The return value is RESULT, which FORMS may have modified by side effect. (fn INIT &rest FORMS) (defalias '-doto '(macro . #[385 "\300\301!\302DC\303\304\305\306\"\"C\"BB\207" [make-symbol "result" let append mapcar make-closure #[257 "\301\300E\207" [V0 ->] 4 "\n\n(fn FORM)"]] 10 (#$ . 72086)])) (byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put -doto edebug-form-spec (form &rest &or symbolp consp) function-put lisp-indent-function 1] 4) #@199 Anaphoric form of `-doto'. This just evaluates INIT, binds the result to `it', evaluates FORMS, and returns the final value of `it'. Note: `it' need not be used in each form. (fn INIT &rest FORMS) (defalias '--doto '(macro . #[385 "\300\301DC\302\303\"BB\207" [let it append (it)] 7 (#$ . 72718)])) (byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put --doto edebug-form-spec (form body) function-put lisp-indent-function 1] 4) #@179 Grade elements of LIST using COMPARATOR relation. This yields a permutation vector such that applying this permutation to LIST sorts it in ascending order. (fn COMPARATOR LIST) (defalias '-grade-up #[514 "\300\301\302\303\304\"\305\306\305\211\203*\211A\262\242\262\262T\262BB\262\202 \266\211\237\262\"\"\207" [mapcar cdr -sort make-closure #[514 "\300@@\"\207" [V0] 5 "\n\n(fn IT OTHER)"] nil 0] 13 (#$ . 73168)]) #@180 Grade elements of LIST using COMPARATOR relation. This yields a permutation vector such that applying this permutation to LIST sorts it in descending order. (fn COMPARATOR LIST) (defalias '-grade-down #[514 "\300\301\302\303\304\"\305\306\305\211\203*\211A\262\242\262\262T\262BB\262\202 \266\211\237\262\"\"\207" [mapcar cdr -sort make-closure #[514 "\300@@\"\207" [V0] 5 "\n\n(fn IT OTHER)"] nil 0] 13 (#$ . 73613)]) #@42 Monotonic counter for generated symbols. (defvar dash--source-counter 0 (#$ . 74060)) #@87 Generate a new dash-source symbol. All returned symbols are guaranteed to be unique. (defalias 'dash--match-make-source-symbol #[0 "\301\302\303\"!T\207" [dash--source-counter make-symbol format "--dash-source-%d--"] 4 (#$ . 74152)]) #@70 Return non-nil if SYMBOL is a symbol and starts with _. (fn SYMBOL) (defalias 'dash--match-ignore-place-p #[257 "\2119\205\f\300!\301H\302=\207" [symbol-name 0 95] 3 (#$ . 74396)]) #@75 Helper function generating idiomatic shifting code. (fn SKIP-CDR SOURCE) (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 (#$ . 74586)]) #@81 Helper function generating idiomatic code to get nth car. (fn SKIP-CDR SOURCE) (defalias 'dash--match-cons-get-car #[514 "\300U\203\n\301D\207\302U\203\303D\207\304E\207" [0 car 1 cadr nth] 5 (#$ . 74855)]) #@81 Helper function generating idiomatic code to get nth cdr. (fn SKIP-CDR SOURCE) (defalias 'dash--match-cons-get-cdr #[514 "\300U\203\207\301U\203\302D\207\303E\207" [0 1 cdr nthcdr] 5 (#$ . 75078)]) #@86 Setup a cons matching environment and call the real matcher. (fn MATCH-FORM SOURCE) (defalias 'dash--match-cons #[514 "\300 \301\211:\203\302@!\203T\262\211A\262\202\211:\203/\211A\204/\303@\304\"\"\207\301V\203>\303\305\"\"\207D\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 (#$ . 75292)]) #@47 Get expand function name for TYPE. (fn TYPE) (defalias 'dash--get-expand-function #[257 "\300\301\302\"!\207" [intern-soft format "dash-expand:%s"] 5 (#$ . 75730)]) #@386 Match MATCH-FORM against SOURCE. MATCH-FORM is a proper or improper list. Each element of MATCH-FORM is either a symbol, which gets bound to the respective value in source or another match form which gets destructured recursively. If the cdr of last cons cell in the list is `nil', matching stops there. SOURCE is a proper or improper list. (fn MATCH-FORM SOURCE &optional PROPS) (defalias 'dash--match-cons-1 #[770 "\300\301\"\206\302:\203]A\203S@9\203,\303\304@!!\203,\305\306!\307\"\"\207\310@!\203@\311A\312\301T##\207\313\314@\315\"\"\311A\"\"\207\314@\316\"\"\207\317=\203e\317\207\314\307\"\"\207" [plist-get :skip-cdr 0 functionp dash--get-expand-function 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 (#$ . 75904)]) #@88 Setup a vector matching environment and call the real matcher. (fn MATCH-FORM SOURCE) (defalias 'dash--match-vector #[514 "\300 G\301U\203\302\303H\304\305BB\"\2079\203\306\"\207\307\310\"\311\312\"G\211GSU\205@\313\312\"\302H\304E\"\262\266\202\206M\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 (#$ . 76845)]) #@691 Match MATCH-FORM against SOURCE. MATCH-FORM is a vector. Each element of MATCH-FORM is either a symbol, which gets bound to the respective value in source or another match form which gets destructured recursively. If second-from-last place in MATCH-FORM is the symbol &rest, the next element of the MATCH-FORM is matched against the tail of SOURCE, starting at index of the &rest symbol. This is conceptually the same as the (head . tail) match for improper lists, where dot plays the role of &rest. SOURCE is a vector. If the MATCH-FORM vector is shorter than SOURCE vector, only the (length MATCH-FORM) places are bound, the rest of the SOURCE is discarded. (fn MATCH-FORM SOURCE) (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 substring symbol-name 95 aref -flatten-n 1] 11 (#$ . 77303)]) #@148 Normalize kv PATTERN. This method normalizes PATTERN to the format expected by `dash--match-kv'. See `-let' for the specification. (fn PATTERN) (defalias 'dash--match-kv-normalize-match-form #[257 "\211@CC\300C\301\302!\303\304\305\306A AA#\"\307\310$\"\210\242\237\207" [nil make-symbol "--dash-fill-placeholder--" -each apply -zip -pad make-closure #[257 "\211@A\301\242\203 \301\303\240\207\302=\204<\2119\203*\304!\204*\211\305=\204*\211\303=\203\233\211:\2036\211@\306=\203\233\307!\204\233\304!\203Z\300\300\242B\240\210\300\310\311!\312\303O!\300\242B\240\210\202\227;\203r\300\300\242B\240\210\300\310!\300\242B\240\210\202\227:\203\221@\306=\203\221\300\300\242B\240\210\300A@\300\242B\240\210\202\227\313\314#\210\301\303\240\207\300\300\242B\240\210\300\300\242B\240\210\301\305\240\207" [V0 V1 V2 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)"]] 11 (#$ . 78333)]) #@152 Setup a kv matching environment and call the real matcher. kv can be any key-value store, such as plist, alist or hash-table. (fn MATCH-FORM SOURCE) (defalias 'dash--match-kv #[514 "\300 G\301U\203\302A@#\2079\203\302A@#\207\211D\302A@#B\207" [dash--match-make-source-symbol 3 dash--match-kv-1] 8 (#$ . 79403)]) #@79 Generate extracting KEY from SOURCE for &hash destructuring. (fn KEY SOURCE) (defalias 'dash-expand:&hash #[514 "\300E\207" [gethash] 5 (#$ . 79740)]) #@80 Generate extracting KEY from SOURCE for &plist destructuring. (fn KEY SOURCE) (defalias 'dash-expand:&plist #[514 "\300E\207" [plist-get] 5 (#$ . 79900)]) #@80 Generate extracting KEY from SOURCE for &alist destructuring. (fn KEY SOURCE) (defalias 'dash-expand:&alist #[514 "\300\301ED\207" [cdr assoc] 6 (#$ . 80064)]) #@135 Generate extracting KEY from SOURCE for &hash? destructuring. Similar to &hash but check whether the map is not nil. (fn KEY SOURCE) (defalias 'dash-expand:&hash\? #[514 "\300\301!\302DC\303\304EEE\207" [make-symbol "src" let when gethash] 10 (#$ . 80234)]) (defalias 'dash-expand:&keys 'dash-expand:&plist) #@509 Match MATCH-FORM against SOURCE of type TYPE. MATCH-FORM is a proper list of the form (key1 place1 ... keyN placeN). Each placeK is either a symbol, which gets bound to the value of keyK retrieved from the key-value store, or another match form which gets destructured recursively. SOURCE is a key-value store of type TYPE, which can be a plist, an alist or a hash table. TYPE is a token specifying the type of the key-value store. Valid values are &plist, &alist and &hash. (fn MATCH-FORM SOURCE TYPE) (defalias 'dash--match-kv-1 #[771 "\300\301\302\303\304#\305\306\"\"\"\207" [-flatten-n 1 -map make-closure #[257 "\211@A@\302\301!\300\"9\203DC\207\303\"\207" [V0 V1 dash--get-expand-function dash--match] 7 "\n\n(fn KV)"] -partition 2] 10 (#$ . 80557)]) #@96 Bind a symbol. This works just like `let', there is no destructuring. (fn MATCH-FORM SOURCE) (defalias 'dash--match-symbol #[514 "DC\207" [] 4 (#$ . 81341)]) #@281 Match MATCH-FORM against SOURCE. This function tests the MATCH-FORM and dispatches to specific matchers based on the type of the expression. Key-value stores are disambiguated by placing a token &plist, &alist or &hash as a first item in the MATCH-FORM. (fn MATCH-FORM SOURCE) (defalias 'dash--match #[514 "9\203\n\300\"\207:\203EA:\2030@9\2030A@\301=\2030@\211D\302AA\"B\207\303\304@!!\203@\305\306!\"\207\307\"\207\310!\205tG\311V\203p\312H9\203p\313H\301=\203p\312H\211D\302\311\314O\"B\207\315\"\207" [dash--match-symbol &as dash--match functionp dash--get-expand-function dash--match-kv dash--match-kv-normalize-match-form dash--match-cons vectorp 2 0 1 nil dash--match-vector] 8 (#$ . 81510)]) #@364 Normalize VARLIST so that every binding is a list. `let' allows specifying a binding which is not a list but simply the place which is then automatically bound to nil, such that all three of the following are identical and evaluate to nil. (let (a) a) (let ((a)) a) (let ((a nil)) a) This function normalizes all of these to the last form. (fn VARLIST) (defalias 'dash--normalize-let-varlist #[257 "\300\301\"\207" [mapcar #[257 "\211:\203\207\211\300D\207" [nil] 3 "\n\n(fn IT)"]] 4 (#$ . 82256)]) #@476 Bind variables according to VARLIST then eval BODY. VARLIST is a list of lists of the form (PATTERN SOURCE). Each PATTERN is matched against the SOURCE structurally. SOURCE is only evaluated once for each PATTERN. Each SOURCE can refer to the symbols already bound by this VARLIST. This is useful if you want to destructure SOURCE recursively but also want to name the intermediate structures. See `-let' for the list of all possible patterns. (fn VARLIST &rest BODY) (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 (#$ . 82775)])) (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) #@5684 Bind variables according to VARLIST then eval BODY. VARLIST is a list of lists of the form (PATTERN SOURCE). Each PATTERN is matched against the SOURCE "structurally". SOURCE is only evaluated once for each PATTERN. Each PATTERN is matched recursively, and can therefore contain sub-patterns which are matched against corresponding sub-expressions of SOURCE. All the SOURCEs are evalled before any symbols are bound (i.e. "in parallel"). If VARLIST only contains one (PATTERN SOURCE) element, you can optionally specify it using a vector and discarding the outer-most parens. Thus (-let ((PATTERN SOURCE)) ...) becomes (-let [PATTERN SOURCE] ...). `-let' uses a convention of not binding places (symbols) starting with _ whenever it's possible. You can use this to skip over entries you don't care about. However, this is not *always* possible (as a result of implementation) and these symbols might get bound to undefined values. Following is the overview of supported patterns. Remember that patterns can be matched recursively, so every a, b, aK in the following can be a matching construct and not necessarily a symbol/variable. Symbol: a - bind the SOURCE to A. This is just like regular `let'. Conses and lists: (a) - bind `car' of cons/list to A (a . b) - bind car of cons to A and `cdr' to B (a b) - bind car of list to A and `cadr' to B (a1 a2 a3 ...) - bind 0th car of list to A1, 1st to A2, 2nd to A3... (a1 a2 a3 ... aN . rest) - as above, but bind the Nth cdr to REST. Vectors: [a] - bind 0th element of a non-list sequence to A (works with vectors, strings, bit arrays...) [a1 a2 a3 ...] - bind 0th element of non-list sequence to A0, 1st to A1, 2nd to A2, ... If the PATTERN is shorter than SOURCE, the values at places not in PATTERN are ignored. If the PATTERN is longer than SOURCE, an `error' is thrown. [a1 a2 a3 ... &rest rest] - as above, but bind the rest of the sequence to REST. This is conceptually the same as improper list matching (a1 a2 ... aN . rest) Key/value stores: (&plist key0 a0 ... keyN aN) - bind value mapped by keyK in the SOURCE plist to aK. If the value is not found, aK is nil. Uses `plist-get' to fetch values. (&alist key0 a0 ... keyN aN) - bind value mapped by keyK in the SOURCE alist to aK. If the value is not found, aK is nil. Uses `assoc' to fetch values. (&hash key0 a0 ... keyN aN) - bind value mapped by keyK in the SOURCE hash table to aK. If the value is not found, aK is nil. Uses `gethash' to fetch values. Further, special keyword &keys supports "inline" matching of plist-like key-value pairs, similarly to &keys keyword of `cl-defun'. (a1 a2 ... aN &keys key1 b1 ... keyN bK) This binds N values from the list to a1 ... aN, then interprets the cdr as a plist (see key/value matching above). A shorthand notation for kv-destructuring exists which allows the patterns be optionally left out and derived from the key name in the following fashion: - a key :foo is converted into `foo' pattern, - a key 'bar is converted into `bar' pattern, - a key "baz" is converted into `baz' pattern. That is, the entire value under the key is bound to the derived variable without any further destructuring. This is possible only when the form following the key is not a valid pattern (i.e. not a symbol, a cons cell or a vector). Otherwise the matching proceeds as usual and in case of an invalid spec fails with an error. Thus the patterns are normalized as follows: ;; derive all the missing patterns (&plist :foo 'bar "baz") => (&plist :foo foo 'bar bar "baz" baz) ;; we can specify some but not others (&plist :foo 'bar explicit-bar) => (&plist :foo foo 'bar explicit-bar) ;; nothing happens, we store :foo in x (&plist :foo x) => (&plist :foo x) ;; nothing happens, we match recursively (&plist :foo (a b c)) => (&plist :foo (a b c)) You can name the source using the syntax SYMBOL &as PATTERN. This syntax works with lists (proper or improper), vectors and all types of maps. (list &as a b c) (list 1 2 3) binds A to 1, B to 2, C to 3 and LIST to (1 2 3). Similarly: (bounds &as beg . end) (cons 1 2) binds BEG to 1, END to 2 and BOUNDS to (1 . 2). (items &as first . rest) (list 1 2 3) binds FIRST to 1, REST to (2 3) and ITEMS to (1 2 3) [vect &as _ b c] [1 2 3] binds B to 2, C to 3 and VECT to [1 2 3] (_ avoids binding as usual). (plist &as &plist :b b) (list :a 1 :b 2 :c 3) binds B to 2 and PLIST to (:a 1 :b 2 :c 3). Same for &alist and &hash. This is especially useful when we want to capture the result of a computation and destructure at the same time. Consider the form (function-returning-complex-structure) returning a list of two vectors with two items each. We want to capture this entire result and pass it to another computation, but at the same time we want to get the second item from each vector. We can achieve it with pattern (result &as [_ a] [_ b]) (function-returning-complex-structure) Note: Clojure programmers may know this feature as the ":as binding". The difference is that we put the &as at the front because we need to support improper list binding. (fn VARLIST &rest BODY) (defalias '-let '(macro . #[385 "\300!\203\301\302\303H\304H\"BB\207\305!\306\303\306\211\203?\211A\262\242\262\262T\262\307\310\311\"!A@DB\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*] 12 (#$ . 83627)])) (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) #@427 Return a lambda which destructures its input as MATCH-FORM and executes BODY. Note that you have to enclose the MATCH-FORM in a pair of parens, such that: (-lambda (x) body) (-lambda (x y ...) body) has the usual semantics of `lambda'. Furthermore, these get translated into normal `lambda', so there is no performance penalty. See `-let' for a description of the destructuring mechanism. (fn MATCH-FORM &rest BODY) (defalias '-lambda '(macro . #[385 "<\204\f\300\301\302D\"\207\303\304\"\203\305BB\207\306\307\306\211\203@\211A\262\242\262\262T\262\310\311\312\"!DB\262\202\266\211\237\262\305\313\314\"\315BBE\207" [signal wrong-type-argument listp -all\? symbolp lambda nil 0 make-symbol format "input%d" mapcar cadr -let*] 12 (#$ . 89920)])) (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) #@530 Bind each MATCH-FORM to the value of its VAL. MATCH-FORM destructuring is done according to the rules of `-let'. This macro allows you to bind multiple variables by destructuring the value, so for example: (-setq (a b) x (&plist :c c) plist) expands roughly speaking to the following code (setq a (car x) b (cadr x) c (plist-get plist :c)) Care is taken to only evaluate each VAL once so that in case of multiple assignments it does not cause unexpected side effects. (fn [MATCH-FORM VAL]...) (defalias '-setq '(macro . #[128 "\300G\301\"\302U\203\303\304\305GTD\"\210\306\307\310\301\"\"\311\312\"\313\306\314\"\315\316\302\"\317\320\306\321\"!BE\317\320!BF\207" [mod 2 1 signal wrong-number-of-arguments -setq -map #[257 "\300@A@\"\207" [dash--match] 4 "\n\n(fn X)"] -partition -mapcat #[257 "\300\301\302\303\302\211\203,\211A\262\242\262\262T\262\304\305\306@!\"\204B\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] 12 "\n\n(fn BINDINGS)"] let cadr let* -flatten-n setq -flatten reverse] 12 (#$ . 90956)])) (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) #@320 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. Note: binding is done according to `-let*'. VALS are evaluated sequentially, and evaluation stops after the first nil VAL is encountered. (fn VARS-VALS THEN &rest ELSE) (defalias '-if-let* '(macro . #[642 "\300\301\302\303\304\"\"!\211G\305\211\306V\203<S\262\262H\262@A@\307DC\310\n\fBBBE\266\202\262\202\266\207" [vconcat apply append mapcar #[257 "\300@A@\"\207" [dash--match] 4 "\n\n(fn IT)"] nil 0 let if] 16 (#$ . 92333)])) (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) #@153 If VAL evaluates to non-nil, bind it to VAR and do THEN, otherwise do ELSE. Note: binding is done according to `-let'. (fn (VAR VAL) THEN &rest ELSE) (defalias '-if-let '(macro . #[642 "\300CBBB\207" [-if-let*] 7 (#$ . 93108)])) (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) #@111 If VAL evaluates to non-nil, bind it to symbol `it' and do THEN, otherwise do ELSE. (fn VAL THEN &rest ELSE) (defalias '--if-let '(macro . #[642 "\300\301DBBB\207" [-if-let it] 7 (#$ . 93503)])) (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) #@301 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. Note: binding is done according to `-let*'. VALS are evaluated sequentially, and evaluation stops after the first nil VAL is encountered. (fn VARS-VALS &rest BODY) (defalias '-when-let* '(macro . #[385 "\300\301BE\207" [-if-let* progn] 6 (#$ . 93857)])) (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) #@134 If VAL evaluates to non-nil, bind it to VAR and execute body. Note: binding is done according to `-let'. (fn (VAR VAL) &rest BODY) (defalias '-when-let '(macro . #[385 "\300\301BE\207" [-if-let progn] 6 (#$ . 94416)])) (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) #@92 If VAL evaluates to non-nil, bind it to symbol `it' and execute body. (fn VAL &rest BODY) (defalias '--when-let '(macro . #[385 "\300\301BE\207" [--if-let progn] 6 (#$ . 94796)])) (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) #@191 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 (#$ . 95131)) #@160 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' (fn LIST) (defalias '-distinct #[257 "\211G\211\301V\205\302>\205\303\304\206\305\306$\211\203R\307\310\307\211\203M\211A\262\242\262\262T\262\311\"\204!\312\313#\203!B\262\202!\266\211\237\207\310\307\211\203x\211A\262\242\262\262T\262\314\"\204VB\262\202V\266\211\237\207" [-compare-fn 32 (nil equal eq eql) make-hash-table :test equal :size nil 0 gethash puthash t -contains\?] 12 (#$ . 95366)]) (defalias '-uniq '-distinct) #@197 Return a new list containing the elements of LIST and elements of LIST2 that are not in LIST. The test for equality is done with `equal', or with `-compare-fn' if that's non-nil. (fn LIST LIST2) (defalias '-union #[514 "\301!\302\300!\203\203\202\303\211\304>\203m\305\306\"\307\310\211\203>\211A\262\242\262\262T\262\311\312#\210\202!\266\307\310\211\203h\211A\262\242\262\262T\262\313\"\204DB\262\202D\266\202\225\307\310\211\203\223\211A\262\242\262\262T\262\314\"\204qB\262\202q\266\211\237)\207" [-compare-fn reverse boundp equal (eq eql equal) make-hash-table :test 0 nil puthash t gethash -contains\?] 13 (#$ . 96001)]) #@191 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. (fn LIST LIST2) (defalias '-intersection #[514 "\300\301\300\211\203(\211A\262\242\262\262T\262\302\"\203B\262\202\266\211\237\207" [nil 0 -contains\?] 10 (#$ . 96702)]) #@174 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. (fn LIST LIST2) (defalias '-difference #[514 "\300\301\300\211\203(\211A\262\242\262\262T\262\302\"\204B\262\202\266\211\237\207" [nil 0 -contains\?] 10 (#$ . 97074)]) #@42 Return the power set of LIST. (fn LIST) (defalias '-powerset #[257 "\211\204\300\207\301A!\302\303\304\305\"\"\"\207" [(nil) -powerset append mapcar make-closure #[257 "\300@B\207" [V0] 3 "\n\n(fn X)"]] 7 (#$ . 97426)]) #@45 Return the permutations of LIST. (fn LIST) (defalias '-permutations #[257 "\211\204\300\207\301\302\303\304\305\"\"\"\207" [(nil) apply append mapcar make-closure #[257 "\301\302\303\"\304\305\300\"!\"\207" [V0 mapcar make-closure #[257 "\300B\207" [V0] 3 "\n\n(fn PERM)"] -permutations remove] 7 "\n\n(fn X)"]] 7 (#$ . 97660)]) #@41 Return all prefixes of LIST. (fn LIST) (defalias '-inits #[257 "\211C\300!\262\203\300A\211\262!B\262\202\207" [reverse] 5 (#$ . 98003)]) #@40 Return all suffixes of LIST (fn LIST) (defalias '-tails #[257 "\300\301\302#\207" [-reductions-r-from cons nil] 5 (#$ . 98159)]) #@62 Return the longest common prefix of LISTS. (fn &rest LISTS) (defalias '-common-prefix #[128 "\211\211\203m\211@A\300\301\211\203j\211A\262\242\262\262T\262\301\300\301\211\211\203_\211A\262\242\262\262\211\262\203_\n\203_\n\211A\262\f\242\232\203_\262\262T\262B\262\202%\266\211\237\262\262\202\f\266\207\301\211\211\300\301\211\211\203\256\211A\262\242\262\262\211\262\203\256\203\256\211A\262\242\232\203\256\262\262T\262B\262\202t\266\211\237\207" [0 nil] 15 (#$ . 98296)]) (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -common-prefix pure t side-effect-free] 5) #@62 Return the longest common suffix of LISTS. (fn &rest LISTS) (defalias '-common-suffix #[128 "\300\301\302\303\"\"\237\207" [apply -common-prefix mapcar reverse] 6 (#$ . 98966)]) #@169 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' (fn LIST ELEMENT) (defalias '-contains\? #[514 "\204\n\211\235\2024\301\267\202\211>\2024\302\"\2024\211\2031@\"\2041\211A\262\202\211\262??\207" [-compare-fn #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (eq 16 eql 22)) memql] 6 (#$ . 99153)]) (defalias '-contains-p '-contains\?) #@149 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' (fn LIST LIST2) (defalias '-same-items\? #[514 "GGU\205\300\"GU\207" [-intersection] 8 (#$ . 99653)]) (defalias '-same-items-p '-same-items\?) #@89 Return non-nil if PREFIX is a prefix of LIST. Alias: `-is-prefix-p'. (fn PREFIX LIST) (defalias '-is-prefix\? #[514 "\211\300\301\211\211\2039\211A\262\242\262\262\211\262\2039@\232\2039A\211\262\2039\262\262T\262\202\266?\207" [0 nil] 9 (#$ . 99943)]) (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -is-prefix\? pure t side-effect-free] 5) #@89 Return non-nil if SUFFIX is a suffix of LIST. Alias: `-is-suffix-p'. (fn SUFFIX LIST) (defalias '-is-suffix\? #[514 "?\206@\235\211\262\205AA\232\207" [] 4 (#$ . 100343)]) (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -is-suffix\? pure t side-effect-free] 5) #@118 Return non-nil if INFIX is infix of LIST. This operation runs in O(n^2) time Alias: `-is-infix-p' (fn INFIX LIST) (defalias '-is-infix\? #[514 "\300\211\204\203\301\"\262A\262\202\207" [nil -is-prefix\?] 6 (#$ . 100645)]) (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) #@268 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. (fn COMPARATOR LIST) (defalias '-sort #[514 "\300\301!\"\207" [sort copy-sequence] 5 (#$ . 101118)]) #@44 Anaphoric form of `-sort'. (fn FORM LIST) (defalias '--sort '(macro . #[514 "\300\301\302EE\207" [-sort lambda (it other)] 6 (#$ . 101473)])) (put '--sort 'edebug-form-spec '(def-form form)) #@398 Ensure ARG is a list. If ARG is already a list, return it as is (not a copy). Otherwise, return a new list with ARG as its only element. Another supported calling convention is (-list &rest ARGS). In this case, if ARG is not a list, a new list with all of ARGS as elements is returned. This use is supported for backward compatibility and is otherwise deprecated. (fn &optional ARG &rest ARGS) (defalias '-list #[384 "<\203\207B\207" [] 4 (#$ . 101674)]) (byte-code "\300\301\302\303#\210\304\301\305\306#\304\301\307\306#\300\207" [set-advertised-calling-convention -list (arg) "2.18.0" function-put pure t side-effect-free] 5) #@100 Return a new list of length N with each element being X. Return nil if N is less than 1. (fn N X) (defalias '-repeat #[514 "\300!\205\n\301\"\207" [natnump make-list] 5 (#$ . 102319)]) (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -repeat pure t side-effect-free] 5) #@36 Return the sum of LIST. (fn LIST) (defalias '-sum #[257 "\300\301\"\207" [apply +] 4 (#$ . 102621)]) (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -sum pure t side-effect-free] 5) #@86 Return a list with running sums of items in LIST. LIST must be non-empty. (fn LIST) (defalias '-running-sum #[257 "\211\204 \300\301\302D\"\210\303\304\"\207" [signal wrong-type-argument consp -reductions +] 5 (#$ . 102833)]) (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -running-sum pure t side-effect-free] 5) #@40 Return the product of LIST. (fn LIST) (defalias '-product #[257 "\300\301\"\207" [apply *] 4 (#$ . 103180)]) (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -product pure t side-effect-free] 5) #@90 Return a list with running products of items in LIST. LIST must be non-empty. (fn LIST) (defalias '-running-product #[257 "\211\204 \300\301\302D\"\210\303\304\"\207" [signal wrong-type-argument consp -reductions *] 5 (#$ . 103404)]) (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -running-product pure t side-effect-free] 5) #@70 Return the largest value from LIST of numbers or markers. (fn LIST) (defalias '-max #[257 "\300\301\"\207" [apply max] 4 (#$ . 103763)]) (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -max pure t side-effect-free] 5) #@71 Return the smallest value from LIST of numbers or markers. (fn LIST) (defalias '-min #[257 "\300\301\"\207" [apply min] 4 (#$ . 104011)]) (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -min pure t side-effect-free] 5) #@225 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. (fn COMPARATOR LIST) (defalias '-max-by #[514 "\211\211\2035\211@A\300\301\211\2032\211A\262\242\262\262T\262\"\203,\202-\262\202\f\266\207\301\211\"\210\301\207" [0 nil] 11 (#$ . 104261)]) #@222 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. (fn COMPARATOR LIST) (defalias '-min-by #[514 "\211\211\2035\211@A\300\301\211\2032\211A\262\242\262\262T\262\"\203,\202-\262\202\f\266\207\301\211\"\210\301\207" [0 nil] 11 (#$ . 104685)]) #@117 Anaphoric version of `-max-by'. The items for the comparator form are exposed as "it" and "other". (fn FORM LIST) (defalias '--max-by '(macro . #[514 "\300\301\302EE\207" [-max-by lambda (it other)] 6 (#$ . 105106)])) (put '--max-by 'edebug-form-spec '(def-form form)) #@117 Anaphoric version of `-min-by'. The items for the comparator form are exposed as "it" and "other". (fn FORM LIST) (defalias '--min-by '(macro . #[514 "\300\301\302EE\207" [-min-by lambda (it other)] 6 (#$ . 105386)])) (put '--min-by 'edebug-form-spec '(def-form form)) #@251 Return a list containing COUNT numbers. Starts from START and adds STEP each time. The default START is zero, the default STEP is 1. This function takes its name from the corresponding primitive in the APL language. (fn COUNT &optional START STEP) (defalias '-iota #[769 "\300!\204 \301\302\300D\"\210\204\303\262\211\204\304\262\211\303U\203&\305\"\207\211\303V\205S\211CS\303\211W\203M\306\\\211\262B\262\210\211T\262\2023\266\211\237\266\202\207" [natnump signal wrong-type-argument 0 1 make-list nil] 11 (#$ . 105666)]) (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -iota pure t side-effect-free] 5) #@139 Compute the (least) fixpoint of FN with initial input LIST. FN is called at least once, results are compared with `equal'. (fn FN LIST) (defalias '-fix #[514 "!\232\204\211\262!\262\202\207" [] 5 (#$ . 106331)]) #@43 Anaphoric form of `-fix'. (fn FORM LIST) (defalias '--fix '(macro . #[514 "\300\301\302EE\207" [-fix lambda (it)] 6 (#$ . 106563)])) (put '--fix 'edebug-form-spec '(def-form form)) #@362 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. (fn FUN SEED) (defalias '-unfold #[514 "!\300\203@B\262A!\262\202\211\237\207" [nil] 6 (#$ . 106754)]) #@49 Anaphoric version of `-unfold'. (fn FORM SEED) (defalias '--unfold '(macro . #[514 "\300\301\302EE\207" [-unfold lambda (it)] 6 (#$ . 107223)])) (put '--unfold 'edebug-form-spec '(def-form form)) #@125 Return non-nil if OBJ is a true cons pair. That is, a cons (A . B) where B is not a list. Alias: `-cons-pair-p'. (fn OBJ) (defalias '-cons-pair\? #[257 "\211\243 b -> a (fn C) (defalias '-const #[257 "\300\301\"\207" [make-closure #[128 "\300\207" [V0] 2 "\n\n(fn &rest _)"]] 4 (#$ . 119036)]) (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -const pure t side-effect-free] 5) #@176 Take n-ary function and n arguments and specialize some of them. Arguments denoted by <> will be left unspecialized. See SRFI-26 for detailed description. (fn &rest PARAMS) (defalias '-cut '(macro . #[128 "\300\301\300\301\211\2038\211A\262\242\262\262T\262\302=\205*T\262\303\304\305\"!\211\2034\211B\262\210\202\266\211\237\262C\306\242\307\310\311\"\"@\302=\203W\312B\202X\211\262E\207" [0 nil <> make-symbol format "D%d" lambda mapcar make-closure #[257 "\211\301=\203\300\242\300\211\242A\240\210\242\207\207" [V0 <>] 4 "\n\n(fn IT)"] funcall] 11 (#$ . 119366)])) (put '-cut 'edebug-form-spec '(&optional sexp &rest &or "<>" form)) #@224 Return a predicate that negates the result of PRED. The returned predicate passes its arguments to PRED. If PRED returns nil, the result is non-nil; otherwise the result is nil. See also: `-andfn' and `-orfn'. (fn PRED) (defalias '-not #[257 "\300\301\"\207" [make-closure #[128 "\301\300\"?\207" [V0 apply] 4 "\n\n(fn &rest ARGS)"]] 4 (#$ . 120047)]) (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -not pure t side-effect-free] 5) #@418 Return a predicate that returns the first non-nil result of PREDS. The returned predicate takes a variable number of arguments, passes them to each predicate in PREDS in turn until one of them returns non-nil, and returns that non-nil result without calling the remaining PREDS. If all PREDS return nil, or if no PREDS are given, the returned predicate returns nil. See also: `-andfn' and `-not'. (fn &rest PREDS) (defalias '-orfn #[128 "\211A\203\n\300\301\"\207\211\203\211@\207\302\207" [make-closure #[128 "\301\300\302\301\211\211\2034\211A\262\242\262\262\211\262\2034\303\"\211\262\2044\262\262T\262\202\266\207" [V0 nil 0 apply] 10 "\n\n(fn &rest ARGS)"] ignore] 4 (#$ . 120514)]) (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -orfn pure t side-effect-free] 5) #@425 Return a predicate that returns non-nil if all PREDS do so. The returned predicate P takes a variable number of arguments and passes them to each predicate in PREDS in turn. If any one of PREDS returns nil, P also returns nil without calling the remaining PREDS. If all PREDS return non-nil, P returns the last such value. If no PREDS are given, P always returns non-nil. See also: `-orfn' and `-not'. (fn &rest PREDS) (defalias '-andfn #[128 "\211A\203\n\300\301\"\207\211\203\211@\207\302\303!\203\303\207\304\207" [make-closure #[128 "\301\300\302\303\211\211\2034\211A\262\242\262\262\211\262\2034\304\"\211\262\2034\262\262T\262\202\266\207" [V0 t 0 nil apply] 10 "\n\n(fn &rest ARGS)"] fboundp always #[128 "\300\207" [t] 2 "\n\n(fn &rest _)"]] 4 (#$ . 121345)]) (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put -andfn pure t side-effect-free] 5) #@396 Return a function FN composed N times with itself. FN is a unary function. If you need to use a function of higher arity, use `-applify' first to turn it into a unary function. With n = 0, this acts as identity function. In types: (a -> a) -> Int -> a -> a. This function satisfies the following law: (funcall (-iteratefn fn n) init) = (-last-item (-iterate fn init (1+ n))). (fn FN N) (defalias '-iteratefn #[514 "\300\301#\207" [make-closure #[257 "\301\302\303W\203\262T\262\300!\262\202\266\207" [V0 V1 0 nil] 6 "\n\n(fn X)"]] 6 (#$ . 122261)]) #@379 Return a closure that counts from BEG to END, with increment INC. The closure will return the next value in the counting sequence each time it is called, and nil after END is reached. BEG defaults to 0, INC defaults to 1, and if END is nil, the counter will increment indefinitely. The closure accepts any number of arguments, which are discarded. (fn &optional BEG END INC) (defalias '-counter #[768 "\211\206\300\206\n\301C\302\303$\207" [1 0 make-closure #[128 "\300\203 \302\242\300W\205\302\242\302\211\242\301\\\240\210\207" [V0 V1 V2] 5 "\n\n(fn &rest _)"]] 10 (#$ . 122841)]) #@94 The default maximum number of iterations performed by `-fixfn' unless otherwise specified. (defvar -fixfn-max-iterations 1000 (#$ . 123444)) #@1190 Return a function that computes the (least) fixpoint of FN. FN must be a unary function. The returned lambda takes a single argument, X, the initial value for the fixpoint iteration. The iteration halts when either of the following conditions is satisfied: 1. Iteration converges to the fixpoint, with equality being tested using EQUAL-TEST. If EQUAL-TEST is not specified, `equal' is used. For functions over the floating point numbers, it may be necessary to provide an appropriate approximate comparison test. 2. HALT-TEST returns a non-nil value. HALT-TEST defaults to a simple counter that returns t after `-fixfn-max-iterations', to guard against infinite iteration. Otherwise, HALT-TEST must be a function that accepts a single argument, the current value of X, and returns non-nil as long as iteration should continue. In this way, a more sophisticated convergence test may be supplied by the caller. The return value of the lambda is either the fixpoint or, if iteration halted before converging, a cons with car `halted' and cdr the final output from HALT-TEST. In types: (a -> a) -> a -> a. (fn FN &optional EQUAL-TEST HALT-TEST) (defalias '-fixfn #[769 "\206\301\206\302\303\304\"!\305\306$\207" [-fixfn-max-iterations equal -not -counter 0 make-closure #[257 "\300!\302!\211\204!\301\"\204!\262\300!\262\302!\262\202\211\203)\303B\207\207" [V0 V1 V2 halted] 6 "\n\n(fn X)"]] 10 (#$ . 123595)]) #@689 Take a list of n functions and return a function that takes a list of length n, applying i-th function to i-th element of the input list. Returns a list of length n. In types (for n=2): ((a -> b), (c -> d)) -> (a, c) -> (b, d) This function satisfies the following laws: (-compose (-prodfn f g ...) (-prodfn f\=' g\=' ...)) = (-prodfn (-compose f f\=') (-compose g g\=') ...) (-prodfn f g ...) = (-juxt (-compose f (-partial \='nth 0)) (-compose g (-partial \='nth 1)) ...) (-compose (-prodfn f g ...) (-juxt f\=' g\=' ...)) = (-juxt (-compose f f\=') (-compose g g\=') ...) (-compose (-partial \='nth n) (-prod f1 f2 ...)) = (-compose fn (-partial \='nth n)) (fn &rest FNS) (defalias '-prodfn #[128 "\300\301\"\207" [make-closure #[257 "\301\302\300#\207" [V0 -zip-with funcall] 5 "\n\n(fn X)"]] 4 (#$ . 125085)]) #@45 Font lock keywords for `dash-fontify-mode'. (defvar dash--keywords (byte-code "\301\302B\303\304B\305\306W\205\307\310\311\312\"P\313BC\262BBB\207" [emacs-major-version "\\_<\\(?:acc\\|it\\(?:-index\\)?\\|other\\)\\_>" (0 font-lock-variable-name-face) "(\\(\\(?:def\\(?:-example-group\\|examples\\)\\)\\)\\_>[ ]+\\(\\(?:\\sw\\|\\s_\\|\\\\.\\)*\\)" ((1 font-lock-keyword-face) (2 font-lock-function-name-face)) "\\_<\\(?:\\(?:!!\\|[=~]\\)>\\)\\_>" 25 ("!cdr" "!cons" "-->" "--all?" "--annotate" "--any?" "--count" "--dotimes" "--doto" "--drop-while" "--each" "--each-r" "--each-r-while" "--each-while" "--filter" "--find-index" "--find-indices" "--find-last-index" "--first" "--fix" "--group-by" "--if-let" "--iterate" "--keep" "--last" "--map" "--map-first" "--map-indexed" "--map-last" "--map-when" "--mapcat" "--max-by" "--min-by" "--none?" "--only-some?" "--partition-by" "--partition-by-header" "--reduce" "--reduce-from" "--reduce-r" "--reduce-r-from" "--reductions" "--reductions-from" "--reductions-r" "--reductions-r-from" "--remove" "--remove-first" "--remove-last" "--separate" "--some" "--sort" "--splice" "--splice-list" "--split-when" "--split-with" "--take-while" "--tree-map" "--tree-map-nodes" "--tree-mapreduce" "--tree-mapreduce-from" "--tree-reduce" "--tree-reduce-from" "--tree-seq" "--unfold" "--update-at" "--when-let" "--zip-with" "->" "->>" "-as->" "-doto" "-if-let" "-if-let*" "-lambda" "-let" "-let*" "-setq" "-some-->" "-some->" "-some->>" "-split-on" "-when-let" "-when-let*") "(" regexp-opt symbols 1] 8) (#$ . 125921)) (byte-code "\300\301\302\303\304DD\305\306\307\310\311\312\313& \207" [custom-declare-variable dash-fontify-mode-lighter funcall function #[0 "\300\207" [nil] 1] "Mode line lighter for `dash-fontify-mode'.\nEither a string to display in the mode line when\n`dash-fontify-mode' is on, or nil to display\nnothing (the default)." :package-version (dash . "2.18.0") :group dash :type (choice (string :tag "Lighter" :value " Dash") (const :tag "Nothing" nil))] 10) #@103 Non-nil if Dash-Fontify mode is enabled. Use the command `dash-fontify-mode' to change this variable. (defvar dash-fontify-mode nil (#$ . 127943)) (make-variable-buffer-local 'dash-fontify-mode) #@1035 Toggle fontification of Dash special variables. This is a minor mode. If called interactively, toggle the `Dash-Fontify mode' mode. If the prefix argument is positive, enable the mode, and if it is zero or negative, disable the mode. If called from Lisp, toggle the mode if ARG is `toggle'. Enable the mode if ARG is nil, omitted, or is a positive number. Disable the mode if ARG is a negative number. To check whether the minor mode is enabled in the current buffer, evaluate `dash-fontify-mode'. The mode's hook is called both when the mode is enabled and when it is disabled. Dash-Fontify mode is a buffer-local minor mode intended for Emacs Lisp buffers. Enabling it causes the special variables bound in anaphoric Dash macros to be fontified. These anaphoras include `it', `it-index', `acc', and `other'. In older Emacs versions which do not dynamically detect macros, Dash-Fontify mode additionally fontifies Dash macro calls. See also `dash-fontify-mode-lighter' and `global-dash-fontify-mode'. (fn &optional ARG) (defalias 'dash-fontify-mode #[256 "\304 \305=\203 ?\202\247\203\306W\203\307\202\310\311\301!\2031\312\300 \"\2031\300 B\203>\313\307\n\310#\210\202C\314\307\n\"\210\315\316!\203O\316 \210\202V \203V\317 \210\320\321\203`\322\202a\323\"\210\324\325!\203\203\304 \203u\211\304 \232\203\203\326\327\203\330\202\200\331\332#\210\210\333 \210\207" [dash-fontify-mode local-minor-modes dash--keywords font-lock-mode current-message toggle 1 nil t boundp delq font-lock-add-keywords font-lock-remove-keywords fboundp font-lock-flush font-lock-fontify-buffer run-hooks dash-fontify-mode-hook dash-fontify-mode-on-hook dash-fontify-mode-off-hook called-interactively-p any message "Dash-Fontify mode %sabled%s" "en" "dis" " in current buffer" force-mode-line-update] 6 (#$ . 128146) (byte-code "\203\n\301!\202 \302C\207" [current-prefix-arg prefix-numeric-value toggle] 2)]) (defvar dash-fontify-mode-hook nil) (byte-code "\301\302N\204\f\303\301\302\304#\210\303\301\305\306#\210\303\301\307\310C#\210\311\312\313\314\300!\205#\310\211%\207" [dash-fontify-mode-map dash-fontify-mode-hook variable-documentation put "Hook run after entering or leaving `dash-fontify-mode'.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it. (This is true for all hook variables.)" custom-type hook standard-value nil add-minor-mode dash-fontify-mode dash-fontify-mode-lighter boundp] 6) #@56 Enable `dash-fontify-mode' if in an Emacs Lisp buffer. (defalias 'dash--turn-on-fontify-mode #[0 "\300\301!\205\302 \207" [derived-mode-p emacs-lisp-mode dash-fontify-mode] 2 (#$ . 130630)]) (put 'global-dash-fontify-mode 'globalized-minor-mode t) (defvar dash-fontify-mode-major-mode nil nil) (byte-code "\300\301!\210\302\303\304\305\306DD\307\310\311\312\313\314\315\316\317& \207" [make-variable-buffer-local dash-fontify-mode-major-mode custom-declare-variable global-dash-fontify-mode funcall function #[0 "\300\207" [nil] 1] "Non-nil if Global Dash-Fontify mode is enabled.\nSee the `global-dash-fontify-mode' command\nfor a description of this minor mode.\nSetting this variable directly does not take effect;\neither customize it (see the info node `Easy Customization')\nor call the function `global-dash-fontify-mode'." :set custom-set-minor-mode :initialize custom-initialize-default :type boolean :group dash] 12) #@379 Toggle Dash-Fontify mode in all buffers. With prefix ARG, enable Global Dash-Fontify mode if ARG is positive; otherwise, disable it. If called from Lisp, enable the mode if ARG is omitted or nil. Dash-Fontify mode is enabled in all buffers where `dash--turn-on-fontify-mode' would do it. See `dash-fontify-mode' for more information on Dash-Fontify mode. (fn &optional ARG) (defalias 'global-dash-fontify-mode #[256 "\303 \304\301\305=\203\306\301!?\202!\247\203 \307W\203 \310\202!\311\"\210\312\300!\2038\313\301\"\306\301!\2038\301B \203N\314\315\316\"\210\314\317\320\"\210\314\321\322\"\210\202]\323\315\316\"\210\323\317\320\"\210\323\321\322\"\210\324 \211\203\203\211@r\211q\210 \203s\325 \210\202{\n\203{\302\326!\210)A\266\202\202_\210\327\330\306\301!\203\220\331\202\221\332\"\210\333\334!\203\271\335\301!\210\303 \203\251\211\303 \232\203\271\336\337\306\301!\203\265\340\202\266\341\342#\210\210\343 \210\306\301!\207" [global-minor-modes global-dash-fontify-mode dash-fontify-mode current-message set-default toggle default-value 1 nil t boundp delq add-hook after-change-major-mode-hook global-dash-fontify-mode-enable-in-buffers find-file-hook global-dash-fontify-mode-check-buffers change-major-mode-hook global-dash-fontify-mode-cmhh remove-hook buffer-list dash--turn-on-fontify-mode -1 run-hooks global-dash-fontify-mode-hook global-dash-fontify-mode-on-hook global-dash-fontify-mode-off-hook called-interactively-p any customize-mark-as-set message "Global Dash-Fontify mode %sabled%s" "en" "dis" "" force-mode-line-update] 6 (#$ . 131566) (byte-code "\203\n\301!\202 \302C\207" [current-prefix-arg prefix-numeric-value toggle] 2)]) (defvar global-dash-fontify-mode-hook nil) (byte-code "\301\302N\204\f\303\301\302\304#\210\303\301\305\306#\210\303\301\307\310C#\210\311\312\310\313\300!\205#\310\211%\207" [global-dash-fontify-mode-map global-dash-fontify-mode-hook variable-documentation put "Hook run after entering or leaving `global-dash-fontify-mode'.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it. (This is true for all hook variables.)" custom-type hook standard-value nil add-minor-mode global-dash-fontify-mode boundp] 6) (defvar dash-fontify-mode-set-explicitly nil nil) (make-variable-buffer-local 'dash-fontify-mode-set-explicitly) (defalias 'dash-fontify-mode-set-explicitly #[0 "\301\211\207" [dash-fontify-mode-set-explicitly t] 2]) (byte-code "\300\301\302\303#\210\304\305\301\"\207" [put dash-fontify-mode-set-explicitly definition-name global-dash-fontify-mode add-hook dash-fontify-mode-hook] 4) (defvar global-dash-fontify-mode-buffers nil) (defalias 'global-dash-fontify-mode-enable-in-buffers #[0 "\305\211\211\2059\211@\306!\2032r\211q\210 \204/\n =\204/\f\203,\304\307!\210\310 \210\202/\310 \210 )A\266\202\202\207" [global-dash-fontify-mode-buffers dash-fontify-mode-set-explicitly dash-fontify-mode-major-mode major-mode dash-fontify-mode nil buffer-live-p -1 dash--turn-on-fontify-mode] 5]) (put 'global-dash-fontify-mode-enable-in-buffers 'definition-name 'global-dash-fontify-mode) (defalias 'global-dash-fontify-mode-check-buffers #[0 "\300 \210\301\302\303\"\207" [global-dash-fontify-mode-enable-in-buffers remove-hook post-command-hook global-dash-fontify-mode-check-buffers] 3]) (put 'global-dash-fontify-mode-check-buffers 'definition-name 'global-dash-fontify-mode) (defalias 'global-dash-fontify-mode-cmhh #[0 "p\211\235\204 \211B\210\301\302\303\"\207" [global-dash-fontify-mode-buffers add-hook post-command-hook global-dash-fontify-mode-check-buffers] 3]) (byte-code "\300\301\302\303#\210\304\305\306\307\310DD\311\312\313\314\315\316\317& \210\320\305\303\321#\210\322\323\303\324#\210\325\323\303\321#\207" [put global-dash-fontify-mode-cmhh definition-name global-dash-fontify-mode custom-declare-variable dash-enable-fontlock funcall function #[0 "\300\207" [nil] 1] "If non-nil, fontify Dash macro calls and special variables." :group dash :set #[514 "\300\"\210\301\203\302\202\303!\207" [set-default global-dash-fontify-mode 1 0] 5 "\n\n(fn SYM VAL)"] :type boolean make-obsolete-variable "2.18.0" defalias dash-enable-font-lock nil make-obsolete] 10) #@94 The Dash :doc-spec entry for `info-lookup-alist'. It is based on that for `emacs-lisp-mode'. (defvar dash--info-doc-spec '("(dash) Index" nil "^ -+ .*: " "\\( \\|$\\)") (#$ . 135806)) #@165 Return the `emacs-lisp-mode' symbol docs from `info-lookup-alist'. Specifically, return the cons containing their `info-lookup->doc-spec' so that we can modify it. (defalias 'dash--info-elisp-docs #[0 "\301\302\303\236A\236\233\207" [info-lookup-alist 3 emacs-lisp-mode symbol] 4 (#$ . 135997)]) #@127 Register the Dash Info manual with `info-lookup-symbol'. This allows Dash symbols to be looked up with \[info-lookup-symbol]. (defalias 'dash-register-info-lookup #[0 "\301\302!\210\303 \211\304@C\"\240\210\305 \207" [dash--info-doc-spec require info-look dash--info-elisp-docs append info-lookup-reset] 5 (#$ . 136301) nil]) #@76 Remove Dash from `info-lookup-alist'. Used by `unload-feature', which see. (defalias 'dash-unload-function #[0 "\301\302!\205\303 @\235\203\211\304@\"\240\210\305 \210\210\306\207" [dash--info-doc-spec featurep info-look dash--info-elisp-docs remove info-lookup-reset nil] 5 (#$ . 136635)]) (provide 'dash)