wilderjds
/
dash.el
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Update info

Browse Source
master
Matus Goljer 9 years ago
parent 4b805e1355
commit 1422b70b56
2 changed files with 260 additions and 204 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 425
      dash.info
  2. 39
      dash.texi

425
dash.info
Unescape View File

@ -203,10 +203,9 @@ The results are collected in order and returned as new list.
⇒ '(1 4 9 16)
-- Function: -map-when (pred rep list)
Return a new list where the elements in LIST that does 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.
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’
@ -319,6 +318,8 @@ The results are collected in order and returned as new list.
-- Function: -copy (arg)
Create a shallow copy of LIST.
(fn LIST)
(-copy '(1 2 3))
⇒ '(1 2 3)
(let ((a '(1 2 3))) (eq a (-copy a)))
@ -451,6 +452,8 @@ Functions returning a sublist of the original list.
See also: ‘-drop-last’ (*note -drop-last::)
(fn N LIST)
(-drop 3 '(1 2 3 4 5))
⇒ '(4 5)
(-drop 17 '(1 2 3 4 5))
@ -1443,7 +1446,7 @@ 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 2.0
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.
@ -1462,6 +1465,23 @@ Other list functions not fit to be classified elsewhere.
(-zip-fill 0 '(1 2 3 4 5) '(6 7 8 9))
⇒ '((1 . 6) (2 . 7) (3 . 8) (4 . 9) (5 . 0))
-- Function: -unzip (lists)
Unzip LISTS.
This works just like ‘-zip’ (*note -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).
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))
-- Function: -cycle (list)
Return an infinite copy of LIST that will cycle through the
elements and repeat from the beginning.
@ -1568,6 +1588,8 @@ Other list functions not fit to be classified elsewhere.
-- Function: -first-item (list)
Return the first item of LIST, or nil on an empty list.
(fn LIST)
(-first-item '(1 2 3))
⇒ 1
(-first-item nil)
@ -2273,8 +2295,8 @@ offered in a separate package: ‘dash-functional‘.
⇒ '(1 2 3 4 5)
(-map (-cut funcall <> 5) '(1+ 1- (lambda (x) (/ 1.0 x))))
⇒ '(6 4 0.2)
(-filter (-cut < <> 5) '(1 3 5 7 9))
⇒ '(1 3)
(-map (-cut <> 1 2 3) (list 'list 'vector 'string))
⇒ '((1 2 3) [1 2 3] "")
-- Function: -not (pred)
Take a unary predicate PRED and return a unary predicate that
@ -2591,12 +2613,12 @@ Index
* -all?: Predicates. (line 18)
* -andfn: Function combinators.
(line 138)
* -annotate: Maps. (line 80)
* -annotate: Maps. (line 79)
* -any?: Predicates. (line 6)
* -applify: Function combinators.
(line 55)
* -butlast: Other list operations.
(line 241)
(line 260)
* -clone: Tree operations. (line 122)
* -compose: Function combinators.
(line 42)
@ -2606,19 +2628,19 @@ Index
* -const: Function combinators.
(line 92)
* -contains?: Predicates. (line 57)
* -copy: Maps. (line 135)
* -copy: Maps. (line 134)
* -count: Reductions. (line 89)
* -cut: Function combinators.
(line 104)
* -cycle: Other list operations.
(line 122)
(line 139)
* -difference: Set operations. (line 20)
* -distinct: Set operations. (line 44)
* -dotimes: Side-effects. (line 41)
* -doto: Side-effects. (line 50)
* -drop: Sublist selection. (line 122)
* -drop-last: Sublist selection. (line 132)
* -drop-while: Sublist selection. (line 153)
* -drop-last: Sublist selection. (line 134)
* -drop-while: Sublist selection. (line 155)
* -each: Side-effects. (line 8)
* -each-indexed: Side-effects. (line 28)
* -each-while: Side-effects. (line 19)
@ -2629,11 +2651,11 @@ Index
* -find-indices: Indexing. (line 60)
* -find-last-index: Indexing. (line 46)
* -first: Other list operations.
(line 188)
(line 205)
* -first-item: Other list operations.
(line 225)
(line 242)
* -fix: Other list operations.
(line 277)
(line 296)
* -fixfn: Function combinators.
(line 175)
* -flatten: List to list. (line 33)
@ -2662,19 +2684,19 @@ Index
* -keep: List to list. (line 8)
* -lambda: Binding. (line 216)
* -last: Other list operations.
(line 215)
(line 232)
* -last-item: Other list operations.
(line 233)
(line 252)
* -let: Binding. (line 62)
* -let*: Binding. (line 196)
* -list: Other list operations.
(line 264)
(line 283)
* -map: Maps. (line 10)
* -map-first: Maps. (line 38)
* -map-indexed: Maps. (line 66)
* -map-last: Maps. (line 52)
* -map-first: Maps. (line 37)
* -map-indexed: Maps. (line 65)
* -map-last: Maps. (line 51)
* -map-when: Maps. (line 21)
* -mapcat: Maps. (line 124)
* -mapcat: Maps. (line 123)
* -max: Reductions. (line 141)
* -max-by: Reductions. (line 151)
* -min: Reductions. (line 117)
@ -2689,7 +2711,7 @@ Index
* -orfn: Function combinators.
(line 126)
* -pad: Other list operations.
(line 133)
(line 150)
* -partial: Function combinators.
(line 9)
* -partition: Partitioning. (line 74)
@ -2722,34 +2744,34 @@ Index
* -rpartial: Function combinators.
(line 20)
* -same-items?: Predicates. (line 72)
* -select-by-indices: Sublist selection. (line 164)
* -select-column: Sublist selection. (line 194)
* -select-columns: Sublist selection. (line 175)
* -select-by-indices: Sublist selection. (line 166)
* -select-column: Sublist selection. (line 196)
* -select-columns: Sublist selection. (line 177)
* -separate: Partitioning. (line 63)
* -slice: Sublist selection. (line 83)
* -snoc: Other list operations.
(line 42)
* -some: Other list operations.
(line 202)
(line 219)
* -some-->: Threading macros. (line 69)
* -some->: Threading macros. (line 45)
* -some->>: Threading macros. (line 57)
* -sort: Other list operations.
(line 251)
* -splice: Maps. (line 91)
* -splice-list: Maps. (line 111)
(line 270)
* -splice: Maps. (line 90)
* -splice-list: Maps. (line 110)
* -split-at: Partitioning. (line 8)
* -split-on: Partitioning. (line 28)
* -split-when: Partitioning. (line 46)
* -split-with: Partitioning. (line 17)
* -sum: Reductions. (line 97)
* -table: Other list operations.
(line 144)
(line 161)
* -table-flat: Other list operations.
(line 163)
(line 180)
* -take: Sublist selection. (line 99)
* -take-last: Sublist selection. (line 110)
* -take-while: Sublist selection. (line 142)
* -take-while: Sublist selection. (line 144)
* -tree-map: Tree operations. (line 28)
* -tree-map-nodes: Tree operations. (line 39)
* -tree-mapreduce: Tree operations. (line 84)
@ -2759,6 +2781,8 @@ Index
* -tree-seq: Tree operations. (line 8)
* -unfold: Unfolding. (line 25)
* -union: Set operations. (line 8)
* -unzip: Other list operations.
(line 122)
* -update-at: List to list. (line 132)
* -when-let: Binding. (line 9)
* -when-let*: Binding. (line 22)
@ -2780,172 +2804,173 @@ Node: Functions3749
Node: Maps4960
Ref: -map5255
Ref: -map-when5596
Ref: -map-first6181
Ref: -map-last6659
Ref: -map-indexed7133
Ref: -annotate7606
Ref: -splice8096
Ref: -splice-list8877
Ref: -mapcat9339
Ref: -copy9715
Node: Sublist selection9903
Ref: -filter10096
Ref: -remove10514
Ref: -remove-first10871
Ref: -remove-last11398
Ref: -remove-item11919
Ref: -non-nil12313
Ref: -slice12472
Ref: -take13004
Ref: -take-last13312
Ref: -drop13635
Ref: -drop-last13890
Ref: -take-while14150
Ref: -drop-while14500
Ref: -select-by-indices14856
Ref: -select-columns15370
Ref: -select-column16076
Node: List to list16540
Ref: -keep16727
Ref: -concat17230
Ref: -flatten17527
Ref: -flatten-n18286
Ref: -replace18673
Ref: -replace-first19136
Ref: -replace-last19632
Ref: -insert-at20121
Ref: -replace-at20448
Ref: -update-at20838
Ref: -remove-at21329
Ref: -remove-at-indices21817
Node: Reductions22399
Ref: -reduce-from22568
Ref: -reduce-r-from23347
Ref: -reduce24132
Ref: -reduce-r24933
Ref: -count25850
Ref: -sum26074
Ref: -product26263
Ref: -min26472
Ref: -min-by26698
Ref: -max27221
Ref: -max-by27446
Node: Unfolding27974
Ref: -iterate28213
Ref: -unfold28658
Node: Predicates29466
Ref: -any?29590
Ref: -all?29918
Ref: -none?30248
Ref: -only-some?30550
Ref: -contains?31035
Ref: -same-items?31424
Ref: -is-prefix?31809
Ref: -is-suffix?32132
Ref: -is-infix?32455
Node: Partitioning32809
Ref: -split-at32997
Ref: -split-with33282
Ref: -split-on33685
Ref: -split-when34361
Ref: -separate35001
Ref: -partition35443
Ref: -partition-all35895
Ref: -partition-in-steps36323
Ref: -partition-all-in-steps36820
Ref: -partition-by37305
Ref: -partition-by-header37687
Ref: -group-by38291
Node: Indexing38728
Ref: -elem-index38930
Ref: -elem-indices39325
Ref: -find-index39708
Ref: -find-last-index40197
Ref: -find-indices40701
Ref: -grade-up41109
Ref: -grade-down41512
Node: Set operations41922
Ref: -union42105
Ref: -difference42547
Ref: -intersection42964
Ref: -distinct43401
Node: Other list operations43725
Ref: -rotate43950
Ref: -repeat44245
Ref: -cons*44508
Ref: -snoc44895
Ref: -interpose45308
Ref: -interleave45606
Ref: -zip-with45975
Ref: -zip46678
Ref: -zip-fill47484
Ref: -cycle47807
Ref: -pad48180
Ref: -table48503
Ref: -table-flat49292
Ref: -first50291
Ref: -some50665
Ref: -last51035
Ref: -first-item51369
Ref: -last-item51568
Ref: -butlast51763
Ref: -sort52010
Ref: -list52499
Ref: -fix52830
Node: Tree operations53370
Ref: -tree-seq53566
Ref: -tree-map54424
Ref: -tree-map-nodes54867
Ref: -tree-reduce55717
Ref: -tree-reduce-from56599
Ref: -tree-mapreduce57200
Ref: -tree-mapreduce-from58060
Ref: -clone59346
Node: Threading macros59674
Ref: ->59819
Ref: ->>60310
Ref: -->60815
Ref: -some->61341
Ref: -some->>61715
Ref: -some-->62151
Node: Binding62622
Ref: -when-let62834
Ref: -when-let*63328
Ref: -if-let63851
Ref: -if-let*64246
Ref: -let64863
Ref: -let*69658
Ref: -lambda70598
Node: Side-effects71395
Ref: -each71589
Ref: -each-while71996
Ref: -each-indexed72356
Ref: -dotimes72867
Ref: -doto73170
Node: Destructive operations73598
Ref: !cons73771
Ref: !cdr73977
Node: Function combinators74172
Ref: -partial74446
Ref: -rpartial74842
Ref: -juxt75245
Ref: -compose75677
Ref: -applify76230
Ref: -on76677
Ref: -flip77200
Ref: -const77512
Ref: -cut77851
Ref: -not78304
Ref: -orfn78614
Ref: -andfn79048
Ref: -iteratefn79543
Ref: -fixfn80246
Ref: -prodfn81809
Node: Development82871
Node: Contribute83220
Node: Changes83968
Node: Contributors86966
Node: Index88585
Ref: -map-first6174
Ref: -map-last6652
Ref: -map-indexed7126
Ref: -annotate7599
Ref: -splice8089
Ref: -splice-list8870
Ref: -mapcat9332
Ref: -copy9708
Node: Sublist selection9912
Ref: -filter10105
Ref: -remove10523
Ref: -remove-first10880
Ref: -remove-last11407
Ref: -remove-item11928
Ref: -non-nil12322
Ref: -slice12481
Ref: -take13013
Ref: -take-last13321
Ref: -drop13644
Ref: -drop-last13917
Ref: -take-while14177
Ref: -drop-while14527
Ref: -select-by-indices14883
Ref: -select-columns15397
Ref: -select-column16103
Node: List to list16567
Ref: -keep16754
Ref: -concat17257
Ref: -flatten17554
Ref: -flatten-n18313
Ref: -replace18700
Ref: -replace-first19163
Ref: -replace-last19659
Ref: -insert-at20148
Ref: -replace-at20475
Ref: -update-at20865
Ref: -remove-at21356
Ref: -remove-at-indices21844
Node: Reductions22426
Ref: -reduce-from22595
Ref: -reduce-r-from23374
Ref: -reduce24159
Ref: -reduce-r24960
Ref: -count25877
Ref: -sum26101
Ref: -product26290
Ref: -min26499
Ref: -min-by26725
Ref: -max27248
Ref: -max-by27473
Node: Unfolding28001
Ref: -iterate28240
Ref: -unfold28685
Node: Predicates29493
Ref: -any?29617
Ref: -all?29945
Ref: -none?30275
Ref: -only-some?30577
Ref: -contains?31062
Ref: -same-items?31451
Ref: -is-prefix?31836
Ref: -is-suffix?32159
Ref: -is-infix?32482
Node: Partitioning32836
Ref: -split-at33024
Ref: -split-with33309
Ref: -split-on33712
Ref: -split-when34388
Ref: -separate35028
Ref: -partition35470
Ref: -partition-all35922
Ref: -partition-in-steps36350
Ref: -partition-all-in-steps36847
Ref: -partition-by37332
Ref: -partition-by-header37714
Ref: -group-by38318
Node: Indexing38755
Ref: -elem-index38957
Ref: -elem-indices39352
Ref: -find-index39735
Ref: -find-last-index40224
Ref: -find-indices40728
Ref: -grade-up41136
Ref: -grade-down41539
Node: Set operations41949
Ref: -union42132
Ref: -difference42574
Ref: -intersection42991
Ref: -distinct43428
Node: Other list operations43752
Ref: -rotate43977
Ref: -repeat44272
Ref: -cons*44535
Ref: -snoc44922
Ref: -interpose45335
Ref: -interleave45633
Ref: -zip-with46002
Ref: -zip46705
Ref: -zip-fill47511
Ref: -unzip47834
Ref: -cycle48368
Ref: -pad48741
Ref: -table49064
Ref: -table-flat49853
Ref: -first50852
Ref: -some51226
Ref: -last51596
Ref: -first-item51930
Ref: -last-item52145
Ref: -butlast52340
Ref: -sort52587
Ref: -list53076
Ref: -fix53407
Node: Tree operations53947
Ref: -tree-seq54143
Ref: -tree-map55001
Ref: -tree-map-nodes55444
Ref: -tree-reduce56294
Ref: -tree-reduce-from57176
Ref: -tree-mapreduce57777
Ref: -tree-mapreduce-from58637
Ref: -clone59923
Node: Threading macros60251
Ref: ->60396
Ref: ->>60887
Ref: -->61392
Ref: -some->61918
Ref: -some->>62292
Ref: -some-->62728
Node: Binding63199
Ref: -when-let63411
Ref: -when-let*63905
Ref: -if-let64428
Ref: -if-let*64823
Ref: -let65440
Ref: -let*70235
Ref: -lambda71175
Node: Side-effects71972
Ref: -each72166
Ref: -each-while72573
Ref: -each-indexed72933
Ref: -dotimes73444
Ref: -doto73747
Node: Destructive operations74175
Ref: !cons74348
Ref: !cdr74554
Node: Function combinators74749
Ref: -partial75023
Ref: -rpartial75419
Ref: -juxt75822
Ref: -compose76254
Ref: -applify76807
Ref: -on77254
Ref: -flip77777
Ref: -const78089
Ref: -cut78428
Ref: -not78914
Ref: -orfn79224
Ref: -andfn79658
Ref: -iteratefn80153
Ref: -fixfn80856
Ref: -prodfn82419
Node: Development83481
Node: Contribute83830
Node: Changes84578
Node: Contributors87576
Node: Index89195

End Tag Table

39
dash.texi
Unescape View File

@ -226,7 +226,7 @@ Return a new list consisting of the result of applying @var{fn} to the items in
@anchor{-map-when}
@defun -map-when (pred rep list)
Return a new list where the elements in @var{list} that does not match the @var{pred} function
Return a new list where the elements in @var{list} that do not match the @var{pred} function
are unchanged, and where the elements in @var{list} that do match the @var{pred} function are mapped
through the @var{rep} function.
@ -410,6 +410,8 @@ Thus function @var{fn} should return a list.
@defun -copy (arg)
Create a shallow copy of @var{list}.
(fn @var{list})
@example
@group
(-copy '(1 2 3))
@ -630,6 +632,8 @@ Return the tail of @var{list} without the first @var{n} items.
See also: @code{-drop-last} (@pxref{-drop-last})
(fn @var{n} @var{list})
@example
@group
(-drop 3 '(1 2 3 4 5))
@ -2276,7 +2280,7 @@ 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 2.0
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.
@example
@ -2309,6 +2313,31 @@ longest input list.
@end example
@end defun
@anchor{-unzip}
@defun -unzip (lists)
Unzip @var{lists}.
This works just like @code{-zip} (@pxref{-zip}) but takes a list of lists instead of
a variable number of arguments, such that
(-unzip (-zip @var{l1} @var{l2} @var{l3} ...))
is identity (given that the lists are the same length).
See also: @code{-zip} (@pxref{-zip})
@example
@group
(-unzip (-zip '(1 2 3) '(a b c) '("e" "f" "g")))
@result{} '((1 2 3) (a b c) ("e" "f" "g"))
@end group
@group
(-unzip '((1 2) (3 4) (5 6) (7 8) (9 10)))
@result{} '((1 3 5 7 9) (2 4 6 8 10))
@end group
@end example
@end defun
@anchor{-cycle}
@defun -cycle (list)
Return an infinite copy of @var{list} that will cycle through the
@ -2484,6 +2513,8 @@ Return the last x in @var{list} where (@var{pred} x) is non-nil, else nil.
@defun -first-item (list)
Return the first item of @var{list}, or nil on an empty list.
(fn @var{list})
@example
@group
(-first-item '(1 2 3))
@ -3569,8 +3600,8 @@ See @var{srfi-26} for detailed description.
@result{} '(6 4 0.2)
@end group
@group
(-filter (-cut < <> 5) '(1 3 5 7 9))
@result{} '(1 3)
(-map (-cut <> 1 2 3) (list 'list 'vector 'string))
@result{} '((1 2 3) [1 2 3] "")
@end group
@end example
@end defmac

Write Preview
Loading…
Cancel
Save