[elpa] externals/dash c77644b 092/316: Regenerate docs

[ELPA Syncer]

branch: externals/dash
commit c77644b7ee293f8fc355c53db533eafca0acf785
Author: Wilfred Hughes <me@wilfred.me.uk>
Commit: Wilfred Hughes <me@wilfred.me.uk>

    Regenerate docs
---
 dash.info | 410 ++++++++++++++++++++++++++++++++++++++++----------------------
 1 file changed, 267 insertions(+), 143 deletions(-)

diff --git a/dash.info b/dash.info
index b5ebaa7..86cf80f 100644
--- a/dash.info
+++ b/dash.info
@@ -1,4 +1,4 @@
-This is dash.info, produced by makeinfo version 6.4 from dash.texi.
+This is dash.info, produced by makeinfo version 6.5 from dash.texi.
 
 This manual is for ‘dash.el’ version 2.12.1.
 
@@ -802,6 +802,70 @@ Functions reducing lists into single value.
           (--reduce-r (format "%s-%s" acc it) '(1 2 3))
               ⇒ "3-2-1"
 
+ -- Function: -reductions-from (fn init list)
+     Return a list of the intermediate values of the reduction.
+
+     See ‘-reduce-from’ (*note -reduce-from::) for explanation of the
+     arguments.
+
+     See also: ‘-reductions’ (*note -reductions::), ‘-reductions-r’
+     (*note -reductions-r::), ‘-reduce-r’ (*note -reduce-r::)
+
+          (-reductions-from (lambda (a i) (format "(%s FN %s)" a i)) "INIT" 
'(1 2 3 4))
+              ⇒ '("INIT" "(INIT FN 1)" "((INIT FN 1) FN 2)" "(((INIT FN 1) FN 
2) FN 3)" "((((INIT FN 1) FN 2) FN 3) FN 4)")
+          (-reductions-from 'max 0 '(2 1 4 3))
+              ⇒ '(0 2 2 4 4)
+          (-reductions-from '* 1 '(1 2 3 4))
+              ⇒ '(1 1 2 6 24)
+
+ -- Function: -reductions-r-from (fn init list)
+     Return a list of the intermediate values of the reduction.
+
+     See ‘-reduce-r-from’ (*note -reduce-r-from::) for explanation of
+     the arguments.
+
+     See also: ‘-reductions-r’ (*note -reductions-r::), ‘-reductions’
+     (*note -reductions::), ‘-reduce’ (*note -reduce::)
+
+          (-reductions-r-from (lambda (i a) (format "(%s FN %s)" i a)) "INIT" 
'(1 2 3 4))
+              ⇒ '("(1 FN (2 FN (3 FN (4 FN INIT))))" "(2 FN (3 FN (4 FN 
INIT)))" "(3 FN (4 FN INIT))" "(4 FN INIT)" "INIT")
+          (-reductions-r-from 'max 0 '(2 1 4 3))
+              ⇒ '(4 4 4 3 0)
+          (-reductions-r-from '* 1 '(1 2 3 4))
+              ⇒ '(24 24 12 4 1)
+
+ -- Function: -reductions (fn list)
+     Return a list of the intermediate values of the reduction.
+
+     See ‘-reduce’ (*note -reduce::) for explanation of the arguments.
+
+     See also: ‘-reductions-from’ (*note -reductions-from::),
+     ‘-reductions-r’ (*note -reductions-r::), ‘-reduce-r’ (*note
+     -reduce-r::)
+
+          (-reductions (lambda (a i) (format "(%s FN %s)" a i)) '(1 2 3 4))
+              ⇒ '(1 "(1 FN 2)" "((1 FN 2) FN 3)" "(((1 FN 2) FN 3) FN 4)")
+          (-reductions '+ '(1 2 3 4))
+              ⇒ '(1 3 6 10)
+          (-reductions '* '(1 2 3 4))
+              ⇒ '(1 2 6 24)
+
+ -- Function: -reductions-r (fn list)
+     Return a list of the intermediate values of the reduction.
+
+     See ‘-reduce-r’ (*note -reduce-r::) for explanation of the
+     arguments.
+
+     See also: ‘-reductions-r-from’ (*note -reductions-r-from::),
+     ‘-reductions’ (*note -reductions::), ‘-reduce’ (*note -reduce::)
+
+          (-reductions-r (lambda (i a) (format "(%s FN %s)" i a)) '(1 2 3 4))
+              ⇒ '("(1 FN (2 FN (3 FN 4)))" "(2 FN (3 FN 4))" "(3 FN 4)" 4)
+          (-reductions-r '+ '(1 2 3 4))
+              ⇒ '(10 9 7 4)
+          (-reductions-r '* '(1 2 3 4))
+              ⇒ '(24 24 12 4)
+
  -- Function: -count (pred list)
      Counts the number of items in LIST where (PRED item) is non-nil.
 
@@ -820,6 +884,18 @@ Functions reducing lists into single value.
           (-sum '(1 2 3 4))
               ⇒ 10
 
+ -- Function: -running-sum (list)
+     Return a list with running sums of items in LIST.
+
+     LIST must be non-empty.
+
+          (-running-sum '(1 2 3 4))
+              ⇒ '(1 3 6 10)
+          (-running-sum '(1))
+              ⇒ '(1)
+          (-running-sum '())
+              ⇒ error
+
  -- Function: -product (list)
      Return the product of LIST.
 
@@ -830,6 +906,38 @@ Functions reducing lists into single value.
           (-product '(1 2 3 4))
               ⇒ 24
 
+ -- Function: -running-product (list)
+     Return a list with running products of items in LIST.
+
+     LIST must be non-empty.
+
+          (-running-product '(1 2 3 4))
+              ⇒ '(1 2 6 24)
+          (-running-product '(1))
+              ⇒ '(1)
+          (-running-product '())
+              ⇒ error
+
+ -- Function: -inits (list)
+     Return all prefixes of LIST.
+
+          (-inits '(1 2 3 4))
+              ⇒ '(nil (1) (1 2) (1 2 3) (1 2 3 4))
+          (-inits nil)
+              ⇒ '(nil)
+          (-inits '(1))
+              ⇒ '(nil (1))
+
+ -- Function: -tails (list)
+     Return all suffixes of LIST
+
+          (-tails '(1 2 3 4))
+              ⇒ '((1 2 3 4) (2 3 4) (3 4) (4) nil)
+          (-tails nil)
+              ⇒ '(nil)
+          (-tails '(1))
+              ⇒ '((1) nil)
+
  -- Function: -min (list)
      Return the smallest value from LIST of numbers or markers.
 
@@ -2772,7 +2880,7 @@ Index
                                                             (line  93)
 * -contains?:                            Predicates.        (line  57)
 * -copy:                                 Maps.              (line 135)
-* -count:                                Reductions.        (line  89)
+* -count:                                Reductions.        (line 153)
 * -cut:                                  Function combinators.
                                                             (line 106)
 * -cycle:                                Other list operations.
@@ -2814,6 +2922,7 @@ Index
 * -group-by:                             Partitioning.      (line 187)
 * -if-let:                               Binding.           (line  37)
 * -if-let*:                              Binding.           (line  50)
+* -inits:                                Reductions.        (line 205)
 * -insert-at:                            List to list.      (line 109)
 * -interleave:                           Other list operations.
                                                             (line  66)
@@ -2844,10 +2953,10 @@ Index
 * -map-last:                             Maps.              (line  52)
 * -map-when:                             Maps.              (line  21)
 * -mapcat:                               Maps.              (line 124)
-* -max:                                  Reductions.        (line 141)
-* -max-by:                               Reductions.        (line 151)
-* -min:                                  Reductions.        (line 117)
-* -min-by:                               Reductions.        (line 127)
+* -max:                                  Reductions.        (line 249)
+* -max-by:                               Reductions.        (line 259)
+* -min:                                  Reductions.        (line 225)
+* -min-by:                               Reductions.        (line 235)
 * -non-nil:                              Sublist selection. (line  80)
 * -none?:                                Predicates.        (line  30)
 * -not:                                  Function combinators.
@@ -2875,11 +2984,15 @@ Index
 * -powerset:                             Set operations.    (line  44)
 * -prodfn:                               Function combinators.
                                                             (line 212)
-* -product:                              Reductions.        (line 107)
+* -product:                              Reductions.        (line 183)
 * -reduce:                               Reductions.        (line  46)
 * -reduce-from:                          Reductions.        (line   8)
 * -reduce-r:                             Reductions.        (line  66)
 * -reduce-r-from:                        Reductions.        (line  27)
+* -reductions:                           Reductions.        (line 121)
+* -reductions-from:                      Reductions.        (line  89)
+* -reductions-r:                         Reductions.        (line 137)
+* -reductions-r-from:                    Reductions.        (line 105)
 * -remove:                               Sublist selection. (line  23)
 * -remove-at:                            List to list.      (line 146)
 * -remove-at-indices:                    List to list.      (line 159)
@@ -2896,6 +3009,8 @@ Index
                                                             (line   8)
 * -rpartial:                             Function combinators.
                                                             (line  20)
+* -running-product:                      Reductions.        (line 193)
+* -running-sum:                          Reductions.        (line 171)
 * -same-items?:                          Predicates.        (line  72)
 * -second-item:                          Other list operations.
                                                             (line 257)
@@ -2919,11 +3034,12 @@ Index
 * -split-on:                             Partitioning.      (line  28)
 * -split-when:                           Partitioning.      (line  46)
 * -split-with:                           Partitioning.      (line  17)
-* -sum:                                  Reductions.        (line  97)
+* -sum:                                  Reductions.        (line 161)
 * -table:                                Other list operations.
                                                             (line 161)
 * -table-flat:                           Other list operations.
                                                             (line 180)
+* -tails:                                Reductions.        (line 215)
 * -take:                                 Sublist selection. (line 102)
 * -take-last:                            Sublist selection. (line 113)
 * -take-while:                           Sublist selection. (line 147)
@@ -3004,141 +3120,149 @@ Ref: -reduce-from22701
 Ref: -reduce-r-from23487
 Ref: -reduce24272
 Ref: -reduce-r25080
-Ref: -count25996
-Ref: -sum26220
-Ref: -product26409
-Ref: -min26618
-Ref: -min-by26844
-Ref: -max27367
-Ref: -max-by27592
-Node: Unfolding28120
-Ref: -iterate28359
-Ref: -unfold28804
-Node: Predicates29612
-Ref: -any?29736
-Ref: -all?30056
-Ref: -none?30386
-Ref: -only-some?30688
-Ref: -contains?31173
-Ref: -same-items?31562
-Ref: -is-prefix?31947
-Ref: -is-suffix?32270
-Ref: -is-infix?32593
-Node: Partitioning32947
-Ref: -split-at33135
-Ref: -split-with33420
-Ref: -split-on33823
-Ref: -split-when34499
-Ref: -separate35139
-Ref: -partition35581
-Ref: -partition-all36033
-Ref: -partition-in-steps36461
-Ref: -partition-all-in-steps36958
-Ref: -partition-by37443
-Ref: -partition-by-header37825
-Ref: -partition-after-pred38429
-Ref: -partition-before-pred38800
-Ref: -partition-before-item39178
-Ref: -partition-after-item39489
-Ref: -group-by39795
-Node: Indexing40232
-Ref: -elem-index40434
-Ref: -elem-indices40829
-Ref: -find-index41212
-Ref: -find-last-index41701
-Ref: -find-indices42205
-Ref: -grade-up42613
-Ref: -grade-down43016
-Node: Set operations43426
-Ref: -union43609
-Ref: -difference44051
-Ref: -intersection44468
-Ref: -powerset44905
-Ref: -permutations45118
-Ref: -distinct45418
-Node: Other list operations45742
-Ref: -rotate45967
-Ref: -repeat46262
-Ref: -cons*46525
-Ref: -snoc46912
-Ref: -interpose47325
-Ref: -interleave47623
-Ref: -zip-with47992
-Ref: -zip48709
-Ref: -zip-fill49515
-Ref: -unzip49838
-Ref: -cycle50372
-Ref: -pad50745
-Ref: -table51068
-Ref: -table-flat51858
-Ref: -first52867
-Ref: -some53239
-Ref: -last53548
-Ref: -first-item53882
-Ref: -second-item54298
-Ref: -third-item54578
-Ref: -fourth-item54856
-Ref: -fifth-item55122
-Ref: -last-item55384
-Ref: -butlast55676
-Ref: -sort55923
-Ref: -list56411
-Ref: -fix56742
-Node: Tree operations57282
-Ref: -tree-seq57478
-Ref: -tree-map58336
-Ref: -tree-map-nodes58779
-Ref: -tree-reduce59634
-Ref: -tree-reduce-from60516
-Ref: -tree-mapreduce61117
-Ref: -tree-mapreduce-from61977
-Ref: -clone63263
-Node: Threading macros63591
-Ref: ->63736
-Ref: ->>64228
-Ref: -->64733
-Ref: -as->65294
-Ref: -some->65749
-Ref: -some->>66123
-Ref: -some-->66559
-Node: Binding67030
-Ref: -when-let67242
-Ref: -when-let*67727
-Ref: -if-let68255
-Ref: -if-let*68650
-Ref: -let69267
-Ref: -let*74060
-Ref: -lambda75001
-Node: Side-effects75803
-Ref: -each75997
-Ref: -each-while76404
-Ref: -each-indexed76764
-Ref: -dotimes77282
-Ref: -doto77585
-Node: Destructive operations78012
-Ref: !cons78185
-Ref: !cdr78391
-Node: Function combinators78586
-Ref: -partial78860
-Ref: -rpartial79255
-Ref: -juxt79657
-Ref: -compose80089
-Ref: -applify80647
-Ref: -on81094
-Ref: -flip81617
-Ref: -const81929
-Ref: -cut82273
-Ref: -not82759
-Ref: -orfn83069
-Ref: -andfn83503
-Ref: -iteratefn83998
-Ref: -fixfn84701
-Ref: -prodfn86270
-Node: Development87336
-Node: Contribute87685
-Node: Changes88433
-Node: Contributors91432
-Node: Index93056
+Ref: -reductions-from25996
+Ref: -reductions-r-from26711
+Ref: -reductions27436
+Ref: -reductions-r28061
+Ref: -count28696
+Ref: -sum28920
+Ref: -running-sum29109
+Ref: -product29402
+Ref: -running-product29611
+Ref: -inits29924
+Ref: -tails30172
+Ref: -min30419
+Ref: -min-by30645
+Ref: -max31168
+Ref: -max-by31393
+Node: Unfolding31921
+Ref: -iterate32160
+Ref: -unfold32605
+Node: Predicates33413
+Ref: -any?33537
+Ref: -all?33857
+Ref: -none?34187
+Ref: -only-some?34489
+Ref: -contains?34974
+Ref: -same-items?35363
+Ref: -is-prefix?35748
+Ref: -is-suffix?36071
+Ref: -is-infix?36394
+Node: Partitioning36748
+Ref: -split-at36936
+Ref: -split-with37221
+Ref: -split-on37624
+Ref: -split-when38300
+Ref: -separate38940
+Ref: -partition39382
+Ref: -partition-all39834
+Ref: -partition-in-steps40262
+Ref: -partition-all-in-steps40759
+Ref: -partition-by41244
+Ref: -partition-by-header41626
+Ref: -partition-after-pred42230
+Ref: -partition-before-pred42601
+Ref: -partition-before-item42979
+Ref: -partition-after-item43290
+Ref: -group-by43596
+Node: Indexing44033
+Ref: -elem-index44235
+Ref: -elem-indices44630
+Ref: -find-index45013
+Ref: -find-last-index45502
+Ref: -find-indices46006
+Ref: -grade-up46414
+Ref: -grade-down46817
+Node: Set operations47227
+Ref: -union47410
+Ref: -difference47852
+Ref: -intersection48269
+Ref: -powerset48706
+Ref: -permutations48919
+Ref: -distinct49219
+Node: Other list operations49543
+Ref: -rotate49768
+Ref: -repeat50063
+Ref: -cons*50326
+Ref: -snoc50713
+Ref: -interpose51126
+Ref: -interleave51424
+Ref: -zip-with51793
+Ref: -zip52510
+Ref: -zip-fill53316
+Ref: -unzip53639
+Ref: -cycle54173
+Ref: -pad54546
+Ref: -table54869
+Ref: -table-flat55659
+Ref: -first56668
+Ref: -some57040
+Ref: -last57349
+Ref: -first-item57683
+Ref: -second-item58099
+Ref: -third-item58379
+Ref: -fourth-item58657
+Ref: -fifth-item58923
+Ref: -last-item59185
+Ref: -butlast59477
+Ref: -sort59724
+Ref: -list60212
+Ref: -fix60543
+Node: Tree operations61083
+Ref: -tree-seq61279
+Ref: -tree-map62137
+Ref: -tree-map-nodes62580
+Ref: -tree-reduce63435
+Ref: -tree-reduce-from64317
+Ref: -tree-mapreduce64918
+Ref: -tree-mapreduce-from65778
+Ref: -clone67064
+Node: Threading macros67392
+Ref: ->67537
+Ref: ->>68029
+Ref: -->68534
+Ref: -as->69095
+Ref: -some->69550
+Ref: -some->>69924
+Ref: -some-->70360
+Node: Binding70831
+Ref: -when-let71043
+Ref: -when-let*71528
+Ref: -if-let72056
+Ref: -if-let*72451
+Ref: -let73068
+Ref: -let*77861
+Ref: -lambda78802
+Node: Side-effects79604
+Ref: -each79798
+Ref: -each-while80205
+Ref: -each-indexed80565
+Ref: -dotimes81083
+Ref: -doto81386
+Node: Destructive operations81813
+Ref: !cons81986
+Ref: !cdr82192
+Node: Function combinators82387
+Ref: -partial82661
+Ref: -rpartial83056
+Ref: -juxt83458
+Ref: -compose83890
+Ref: -applify84448
+Ref: -on84895
+Ref: -flip85418
+Ref: -const85730
+Ref: -cut86074
+Ref: -not86560
+Ref: -orfn86870
+Ref: -andfn87304
+Ref: -iteratefn87799
+Ref: -fixfn88502
+Ref: -prodfn90071
+Node: Development91137
+Node: Contribute91486
+Node: Changes92234
+Node: Contributors95233
+Node: Index96857
 
 End Tag Table