diff --git a/elpa/dash-20210330.1544/dash-autoloads.el b/elpa/dash-20210609.1330/dash-autoloads.el similarity index 100% rename from elpa/dash-20210330.1544/dash-autoloads.el rename to elpa/dash-20210609.1330/dash-autoloads.el diff --git a/elpa/dash-20210330.1544/dash-pkg.el b/elpa/dash-20210609.1330/dash-pkg.el similarity index 67% rename from elpa/dash-20210330.1544/dash-pkg.el rename to elpa/dash-20210609.1330/dash-pkg.el index 92d619a..befa385 100644 --- a/elpa/dash-20210330.1544/dash-pkg.el +++ b/elpa/dash-20210609.1330/dash-pkg.el @@ -1,6 +1,6 @@ -(define-package "dash" "20210330.1544" "A modern list library for Emacs" +(define-package "dash" "20210609.1330" "A modern list library for Emacs" '((emacs "24")) - :commit "b9286a84975874b10493f1cb4ea051c501f51273" :authors + :commit "88d799595e8f1b4154637ce8a3f81b97b0520c1a" :authors '(("Magnar Sveen" . "magnars@gmail.com")) :maintainer '("Magnar Sveen" . "magnars@gmail.com") diff --git a/elpa/dash-20210330.1544/dash.el b/elpa/dash-20210609.1330/dash.el similarity index 98% rename from elpa/dash-20210330.1544/dash.el rename to elpa/dash-20210609.1330/dash.el index af22ef9..be50166 100644 --- a/elpa/dash-20210330.1544/dash.el +++ b/elpa/dash-20210609.1330/dash.el @@ -43,10 +43,12 @@ (defmacro !cons (car cdr) "Destructive: Set CDR to the cons of CAR and CDR." + (declare (debug (form symbolp))) `(setq ,cdr (cons ,car ,cdr))) (defmacro !cdr (list) "Destructive: Set LIST to the cdr of LIST." + (declare (debug (symbolp))) `(setq ,list (cdr ,list))) (defmacro --each (list &rest body) @@ -637,6 +639,7 @@ See also: `-map-when', `-replace-first'" (defmacro --map-first (pred rep list) "Anaphoric form of `-map-first'." + (declare (debug (def-form def-form form))) `(-map-first (lambda (it) ,pred) (lambda (it) (ignore it) ,rep) ,list)) (defun -map-last (pred rep list) @@ -647,6 +650,7 @@ See also: `-map-when', `-replace-last'" (defmacro --map-last (pred rep list) "Anaphoric form of `-map-last'." + (declare (debug (def-form def-form form))) `(-map-last (lambda (it) ,pred) (lambda (it) (ignore it) ,rep) ,list)) (defun -replace (old new list) @@ -765,6 +769,7 @@ See also: `-splice-list', `-insert-at'" (defmacro --splice (pred form list) "Anaphoric form of `-splice'." + (declare (debug (def-form def-form form))) `(-splice (lambda (it) ,pred) (lambda (it) ,form) ,list)) (defun -splice-list (pred new-list list) @@ -775,6 +780,7 @@ See also: `-splice', `-insert-at'" (defmacro --splice-list (pred new-list list) "Anaphoric form of `-splice-list'." + (declare (debug (def-form form form))) `(-splice-list (lambda (it) ,pred) ,new-list ,list)) (defun -cons* (&rest args) @@ -1171,7 +1177,7 @@ See also: `-map-when'" (defmacro --update-at (n form list) "Anaphoric version of `-update-at'." - (declare (debug (form form form))) + (declare (debug (form def-form form))) `(-update-at ,n (lambda (it) ,form) ,list)) (defun -remove-at (n list) @@ -1228,12 +1234,12 @@ Empty lists are also removed from the result. Comparison is done by `equal'. See also `-split-when'" - (declare (debug (form form))) + (declare (debug (def-form form))) `(-split-when (lambda (it) (equal it ,item)) ,list)) (defmacro --split-when (form list) "Anaphoric version of `-split-when'." - (declare (debug (form form))) + (declare (debug (def-form form))) `(-split-when (lambda (it) ,form) ,list)) (defun -split-when (fn list) @@ -1376,20 +1382,31 @@ returns the header value, but only after seeing at least one other value (the body)." (--partition-by-header (funcall fn it) list)) -(defun -partition-after-pred (pred list) - "Partition directly after each time PRED is true on an element of LIST." - (when list - (let ((rest (-partition-after-pred pred - (cdr list)))) - (if (funcall pred (car list)) - ;;split after (car list) - (cons (list (car list)) - rest) +(defmacro --partition-after-pred (form list) + "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. - ;;don't split after (car list) - (cons (cons (car list) - (car rest)) - (cdr rest)))))) +This is the anaphoric counterpart to `-partition-after-pred'." + (let ((l (make-symbol "list")) + (r (make-symbol "result")) + (s (make-symbol "sublist"))) + `(let ((,l ,list) ,r ,s) + (when ,l + (--each ,l + (push it ,s) + (when ,form + (push (nreverse ,s) ,r) + (setq ,s ()))) + (when ,s + (push (nreverse ,s) ,r)) + (nreverse ,r))))) + +(defun -partition-after-pred (pred list) + "Partition LIST after each element for which PRED returns non-nil. + +This function's anaphoric counterpart is `--partition-after-pred'." + (--partition-after-pred (funcall pred it) list)) (defun -partition-before-pred (pred list) "Partition directly before each time PRED is true on an element of LIST." @@ -1577,7 +1594,7 @@ element of LIST paired with the unmodified element of LIST." (defmacro --annotate (form list) "Anaphoric version of `-annotate'." - (declare (debug (form form))) + (declare (debug (def-form form))) `(-annotate (lambda (it) ,form) ,list)) (defun dash--table-carry (lists restore-lists &optional re) @@ -1662,7 +1679,7 @@ predicate PRED, in ascending order." (defmacro --find-indices (form list) "Anaphoric version of `-find-indices'." - (declare (debug (form form))) + (declare (debug (def-form form))) `(-find-indices (lambda (it) ,form) ,list)) (defun -find-index (pred list) @@ -1675,7 +1692,7 @@ See also `-first'." (defmacro --find-index (form list) "Anaphoric version of `-find-index'." - (declare (debug (form form))) + (declare (debug (def-form form))) `(-find-index (lambda (it) ,form) ,list)) (defun -find-last-index (pred list) @@ -1688,6 +1705,7 @@ See also `-last'." (defmacro --find-last-index (form list) "Anaphoric version of `-find-last-index'." + (declare (debug (def-form form))) `(-find-last-index (lambda (it) ,form) ,list)) (defun -select-by-indices (indices list) @@ -2695,7 +2713,7 @@ if the first element should sort before the second." (defmacro --sort (form list) "Anaphoric form of `-sort'." - (declare (debug (form form))) + (declare (debug (def-form form))) `(-sort (lambda (it other) ,form) ,list)) (defun -list (&optional arg &rest args) @@ -2771,14 +2789,14 @@ comparing them." "Anaphoric version of `-max-by'. The items for the comparator form are exposed as \"it\" and \"other\"." - (declare (debug (form form))) + (declare (debug (def-form form))) `(-max-by (lambda (it other) ,form) ,list)) (defmacro --min-by (form list) "Anaphoric version of `-min-by'. The items for the comparator form are exposed as \"it\" and \"other\"." - (declare (debug (form form))) + (declare (debug (def-form form))) `(-min-by (lambda (it other) ,form) ,list)) (defun -iota (count &optional start step) @@ -2808,6 +2826,7 @@ FN is called at least once, results are compared with `equal'." (defmacro --fix (form list) "Anaphoric form of `-fix'." + (declare (debug (def-form form))) `(-fix (lambda (it) ,form) ,list)) (defun -unfold (fun seed) @@ -2828,7 +2847,7 @@ the new seed." (defmacro --unfold (form seed) "Anaphoric version of `-unfold'." - (declare (debug (form form))) + (declare (debug (def-form form))) `(-unfold (lambda (it) ,form) ,seed)) (defun -cons-pair? (obj) @@ -2877,7 +2896,7 @@ but is twice as fast as it only traverse the structure once." (defmacro --tree-mapreduce-from (form folder init-value tree) "Anaphoric form of `-tree-mapreduce-from'." - (declare (debug (form form form form))) + (declare (debug (def-form def-form form form))) `(-tree-mapreduce-from (lambda (it) ,form) (lambda (it acc) ,folder) ,init-value ,tree)) (defun -tree-mapreduce (fn folder tree) @@ -2899,7 +2918,7 @@ but is twice as fast as it only traverse the structure once." (defmacro --tree-mapreduce (form folder tree) "Anaphoric form of `-tree-mapreduce'." - (declare (debug (form form form))) + (declare (debug (def-form def-form form))) `(-tree-mapreduce (lambda (it) ,form) (lambda (it acc) ,folder) ,tree)) (defun -tree-map (fn tree) @@ -2913,7 +2932,7 @@ but is twice as fast as it only traverse the structure once." (defmacro --tree-map (form tree) "Anaphoric form of `-tree-map'." - (declare (debug (form form))) + (declare (debug (def-form form))) `(-tree-map (lambda (it) ,form) ,tree)) (defun -tree-reduce-from (fn init-value tree) @@ -2934,7 +2953,7 @@ two elements." (defmacro --tree-reduce-from (form init-value tree) "Anaphoric form of `-tree-reduce-from'." - (declare (debug (form form form))) + (declare (debug (def-form form form))) `(-tree-reduce-from (lambda (it acc) ,form) ,init-value ,tree)) (defun -tree-reduce (fn tree) @@ -2954,7 +2973,7 @@ See `-reduce-r' for how exactly are lists of zero or one element handled." (defmacro --tree-reduce (form tree) "Anaphoric form of `-tree-reduce'." - (declare (debug (form form))) + (declare (debug (def-form form))) `(-tree-reduce (lambda (it acc) ,form) ,tree)) (defun -tree-map-nodes (pred fun tree) @@ -2972,6 +2991,7 @@ further." (defmacro --tree-map-nodes (pred form tree) "Anaphoric form of `-tree-map-nodes'." + (declare (debug (def-form def-form form))) `(-tree-map-nodes (lambda (it) ,pred) (lambda (it) ,form) ,tree)) (defun -tree-seq (branch children tree) @@ -2991,6 +3011,7 @@ Non-branch nodes are simply copied." (defmacro --tree-seq (branch children tree) "Anaphoric form of `-tree-seq'." + (declare (debug (def-form def-form form))) `(-tree-seq (lambda (it) ,branch) (lambda (it) ,children) ,tree)) (defun -clone (list) @@ -3071,6 +3092,7 @@ In types: a -> b -> a" Arguments denoted by <> will be left unspecialized. See SRFI-26 for detailed description." + (declare (debug (&optional sexp &rest &or "<>" form))) (let* ((i 0) (args (--keep (when (eq it '<>) (setq i (1+ i)) diff --git a/elpa/dash-20210330.1544/dash.info b/elpa/dash-20210609.1330/dash.info similarity index 98% rename from elpa/dash-20210330.1544/dash.info rename to elpa/dash-20210609.1330/dash.info index 08648b0..7a03f7c 100644 --- a/elpa/dash-20210330.1544/dash.info +++ b/elpa/dash-20210609.1330/dash.info @@ -1418,8 +1418,9 @@ Functions partitioning the input list into a list of lists. ⇒ ((2 1 1 1) (4 1 3 5) (6 6 1)) -- Function: -partition-after-pred (pred list) - Partition directly after each time PRED is true on an element of - LIST. + Partition LIST after each element for which PRED returns non-nil. + + This function’s anaphoric counterpart is ‘--partition-after-pred’. (-partition-after-pred #'booleanp ()) ⇒ () @@ -4294,7 +4295,7 @@ Index (line 320) * -grade-down: Indexing. (line 81) * -grade-up: Indexing. (line 71) -* -group-by: Partitioning. (line 193) +* -group-by: Partitioning. (line 194) * -if-let: Binding. (line 34) * -if-let*: Binding. (line 45) * -inits: Reductions. (line 222) @@ -4348,12 +4349,12 @@ Index * -partial: Function combinators. (line 8) * -partition: Partitioning. (line 80) -* -partition-after-item: Partitioning. (line 183) +* -partition-after-item: Partitioning. (line 184) * -partition-after-pred: Partitioning. (line 151) * -partition-all: Partitioning. (line 92) * -partition-all-in-steps: Partitioning. (line 115) -* -partition-before-item: Partitioning. (line 173) -* -partition-before-pred: Partitioning. (line 162) +* -partition-before-item: Partitioning. (line 174) +* -partition-before-pred: Partitioning. (line 163) * -partition-by: Partitioning. (line 127) * -partition-by-header: Partitioning. (line 138) * -partition-in-steps: Partitioning. (line 103) @@ -4550,114 +4551,114 @@ Ref: -partition-all-in-steps46825 Ref: -partition-by47307 Ref: -partition-by-header47685 Ref: -partition-after-pred48286 -Ref: -partition-before-pred48664 -Ref: -partition-before-item49049 -Ref: -partition-after-item49356 -Ref: -group-by49658 -Node: Indexing50091 -Ref: -elem-index50293 -Ref: -elem-indices50688 -Ref: -find-index51068 -Ref: -find-last-index51557 -Ref: -find-indices52061 -Ref: -grade-up52466 -Ref: -grade-down52873 -Node: Set operations53287 -Ref: -union53470 -Ref: -difference53908 -Ref: -intersection54320 -Ref: -powerset54752 -Ref: -permutations54962 -Ref: -distinct55258 -Node: Other list operations55632 -Ref: -rotate55857 -Ref: -repeat56224 -Ref: -cons*56503 -Ref: -snoc56919 -Ref: -interpose57329 -Ref: -interleave57623 -Ref: -iota57989 -Ref: -zip-with58472 -Ref: -zip59186 -Ref: -zip-lists60015 -Ref: -zip-fill60713 -Ref: -unzip61035 -Ref: -cycle61777 -Ref: -pad62176 -Ref: -table62495 -Ref: -table-flat63281 -Ref: -first64286 -Ref: -some64772 -Ref: -last65256 -Ref: -first-item65590 -Ref: -second-item65989 -Ref: -third-item66253 -Ref: -fourth-item66515 -Ref: -fifth-item66781 -Ref: -last-item67043 -Ref: -butlast67334 -Ref: -sort67579 -Ref: -list68065 -Ref: -fix68634 -Node: Tree operations69123 -Ref: -tree-seq69319 -Ref: -tree-map70174 -Ref: -tree-map-nodes70614 -Ref: -tree-reduce71461 -Ref: -tree-reduce-from72343 -Ref: -tree-mapreduce72943 -Ref: -tree-mapreduce-from73802 -Ref: -clone75087 -Node: Threading macros75414 -Ref: ->75639 -Ref: ->>76127 -Ref: -->76630 -Ref: -as->77186 -Ref: -some->77640 -Ref: -some->>78013 -Ref: -some-->78448 -Ref: -doto78997 -Node: Binding79550 -Ref: -when-let79757 -Ref: -when-let*80212 -Ref: -if-let80735 -Ref: -if-let*81095 -Ref: -let81712 -Ref: -let*87784 -Ref: -lambda88721 -Ref: -setq89527 -Node: Side effects90328 -Ref: -each90522 -Ref: -each-while91043 -Ref: -each-indexed91645 -Ref: -each-r92231 -Ref: -each-r-while92667 -Ref: -dotimes93293 -Node: Destructive operations93846 -Ref: !cons94064 -Ref: !cdr94268 -Node: Function combinators94461 -Ref: -partial94665 -Ref: -rpartial95183 -Ref: -juxt95831 -Ref: -compose96283 -Ref: -applify96890 -Ref: -on97320 -Ref: -flip97844 -Ref: -const98155 -Ref: -cut98493 -Ref: -not98973 -Ref: -orfn99282 -Ref: -andfn99715 -Ref: -iteratefn100209 -Ref: -fixfn100911 -Ref: -prodfn102467 -Node: Development103525 -Node: Contribute103814 -Node: Contributors104826 -Node: FDL106919 -Node: GPL132239 -Node: Index169988 +Ref: -partition-before-pred48733 +Ref: -partition-before-item49118 +Ref: -partition-after-item49425 +Ref: -group-by49727 +Node: Indexing50160 +Ref: -elem-index50362 +Ref: -elem-indices50757 +Ref: -find-index51137 +Ref: -find-last-index51626 +Ref: -find-indices52130 +Ref: -grade-up52535 +Ref: -grade-down52942 +Node: Set operations53356 +Ref: -union53539 +Ref: -difference53977 +Ref: -intersection54389 +Ref: -powerset54821 +Ref: -permutations55031 +Ref: -distinct55327 +Node: Other list operations55701 +Ref: -rotate55926 +Ref: -repeat56293 +Ref: -cons*56572 +Ref: -snoc56988 +Ref: -interpose57398 +Ref: -interleave57692 +Ref: -iota58058 +Ref: -zip-with58541 +Ref: -zip59255 +Ref: -zip-lists60084 +Ref: -zip-fill60782 +Ref: -unzip61104 +Ref: -cycle61846 +Ref: -pad62245 +Ref: -table62564 +Ref: -table-flat63350 +Ref: -first64355 +Ref: -some64841 +Ref: -last65325 +Ref: -first-item65659 +Ref: -second-item66058 +Ref: -third-item66322 +Ref: -fourth-item66584 +Ref: -fifth-item66850 +Ref: -last-item67112 +Ref: -butlast67403 +Ref: -sort67648 +Ref: -list68134 +Ref: -fix68703 +Node: Tree operations69192 +Ref: -tree-seq69388 +Ref: -tree-map70243 +Ref: -tree-map-nodes70683 +Ref: -tree-reduce71530 +Ref: -tree-reduce-from72412 +Ref: -tree-mapreduce73012 +Ref: -tree-mapreduce-from73871 +Ref: -clone75156 +Node: Threading macros75483 +Ref: ->75708 +Ref: ->>76196 +Ref: -->76699 +Ref: -as->77255 +Ref: -some->77709 +Ref: -some->>78082 +Ref: -some-->78517 +Ref: -doto79066 +Node: Binding79619 +Ref: -when-let79826 +Ref: -when-let*80281 +Ref: -if-let80804 +Ref: -if-let*81164 +Ref: -let81781 +Ref: -let*87853 +Ref: -lambda88790 +Ref: -setq89596 +Node: Side effects90397 +Ref: -each90591 +Ref: -each-while91112 +Ref: -each-indexed91714 +Ref: -each-r92300 +Ref: -each-r-while92736 +Ref: -dotimes93362 +Node: Destructive operations93915 +Ref: !cons94133 +Ref: !cdr94337 +Node: Function combinators94530 +Ref: -partial94734 +Ref: -rpartial95252 +Ref: -juxt95900 +Ref: -compose96352 +Ref: -applify96959 +Ref: -on97389 +Ref: -flip97913 +Ref: -const98224 +Ref: -cut98562 +Ref: -not99042 +Ref: -orfn99351 +Ref: -andfn99784 +Ref: -iteratefn100278 +Ref: -fixfn100980 +Ref: -prodfn102536 +Node: Development103594 +Node: Contribute103883 +Node: Contributors104895 +Node: FDL106988 +Node: GPL132308 +Node: Index170057  End Tag Table diff --git a/elpa/dash-20210330.1544/dir b/elpa/dash-20210609.1330/dir similarity index 100% rename from elpa/dash-20210330.1544/dir rename to elpa/dash-20210609.1330/dir