[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[elpa] externals/dash 52fd010 167/316: feat: add -zip-lists
|
From: |
ELPA Syncer |
|
Subject: |
[elpa] externals/dash 52fd010 167/316: feat: add -zip-lists |
|
Date: |
Mon, 15 Feb 2021 15:57:50 -0500 (EST) |
branch: externals/dash
commit 52fd01071aa0bb5c22d4aeaa6ff3efa095967325
Author: Matus Goljer <matus.goljer@gmail.com>
Commit: Matus Goljer <matus.goljer@gmail.com>
feat: add -zip-lists
---
dash.el | 31 +++-
dash.info | 436 ++++++++++++++++++++++++++++-------------------------
dash.texi | 47 +++++-
dev/examples.el | 13 +-
readme-template.md | 3 +-
5 files changed, 316 insertions(+), 214 deletions(-)
diff --git a/dash.el b/dash.el
index 460425a..688125d 100644
--- a/dash.el
+++ b/dash.el
@@ -1263,6 +1263,24 @@ The anaphoric form `--zip-with' binds the elements from
LIST1 as symbol `it',
and the elements from LIST2 as symbol `other'."
(--zip-with (funcall fn it other) list1 list2))
+(defun -zip-lists (&rest lists)
+ "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'"
+ (declare (pure t) (side-effect-free t))
+ (when lists
+ (let (results)
+ (while (-none? 'null lists)
+ (setq results (cons (mapcar 'car lists) results))
+ (setq lists (mapcar 'cdr lists)))
+ (nreverse results))))
+
(defun -zip (&rest lists)
"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
@@ -1271,11 +1289,12 @@ 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.
-Please note! This distinction is being removed in an upcoming 3.0
-release of Dash. If you rely on this behavior, use `-zip-pair` instead,
-which will retain that behaviour in future versions.
+Use `-zip-lists' if you need the return value to always be a list
+of lists.
+
+Alias: `-zip-pair'
-Alias: `-zip-pair'"
+See also: `-zip-lists'"
(declare (pure t) (side-effect-free t))
(when lists
(let (results)
@@ -1308,6 +1327,9 @@ a variable number of arguments, such that
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 aboce identity works.
+
See also: `-zip'"
(apply '-zip lists))
@@ -2921,6 +2943,7 @@ structure such as plist or alist."
"--zip-with"
"-zip"
"-zip-fill"
+ "-zip-lists"
"-zip-pair"
"-cycle"
"-pad"
diff --git a/dash.info b/dash.info
index 96e3efc..3ef1e69 100644
--- a/dash.info
+++ b/dash.info
@@ -1,4 +1,4 @@
-This is dash.info, produced by makeinfo version 6.6 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.
@@ -1643,16 +1643,38 @@ Other list functions not fit to be classified elsewhere.
list of cons cells. Otherwise, return the groupings as a list of
lists.
- Please note! This distinction is being removed in an upcoming
- 3.0 release of Dash. If you rely on this behavior, use -zip-pair
- instead.
+ Use ‘-zip-lists’ (*note -zip-lists::) if you need the return
+ value to always be a list of lists.
+
+ Alias: ‘-zip-pair’
+
+ See also: ‘-zip-lists’ (*note -zip-lists::)
(-zip '(1 2 3) '(4 5 6))
⇒ '((1 . 4) (2 . 5) (3 . 6))
(-zip '(1 2 3) '(4 5 6 7))
⇒ '((1 . 4) (2 . 5) (3 . 6))
- (-zip '(1 2 3 4) '(4 5 6))
- ⇒ '((1 . 4) (2 . 5) (3 . 6))
+ (-zip '(1 2) '(3 4 5) '(6))
+ ⇒ '((1 3 6))
+
+ -- Function: -zip-lists (&rest lists)
+ 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’ (*note -zip::)
+
+ (-zip-lists '(1 2 3) '(4 5 6))
+ ⇒ '((1 4) (2 5) (3 6))
+ (-zip-lists '(1 2 3) '(4 5 6 7))
+ ⇒ '((1 4) (2 5) (3 6))
+ (-zip-lists '(1 2) '(3 4 5) '(6))
+ ⇒ '((1 3 6))
-- Function: -zip-fill (fill-value &rest lists)
Zip LISTS, with FILL-VALUE padded onto the shorter lists. The
@@ -1672,12 +1694,17 @@ Other list functions not fit to be classified elsewhere.
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 aboce identity works.
+
See also: ‘-zip’ (*note -zip::)
(-unzip (-zip '(1 2 3) '(a b c) '("e" "f" "g")))
⇒ '((1 2 3) (a b c) ("e" "f" "g"))
(-unzip '((1 2) (3 4) (5 6) (7 8) (9 10)))
⇒ '((1 3 5 7 9) (2 4 6 8 10))
+ (-unzip '((1 2) (3 4)))
+ ⇒ '((1 . 3) (2 . 4))
-- Function: -cycle (list)
Return an infinite copy of LIST that will cycle through the
@@ -2980,7 +3007,7 @@ Index
(line 56)
* -as->: Threading macros. (line 47)
* -butlast: Other list operations.
- (line 313)
+ (line 340)
* -clone: Tree operations. (line 123)
* -common-prefix: Reductions. (line 224)
* -common-suffix: Reductions. (line 234)
@@ -2997,7 +3024,7 @@ Index
* -cut: Function combinators.
(line 106)
* -cycle: Other list operations.
- (line 141)
+ (line 168)
* -difference: Set operations. (line 20)
* -distinct: Set operations. (line 62)
* -dotimes: Side-effects. (line 61)
@@ -3013,17 +3040,17 @@ Index
* -elem-index: Indexing. (line 9)
* -elem-indices: Indexing. (line 21)
* -fifth-item: Other list operations.
- (line 293)
+ (line 320)
* -filter: Sublist selection. (line 8)
* -find-index: Indexing. (line 32)
* -find-indices: Indexing. (line 60)
* -find-last-index: Indexing. (line 46)
* -first: Other list operations.
- (line 207)
+ (line 234)
* -first-item: Other list operations.
- (line 244)
+ (line 271)
* -fix: Other list operations.
- (line 349)
+ (line 376)
* -fixfn: Function combinators.
(line 177)
* -flatten: List to list. (line 33)
@@ -3031,7 +3058,7 @@ Index
* -flip: Function combinators.
(line 81)
* -fourth-item: Other list operations.
- (line 283)
+ (line 310)
* -grade-down: Indexing. (line 81)
* -grade-up: Indexing. (line 71)
* -group-by: Partitioning. (line 187)
@@ -3055,13 +3082,13 @@ Index
* -keep: List to list. (line 8)
* -lambda: Binding. (line 253)
* -last: Other list operations.
- (line 234)
+ (line 261)
* -last-item: Other list operations.
- (line 303)
+ (line 330)
* -let: Binding. (line 66)
* -let*: Binding. (line 233)
* -list: Other list operations.
- (line 336)
+ (line 363)
* -map: Maps. (line 10)
* -map-first: Maps. (line 38)
* -map-indexed: Maps. (line 66)
@@ -3082,7 +3109,7 @@ Index
* -orfn: Function combinators.
(line 128)
* -pad: Other list operations.
- (line 152)
+ (line 179)
* -partial: Function combinators.
(line 9)
* -partition: Partitioning. (line 74)
@@ -3128,7 +3155,7 @@ Index
* -running-sum: Reductions. (line 170)
* -same-items?: Predicates. (line 72)
* -second-item: Other list operations.
- (line 259)
+ (line 286)
* -select-by-indices: Sublist selection. (line 169)
* -select-column: Sublist selection. (line 199)
* -select-columns: Sublist selection. (line 180)
@@ -3138,12 +3165,12 @@ Index
* -snoc: Other list operations.
(line 44)
* -some: Other list operations.
- (line 221)
+ (line 248)
* -some-->: Threading macros. (line 84)
* -some->: Threading macros. (line 60)
* -some->>: Threading macros. (line 72)
* -sort: Other list operations.
- (line 323)
+ (line 350)
* -splice: Maps. (line 91)
* -splice-list: Maps. (line 111)
* -split-at: Partitioning. (line 8)
@@ -3152,15 +3179,15 @@ Index
* -split-with: Partitioning. (line 17)
* -sum: Reductions. (line 160)
* -table: Other list operations.
- (line 163)
+ (line 190)
* -table-flat: Other list operations.
- (line 182)
+ (line 209)
* -tails: Reductions. (line 214)
* -take: Sublist selection. (line 102)
* -take-last: Sublist selection. (line 113)
* -take-while: Sublist selection. (line 147)
* -third-item: Other list operations.
- (line 271)
+ (line 298)
* -tree-map: Tree operations. (line 28)
* -tree-map-nodes: Tree operations. (line 39)
* -tree-mapreduce: Tree operations. (line 85)
@@ -3171,14 +3198,16 @@ Index
* -unfold: Unfolding. (line 25)
* -union: Set operations. (line 8)
* -unzip: Other list operations.
- (line 124)
+ (line 146)
* -update-at: List to list. (line 133)
* -when-let: Binding. (line 9)
* -when-let*: Binding. (line 23)
* -zip: Other list operations.
(line 95)
* -zip-fill: Other list operations.
- (line 116)
+ (line 138)
+* -zip-lists: Other list operations.
+ (line 119)
* -zip-with: Other list operations.
(line 79)
@@ -3207,184 +3236,185 @@ Ref: -remove10524
Ref: -remove-first10935
Ref: -remove-last11462
Ref: -remove-item11983
-Ref: -non-nil12377
-Ref: -slice12536
-Ref: -take13068
-Ref: -take-last13376
-Ref: -drop13699
-Ref: -drop-last13972
-Ref: -take-while14232
-Ref: -drop-while14582
-Ref: -select-by-indices14938
-Ref: -select-columns15452
-Ref: -select-column16157
-Node: List to list16620
-Ref: -keep16812
-Ref: -concat17315
-Ref: -flatten17612
-Ref: -flatten-n18371
-Ref: -replace18758
-Ref: -replace-first19221
-Ref: -replace-last19717
-Ref: -insert-at20206
-Ref: -replace-at20533
-Ref: -update-at20928
-Ref: -remove-at21419
-Ref: -remove-at-indices21907
-Node: Reductions22489
-Ref: -reduce-from22658
-Ref: -reduce-r-from23424
-Ref: -reduce24191
-Ref: -reduce-r24925
-Ref: -reductions-from25795
-Ref: -reductions-r-from26510
-Ref: -reductions27235
-Ref: -reductions-r27860
-Ref: -count28495
-Ref: -sum28719
-Ref: -running-sum28908
-Ref: -product29201
-Ref: -running-product29410
-Ref: -inits29723
-Ref: -tails29971
-Ref: -common-prefix30218
-Ref: -common-suffix30515
-Ref: -min30812
-Ref: -min-by31038
-Ref: -max31561
-Ref: -max-by31786
-Node: Unfolding32314
-Ref: -iterate32553
-Ref: -unfold32998
-Node: Predicates33806
-Ref: -any?33930
-Ref: -all?34250
-Ref: -none?34580
-Ref: -only-some?34882
-Ref: -contains?35367
-Ref: -same-items?35756
-Ref: -is-prefix?36141
-Ref: -is-suffix?36464
-Ref: -is-infix?36787
-Node: Partitioning37141
-Ref: -split-at37329
-Ref: -split-with37614
-Ref: -split-on38017
-Ref: -split-when38693
-Ref: -separate39333
-Ref: -partition39775
-Ref: -partition-all40227
-Ref: -partition-in-steps40655
-Ref: -partition-all-in-steps41152
-Ref: -partition-by41637
-Ref: -partition-by-header42019
-Ref: -partition-after-pred42623
-Ref: -partition-before-pred42967
-Ref: -partition-before-item43318
-Ref: -partition-after-item43629
-Ref: -group-by43935
-Node: Indexing44372
-Ref: -elem-index44574
-Ref: -elem-indices44969
-Ref: -find-index45352
-Ref: -find-last-index45841
-Ref: -find-indices46345
-Ref: -grade-up46753
-Ref: -grade-down47156
-Node: Set operations47566
-Ref: -union47749
-Ref: -difference48191
-Ref: -intersection48608
-Ref: -powerset49045
-Ref: -permutations49258
-Ref: -distinct49558
-Node: Other list operations49936
-Ref: -rotate50161
-Ref: -repeat50531
-Ref: -cons*50794
-Ref: -snoc51181
-Ref: -interpose51594
-Ref: -interleave51892
-Ref: -zip-with52261
-Ref: -zip52978
-Ref: -zip-fill53784
-Ref: -unzip54107
-Ref: -cycle54641
-Ref: -pad55014
-Ref: -table55337
-Ref: -table-flat56127
-Ref: -first57136
-Ref: -some57508
-Ref: -last57817
-Ref: -first-item58151
-Ref: -second-item58567
-Ref: -third-item58847
-Ref: -fourth-item59125
-Ref: -fifth-item59391
-Ref: -last-item59653
-Ref: -butlast59945
-Ref: -sort60192
-Ref: -list60680
-Ref: -fix61011
-Node: Tree operations61551
-Ref: -tree-seq61747
-Ref: -tree-map62605
-Ref: -tree-map-nodes63048
-Ref: -tree-reduce63903
-Ref: -tree-reduce-from64785
-Ref: -tree-mapreduce65386
-Ref: -tree-mapreduce-from66246
-Ref: -clone67532
-Node: Threading macros67860
-Ref: ->68005
-Ref: ->>68497
-Ref: -->69002
-Ref: -as->69563
-Ref: -some->70018
-Ref: -some->>70392
-Ref: -some-->70828
-Node: Binding71299
-Ref: -when-let71511
-Ref: -when-let*71996
-Ref: -if-let72524
-Ref: -if-let*72919
-Ref: -let73536
-Ref: -let*79624
-Ref: -lambda80565
-Ref: -setq81367
-Node: Side-effects82183
-Ref: -each82377
-Ref: -each-while82784
-Ref: -each-indexed83144
-Ref: -each-r83662
-Ref: -each-r-while84095
-Ref: -dotimes84470
-Ref: -doto84773
-Ref: --doto85200
-Node: Destructive operations85475
-Ref: !cons85648
-Ref: !cdr85854
-Node: Function combinators86049
-Ref: -partial86323
-Ref: -rpartial86718
-Ref: -juxt87120
-Ref: -compose87552
-Ref: -applify88110
-Ref: -on88541
-Ref: -flip89067
-Ref: -const89379
-Ref: -cut89723
-Ref: -not90209
-Ref: -orfn90519
-Ref: -andfn90953
-Ref: -iteratefn91448
-Ref: -fixfn92151
-Ref: -prodfn93720
-Node: Development94789
-Node: Contribute95138
-Node: Changes95886
-Node: Contributors98885
-Node: Index100509
+Ref: -non-nil12378
+Ref: -slice12537
+Ref: -take13069
+Ref: -take-last13377
+Ref: -drop13700
+Ref: -drop-last13973
+Ref: -take-while14233
+Ref: -drop-while14583
+Ref: -select-by-indices14939
+Ref: -select-columns15453
+Ref: -select-column16158
+Node: List to list16621
+Ref: -keep16813
+Ref: -concat17316
+Ref: -flatten17613
+Ref: -flatten-n18372
+Ref: -replace18759
+Ref: -replace-first19222
+Ref: -replace-last19719
+Ref: -insert-at20209
+Ref: -replace-at20536
+Ref: -update-at20931
+Ref: -remove-at21422
+Ref: -remove-at-indices21910
+Node: Reductions22492
+Ref: -reduce-from22661
+Ref: -reduce-r-from23427
+Ref: -reduce24194
+Ref: -reduce-r24928
+Ref: -reductions-from25798
+Ref: -reductions-r-from26513
+Ref: -reductions27238
+Ref: -reductions-r27863
+Ref: -count28498
+Ref: -sum28722
+Ref: -running-sum28911
+Ref: -product29204
+Ref: -running-product29413
+Ref: -inits29726
+Ref: -tails29974
+Ref: -common-prefix30221
+Ref: -common-suffix30518
+Ref: -min30815
+Ref: -min-by31041
+Ref: -max31564
+Ref: -max-by31789
+Node: Unfolding32317
+Ref: -iterate32556
+Ref: -unfold33001
+Node: Predicates33809
+Ref: -any?33933
+Ref: -all?34253
+Ref: -none?34583
+Ref: -only-some?34885
+Ref: -contains?35370
+Ref: -same-items?35759
+Ref: -is-prefix?36144
+Ref: -is-suffix?36467
+Ref: -is-infix?36790
+Node: Partitioning37144
+Ref: -split-at37332
+Ref: -split-with37617
+Ref: -split-on38020
+Ref: -split-when38696
+Ref: -separate39336
+Ref: -partition39778
+Ref: -partition-all40230
+Ref: -partition-in-steps40658
+Ref: -partition-all-in-steps41155
+Ref: -partition-by41640
+Ref: -partition-by-header42022
+Ref: -partition-after-pred42626
+Ref: -partition-before-pred42970
+Ref: -partition-before-item43321
+Ref: -partition-after-item43632
+Ref: -group-by43938
+Node: Indexing44375
+Ref: -elem-index44577
+Ref: -elem-indices44972
+Ref: -find-index45355
+Ref: -find-last-index45844
+Ref: -find-indices46348
+Ref: -grade-up46756
+Ref: -grade-down47159
+Node: Set operations47569
+Ref: -union47752
+Ref: -difference48194
+Ref: -intersection48611
+Ref: -powerset49048
+Ref: -permutations49261
+Ref: -distinct49561
+Node: Other list operations49939
+Ref: -rotate50164
+Ref: -repeat50534
+Ref: -cons*50797
+Ref: -snoc51184
+Ref: -interpose51597
+Ref: -interleave51895
+Ref: -zip-with52264
+Ref: -zip52981
+Ref: -zip-lists53813
+Ref: -zip-fill54514
+Ref: -unzip54837
+Ref: -cycle55582
+Ref: -pad55955
+Ref: -table56278
+Ref: -table-flat57068
+Ref: -first58077
+Ref: -some58449
+Ref: -last58758
+Ref: -first-item59092
+Ref: -second-item59508
+Ref: -third-item59788
+Ref: -fourth-item60066
+Ref: -fifth-item60332
+Ref: -last-item60594
+Ref: -butlast60886
+Ref: -sort61133
+Ref: -list61621
+Ref: -fix61952
+Node: Tree operations62492
+Ref: -tree-seq62688
+Ref: -tree-map63546
+Ref: -tree-map-nodes63989
+Ref: -tree-reduce64844
+Ref: -tree-reduce-from65726
+Ref: -tree-mapreduce66327
+Ref: -tree-mapreduce-from67187
+Ref: -clone68473
+Node: Threading macros68801
+Ref: ->68946
+Ref: ->>69438
+Ref: -->69943
+Ref: -as->70504
+Ref: -some->70959
+Ref: -some->>71333
+Ref: -some-->71769
+Node: Binding72240
+Ref: -when-let72452
+Ref: -when-let*72937
+Ref: -if-let73465
+Ref: -if-let*73860
+Ref: -let74477
+Ref: -let*80565
+Ref: -lambda81506
+Ref: -setq82308
+Node: Side-effects83124
+Ref: -each83318
+Ref: -each-while83725
+Ref: -each-indexed84085
+Ref: -each-r84603
+Ref: -each-r-while85036
+Ref: -dotimes85411
+Ref: -doto85714
+Ref: --doto86141
+Node: Destructive operations86416
+Ref: !cons86589
+Ref: !cdr86795
+Node: Function combinators86990
+Ref: -partial87264
+Ref: -rpartial87659
+Ref: -juxt88061
+Ref: -compose88493
+Ref: -applify89051
+Ref: -on89498
+Ref: -flip90024
+Ref: -const90336
+Ref: -cut90680
+Ref: -not91166
+Ref: -orfn91476
+Ref: -andfn91910
+Ref: -iteratefn92405
+Ref: -fixfn93108
+Ref: -prodfn94676
+Node: Development95745
+Node: Contribute96094
+Node: Changes96842
+Node: Contributors99841
+Node: Index101465
End Tag Table
diff --git a/dash.texi b/dash.texi
index 3258a5e..5dd0290 100644
--- a/dash.texi
+++ b/dash.texi
@@ -2624,8 +2624,12 @@ 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.
-Please note! This distinction is being removed in an upcoming 3.0
-release of Dash. If you rely on this behavior, use -zip-pair instead.
+Use @code{-zip-lists} (@pxref{-zip-lists}) if you need the return value to
always be a list
+of lists.
+
+Alias: @code{-zip-pair}
+
+See also: @code{-zip-lists} (@pxref{-zip-lists})
@example
@group
@@ -2637,8 +2641,36 @@ release of Dash. If you rely on this behavior, use
-zip-pair instead.
@result{} '((1 . 4) (2 . 5) (3 . 6))
@end group
@group
-(-zip '(1 2 3 4) '(4 5 6))
- @result{} '((1 . 4) (2 . 5) (3 . 6))
+(-zip '(1 2) '(3 4 5) '(6))
+ @result{} '((1 3 6))
+@end group
+@end example
+@end defun
+
+@anchor{-zip-lists}
+@defun -zip-lists (&rest lists)
+Zip @var{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 @code{-zip-pair} which returns a cons-cell in case two input
+lists are provided.
+
+See also: @code{-zip} (@pxref{-zip})
+
+@example
+@group
+(-zip-lists '(1 2 3) '(4 5 6))
+ @result{} '((1 4) (2 5) (3 6))
+@end group
+@group
+(-zip-lists '(1 2 3) '(4 5 6 7))
+ @result{} '((1 4) (2 5) (3 6))
+@end group
+@group
+(-zip-lists '(1 2) '(3 4 5) '(6))
+ @result{} '((1 3 6))
@end group
@end example
@end defun
@@ -2668,6 +2700,9 @@ a variable number of arguments, such that
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 aboce identity works.
+
See also: @code{-zip} (@pxref{-zip})
@example
@@ -2679,6 +2714,10 @@ See also: @code{-zip} (@pxref{-zip})
(-unzip '((1 2) (3 4) (5 6) (7 8) (9 10)))
@result{} '((1 3 5 7 9) (2 4 6 8 10))
@end group
+@group
+(-unzip '((1 2) (3 4)))
+ @result{} '((1 . 3) (2 . 4))
+@end group
@end example
@end defun
diff --git a/dev/examples.el b/dev/examples.el
index 6c11df4..5c37b3e 100644
--- a/dev/examples.el
+++ b/dev/examples.el
@@ -756,17 +756,26 @@ new list."
(defexamples -zip
(-zip '(1 2 3) '(4 5 6)) => '((1 . 4) (2 . 5) (3 . 6))
(-zip '(1 2 3) '(4 5 6 7)) => '((1 . 4) (2 . 5) (3 . 6))
+ (-zip '(1 2) '(3 4 5) '(6)) => '((1 3 6))
(-zip '(1 2 3 4) '(4 5 6)) => '((1 . 4) (2 . 5) (3 . 6))
(-zip '(1 2 3) '(4 5 6) '(7 8 9)) => '((1 4 7) (2 5 8) (3 6 9))
- (-zip '(1 2) '(3 4 5) '(6)) => '((1 3 6))
(-zip) => nil)
+ (defexamples -zip-lists
+ (-zip-lists '(1 2 3) '(4 5 6)) => '((1 4) (2 5) (3 6))
+ (-zip-lists '(1 2 3) '(4 5 6 7)) => '((1 4) (2 5) (3 6))
+ (-zip-lists '(1 2) '(3 4 5) '(6)) => '((1 3 6))
+ (-zip-lists '(1 2 3 4) '(4 5 6)) => '((1 4) (2 5) (3 6))
+ (-zip-lists '(1 2 3) '(4 5 6) '(7 8 9)) => '((1 4 7) (2 5 8) (3 6 9))
+ (-zip-lists) => nil)
+
(defexamples -zip-fill
(-zip-fill 0 '(1 2 3 4 5) '(6 7 8 9)) => '((1 . 6) (2 . 7) (3 . 8) (4 . 9)
(5 . 0)))
(defexamples -unzip
(-unzip (-zip '(1 2 3) '(a b c) '("e" "f" "g"))) => '((1 2 3) (a b c) ("e"
"f" "g"))
- (-unzip '((1 2) (3 4) (5 6) (7 8) (9 10))) => '((1 3 5 7 9) (2 4 6 8 10)))
+ (-unzip '((1 2) (3 4) (5 6) (7 8) (9 10))) => '((1 3 5 7 9) (2 4 6 8 10))
+ (-unzip '((1 2) (3 4))) => '((1 . 3) (2 . 4)))
(defexamples -cycle
(-take 5 (-cycle '(1 2 3))) => '(1 2 3 1 2)
diff --git a/readme-template.md b/readme-template.md
index 4acba67..82ebeeb 100644
--- a/readme-template.md
+++ b/readme-template.md
@@ -30,7 +30,8 @@ To get function combinators:
- For backward compatibility reasons `-zip` return a cons-cell instead of a
list
with two elements when called on two lists. This is a clunky API, and in an
upcoming 3.0 release of Dash it will always return a list. If you rely on the
- cons-cell return value, use `-zip-pair` instead.
+ cons-cell return value, use `-zip-pair` instead. During the 2.x
+ release cycle the new API is available as `-zip-lists`.
## Syntax highlighting of dash functions
- [elpa] externals/dash 62707a6 154/316: Avoid interning unused symbols in destructuring, (continued)
- [elpa] externals/dash 62707a6 154/316: Avoid interning unused symbols in destructuring, ELPA Syncer, 2021/02/15
- [elpa] externals/dash 9631947 155/316: Merge pull request #317 from cireu/feat/intern-soft, ELPA Syncer, 2021/02/15
- [elpa] externals/dash 0ee27a4 157/316: Clarify docs on -zip-pair future behaviour, ELPA Syncer, 2021/02/15
- [elpa] externals/dash 5f65fdf 159/316: Merge pull request #321 from wbolster/some-macro-indentation, ELPA Syncer, 2021/02/15
- [elpa] externals/dash 13e5366 161/316: Merge pull request #323 from tarsiiformes/typos, ELPA Syncer, 2021/02/15
- [elpa] externals/dash c645ed6 162/316: use bash for pre-commit script, ELPA Syncer, 2021/02/15
- [elpa] externals/dash ea7adeb 165/316: Merge pull request #328 from conao3/github-actions, ELPA Syncer, 2021/02/15
- [elpa] externals/dash 42862f3 164/316: Use github actions instead of travis, ELPA Syncer, 2021/02/15
- [elpa] externals/dash feea52d 174/316: Fix typo, ELPA Syncer, 2021/02/15
- [elpa] externals/dash 0f238a9 177/316: Merge pull request #346 from jcs-PR/badge, ELPA Syncer, 2021/02/15
- [elpa] externals/dash 52fd010 167/316: feat: add -zip-lists,
ELPA Syncer <=
- [elpa] externals/dash be03404 179/316: Fix package keywords, ELPA Syncer, 2021/02/15
- [elpa] externals/dash b92ab5a 175/316: Merge branch 'zaeph/fix-typo', ELPA Syncer, 2021/02/15
- [elpa] externals/dash eb0a94f 178/316: Update docs after incorporating README.md change, ELPA Syncer, 2021/02/15
- [elpa] externals/dash 732d92e 173/316: Remove duplicate definition., ELPA Syncer, 2021/02/15
- [elpa] externals/dash b1bc1bf 181/316: Use correct names of package archives, ELPA Syncer, 2021/02/15
- [elpa] externals/dash f2c0e0d 184/316: Add dash-fontify-mode, ELPA Syncer, 2021/02/15
- [elpa] externals/dash e47ecb8 187/316: Improve --each-while, ELPA Syncer, 2021/02/15
- [elpa] externals/dash 081e10a 192/316: Improve take/drop definitions, ELPA Syncer, 2021/02/15
- [elpa] externals/dash aa76fb3 201/316: Copy-edit README, ELPA Syncer, 2021/02/15
- [elpa] externals/dash ac1f66a 215/316: ; Fix omission in last change, ELPA Syncer, 2021/02/15