Update dash

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")

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)
+(defmacro --partition-after-pred (form list)
-  "Partition directly after each time PRED is true on an element of LIST."
+  "Partition LIST after each element for which FORM evaluates to non-nil.
-  (when list
+Each element of LIST in turn is bound to `it' before evaluating
-    (let ((rest (-partition-after-pred pred
+FORM.
-                                       (cdr list))))
-      (if (funcall pred (car list))
-          ;;split after (car list)
-          (cons (list (car list))
-                rest)
 
-        ;;don't split after (car list)
+This is the anaphoric counterpart to `-partition-after-pred'."
-        (cons (cons (car list)
+  (let ((l (make-symbol "list"))
-                    (car rest))
+        (r (make-symbol "result"))
-              (cdr rest))))))
+        (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))

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
+     Partition LIST after each element for which PRED returns non-nil.
-     LIST.
+
+     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-item:                Partitioning.        (line 174)
-* -partition-before-pred:                Partitioning.        (line 162)
+* -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-pred48733
-Ref: -partition-before-item49049
+Ref: -partition-before-item49118
-Ref: -partition-after-item49356
+Ref: -partition-after-item49425
-Ref: -group-by49658
+Ref: -group-by49727
-Node: Indexing50091
+Node: Indexing50160
-Ref: -elem-index50293
+Ref: -elem-index50362
-Ref: -elem-indices50688
+Ref: -elem-indices50757
-Ref: -find-index51068
+Ref: -find-index51137
-Ref: -find-last-index51557
+Ref: -find-last-index51626
-Ref: -find-indices52061
+Ref: -find-indices52130
-Ref: -grade-up52466
+Ref: -grade-up52535
-Ref: -grade-down52873
+Ref: -grade-down52942
-Node: Set operations53287
+Node: Set operations53356
-Ref: -union53470
+Ref: -union53539
-Ref: -difference53908
+Ref: -difference53977
-Ref: -intersection54320
+Ref: -intersection54389
-Ref: -powerset54752
+Ref: -powerset54821
-Ref: -permutations54962
+Ref: -permutations55031
-Ref: -distinct55258
+Ref: -distinct55327
-Node: Other list operations55632
+Node: Other list operations55701
-Ref: -rotate55857
+Ref: -rotate55926
-Ref: -repeat56224
+Ref: -repeat56293
-Ref: -cons*56503
+Ref: -cons*56572
-Ref: -snoc56919
+Ref: -snoc56988
-Ref: -interpose57329
+Ref: -interpose57398
-Ref: -interleave57623
+Ref: -interleave57692
-Ref: -iota57989
+Ref: -iota58058
-Ref: -zip-with58472
+Ref: -zip-with58541
-Ref: -zip59186
+Ref: -zip59255
-Ref: -zip-lists60015
+Ref: -zip-lists60084
-Ref: -zip-fill60713
+Ref: -zip-fill60782
-Ref: -unzip61035
+Ref: -unzip61104
-Ref: -cycle61777
+Ref: -cycle61846
-Ref: -pad62176
+Ref: -pad62245
-Ref: -table62495
+Ref: -table62564
-Ref: -table-flat63281
+Ref: -table-flat63350
-Ref: -first64286
+Ref: -first64355
-Ref: -some64772
+Ref: -some64841
-Ref: -last65256
+Ref: -last65325
-Ref: -first-item65590
+Ref: -first-item65659
-Ref: -second-item65989
+Ref: -second-item66058
-Ref: -third-item66253
+Ref: -third-item66322
-Ref: -fourth-item66515
+Ref: -fourth-item66584
-Ref: -fifth-item66781
+Ref: -fifth-item66850
-Ref: -last-item67043
+Ref: -last-item67112
-Ref: -butlast67334
+Ref: -butlast67403
-Ref: -sort67579
+Ref: -sort67648
-Ref: -list68065
+Ref: -list68134
-Ref: -fix68634
+Ref: -fix68703
-Node: Tree operations69123
+Node: Tree operations69192
-Ref: -tree-seq69319
+Ref: -tree-seq69388
-Ref: -tree-map70174
+Ref: -tree-map70243
-Ref: -tree-map-nodes70614
+Ref: -tree-map-nodes70683
-Ref: -tree-reduce71461
+Ref: -tree-reduce71530
-Ref: -tree-reduce-from72343
+Ref: -tree-reduce-from72412
-Ref: -tree-mapreduce72943
+Ref: -tree-mapreduce73012
-Ref: -tree-mapreduce-from73802
+Ref: -tree-mapreduce-from73871
-Ref: -clone75087
+Ref: -clone75156
-Node: Threading macros75414
+Node: Threading macros75483
-Ref: ->75639
+Ref: ->75708
-Ref: ->>76127
+Ref: ->>76196
-Ref: -->76630
+Ref: -->76699
-Ref: -as->77186
+Ref: -as->77255
-Ref: -some->77640
+Ref: -some->77709
-Ref: -some->>78013
+Ref: -some->>78082
-Ref: -some-->78448
+Ref: -some-->78517
-Ref: -doto78997
+Ref: -doto79066
-Node: Binding79550
+Node: Binding79619
-Ref: -when-let79757
+Ref: -when-let79826
-Ref: -when-let*80212
+Ref: -when-let*80281
-Ref: -if-let80735
+Ref: -if-let80804
-Ref: -if-let*81095
+Ref: -if-let*81164
-Ref: -let81712
+Ref: -let81781
-Ref: -let*87784
+Ref: -let*87853
-Ref: -lambda88721
+Ref: -lambda88790
-Ref: -setq89527
+Ref: -setq89596
-Node: Side effects90328
+Node: Side effects90397
-Ref: -each90522
+Ref: -each90591
-Ref: -each-while91043
+Ref: -each-while91112
-Ref: -each-indexed91645
+Ref: -each-indexed91714
-Ref: -each-r92231
+Ref: -each-r92300
-Ref: -each-r-while92667
+Ref: -each-r-while92736
-Ref: -dotimes93293
+Ref: -dotimes93362
-Node: Destructive operations93846
+Node: Destructive operations93915
-Ref: !cons94064
+Ref: !cons94133
-Ref: !cdr94268
+Ref: !cdr94337
-Node: Function combinators94461
+Node: Function combinators94530
-Ref: -partial94665
+Ref: -partial94734
-Ref: -rpartial95183
+Ref: -rpartial95252
-Ref: -juxt95831
+Ref: -juxt95900
-Ref: -compose96283
+Ref: -compose96352
-Ref: -applify96890
+Ref: -applify96959
-Ref: -on97320
+Ref: -on97389
-Ref: -flip97844
+Ref: -flip97913
-Ref: -const98155
+Ref: -const98224
-Ref: -cut98493
+Ref: -cut98562
-Ref: -not98973
+Ref: -not99042
-Ref: -orfn99282
+Ref: -orfn99351
-Ref: -andfn99715
+Ref: -andfn99784
-Ref: -iteratefn100209
+Ref: -iteratefn100278
-Ref: -fixfn100911
+Ref: -fixfn100980
-Ref: -prodfn102467
+Ref: -prodfn102536
-Node: Development103525
+Node: Development103594
-Node: Contribute103814
+Node: Contribute103883
-Node: Contributors104826
+Node: Contributors104895
-Node: FDL106919
+Node: FDL106988
-Node: GPL132239
+Node: GPL132308
-Node: Index169988
+Node: Index170057
 
 End Tag Table