daniel/emacs
1
2
Fork 0
Code Issues 7 Pull Requests Projects Releases Wiki Activity

update of packages

Browse Source
This commit is contained in:
Daniel Weschke
2023-11-04 19:26:41 +01:00
parent e162a12b58
commit 3b54a3236d
726 changed files with 297673 additions and 34585 deletions
Download Patch File Download Diff File Expand all files Collapse all files

722
lisp/dash/dash.info
View File

@@ -1,8 +1,8 @@
This is dash.info, produced by makeinfo version 7.0.1 from dash.texi.
This is dash.info, produced by makeinfo version 6.8 from dash.texi.
This manual is for Dash version 2.19.1.
Copyright © 2012–2021 Free Software Foundation, Inc.
Copyright © 2012–2023 Free Software Foundation, Inc.
Permission is granted to copy, distribute and/or modify this
document under the terms of the GNU Free Documentation License,
@@ -24,7 +24,7 @@ Dash
This manual is for Dash version 2.19.1.
Copyright © 2012–2021 Free Software Foundation, Inc.
Copyright © 2012–2023 Free Software Foundation, Inc.
Permission is granted to copy, distribute and/or modify this
document under the terms of the GNU Free Documentation License,
@@ -767,31 +767,42 @@ Functions returning a modified copy of the input list.
⇒ ("foo" "bar" 3 "quux")
-- Function: -remove-at (n list)
Return a list with element at Nth position in LIST removed.
Return LIST with its element at index N removed. That is, remove
any element selected as (nth N LIST) from LIST and return the
result.
This is a non-destructive operation: parts of LIST (but not
necessarily all of it) are copied as needed to avoid destructively
modifying it.
See also: ‘-remove-at-indices’ (*note -remove-at-indices::),
‘-remove’ (*note -remove::)
‘-remove’ (*note -remove::).
(-remove-at 0 '("0" "1" "2" "3" "4" "5"))
⇒ ("1" "2" "3" "4" "5")
(-remove-at 1 '("0" "1" "2" "3" "4" "5"))
⇒ ("0" "2" "3" "4" "5")
(-remove-at 2 '("0" "1" "2" "3" "4" "5"))
⇒ ("0" "1" "3" "4" "5")
(-remove-at 0 '(a b c))
⇒ (b c)
(-remove-at 1 '(a b c))
⇒ (a c)
(-remove-at 2 '(a b c))
⇒ (a b)
-- Function: -remove-at-indices (indices list)
Return a list whose elements are elements from LIST without
elements selected as ‘(nth i list)‘ for all i from INDICES.
Return LIST with its elements at INDICES removed. That is, for
each index I in INDICES, remove any element selected as (nth I
LIST) from LIST.
This is a non-destructive operation: parts of LIST (but not
necessarily all of it) are copied as needed to avoid destructively
modifying it.
See also: ‘-remove-at’ (*note -remove-at::), ‘-remove’ (*note
-remove::)
-remove::).
(-remove-at-indices '(0) '("0" "1" "2" "3" "4" "5"))
⇒ ("1" "2" "3" "4" "5")
(-remove-at-indices '(0 2 4) '("0" "1" "2" "3" "4" "5"))
⇒ ("1" "3" "5")
(-remove-at-indices '(0 5) '("0" "1" "2" "3" "4" "5"))
⇒ ("1" "2" "3" "4")
(-remove-at-indices '(0) '(a b c d e))
⇒ (b c d e)
(-remove-at-indices '(1 3) '(a b c d e))
⇒ (a c e)
(-remove-at-indices '(4 0 2) '(a b c d e))
⇒ (b d)

File: dash.info, Node: Reductions, Next: Unfolding, Prev: List to list, Up: Functions
@@ -1026,7 +1037,7 @@ Functions reducing lists to a single value (which may also be a list).
⇒ (nil (1))
-- Function: -tails (list)
Return all suffixes of LIST
Return all suffixes of LIST.
(-tails '(1 2 3 4))
⇒ ((1 2 3 4) (2 3 4) (3 4) (4) nil)
@@ -1185,8 +1196,8 @@ than consuming a list to produce a single value.
⇒ (1 2 3 1 2)
(-take 7 (-cycle '(1 "and" 3)))
⇒ (1 "and" 3 1 "and" 3 1)
(-zip (-cycle '(1 2 3)) '(1 2))
⇒ ((1 . 1) (2 . 2))
(-zip-lists (-cycle '(3)) '(1 2))
⇒ ((3 1) (3 2))

File: dash.info, Node: Predicates, Next: Partitioning, Prev: Unfolding, Up: Functions
@@ -1871,56 +1882,52 @@ Other list functions not fit to be classified elsewhere.
error→ Wrong type argument: natnump, -1
-- Function: -zip-with (fn list1 list2)
Zip the two lists LIST1 and LIST2 using a function FN. This
function is applied pairwise taking as first argument element of
LIST1 and as second argument element of LIST2 at corresponding
position.
Zip LIST1 and LIST2 into a new list using the function FN. That
is, apply FN pairwise taking as first argument the next element of
LIST1 and as second argument the next element of LIST2 at the
corresponding position. The result is as long as the shorter list.
The anaphoric form ‘--zip-with’ binds the elements from LIST1 as
symbol ‘it’, and the elements from LIST2 as symbol ‘other’.
This function’s anaphoric counterpart is ‘--zip-with’.
(-zip-with '+ '(1 2 3) '(4 5 6))
⇒ (5 7 9)
(-zip-with 'cons '(1 2 3) '(4 5 6))
For other zips, see also ‘-zip-lists’ (*note -zip-lists::) and
‘-zip-fill’ (*note -zip-fill::).
(-zip-with #'+ '(1 2 3 4) '(5 6 7))
⇒ (6 8 10)
(-zip-with #'cons '(1 2 3) '(4 5 6 7))
⇒ ((1 . 4) (2 . 5) (3 . 6))
(--zip-with (concat it " and " other) '("Batman" "Jekyll") '("Robin" "Hyde"))
⇒ ("Batman and Robin" "Jekyll and Hyde")
(--zip-with (format "%s & %s" it other) '(Batman Jekyll) '(Robin Hyde))
⇒ ("Batman & Robin" "Jekyll & Hyde")
-- Function: -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 groupings are equal to the length of the shortest input
list.
-- Function: -zip-pair (list1 list2)
Zip LIST1 and LIST2 together.
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.
Make a pair with the head of each list, followed by a pair with the
second element of each list, and so on. The number of pairs
returned is equal to the length of the shorter input list.
Use ‘-zip-lists’ (*note -zip-lists::) if you need the return value
to always be a list of lists.
See also: ‘-zip-lists’ (*note -zip-lists::).
Alias: ‘-zip-pair’
See also: ‘-zip-lists’ (*note -zip-lists::)
(-zip '(1 2 3) '(4 5 6))
(-zip-pair '(1 2 3 4) '(5 6 7))
⇒ ((1 . 5) (2 . 6) (3 . 7))
(-zip-pair '(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-pair '(1 2) '(3))
⇒ ((1 . 3))
-- 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.
Zip LISTS together.
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.
Group the head of each list, followed by the second element of each
list, and so on. The number of returned groupings is equal to the
length of the shortest input list, and the length of each grouping
is equal to the number of input LISTS.
See also: ‘-zip’ (*note -zip::)
The return value is always a list of proper lists, in contrast to
‘-zip’ (*note -zip::) which returns a list of dotted pairs when
only two input LISTS are provided.
See also: ‘-zip-pair’ (*note -zip-pair::).
(-zip-lists '(1 2 3) '(4 5 6))
⇒ ((1 4) (2 5) (3 6))
@@ -1929,35 +1936,111 @@ Other list functions not fit to be classified elsewhere.
(-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
lengths of the returned groupings are equal to the length of the
longest input list.
-- Function: -zip-lists-fill (fill-value &rest lists)
Zip LISTS together, padding shorter lists with FILL-VALUE. This is
like ‘-zip-lists’ (*note -zip-lists::) (which see), except it
retains all elements at positions beyond the end of the shortest
list. The number of returned groupings is equal to the length of
the longest input list, and the length of each grouping is equal to
the number of input LISTS.
(-zip-fill 0 '(1 2 3 4 5) '(6 7 8 9))
⇒ ((1 . 6) (2 . 7) (3 . 8) (4 . 9) (5 . 0))
(-zip-lists-fill 0 '(1 2) '(3 4 5) '(6))
⇒ ((1 3 6) (2 4 0) (0 5 0))
(-zip-lists-fill 0 '(1 2) '(3 4) '(5 6))
⇒ ((1 3 5) (2 4 6))
(-zip-lists-fill 0 '(1 2 3) nil)
⇒ ((1 0) (2 0) (3 0))
-- Function: -zip (&rest lists)
Zip LISTS together.
Group the head of each list, followed by the second element of each
list, and so on. The number of returned groupings is equal to the
length of the shortest input list, and the number of items in each
grouping is equal to the number of input LISTS.
If only two LISTS are provided as arguments, return the groupings
as a list of dotted pairs. Otherwise, return the groupings as a
list of proper lists.
Since the return value changes form depending on the number of
arguments, it is generally recommended to use ‘-zip-lists’ (*note
-zip-lists::) instead, or ‘-zip-pair’ (*note -zip-pair::) if a list
of dotted pairs is desired.
See also: ‘-unzip’ (*note -unzip::).
(-zip '(1 2 3 4) '(5 6 7) '(8 9))
⇒ ((1 5 8) (2 6 9))
(-zip '(1 2 3) '(4 5 6) '(7 8 9))
⇒ ((1 4 7) (2 5 8) (3 6 9))
(-zip '(1 2 3))
⇒ ((1) (2) (3))
-- Function: -zip-fill (fill-value &rest lists)
Zip LISTS together, padding shorter lists with FILL-VALUE. This is
like ‘-zip’ (*note -zip::) (which see), except it retains all
elements at positions beyond the end of the shortest list. The
number of returned groupings is equal to the length of the longest
input list, and the length of each grouping is equal to the number
of input LISTS.
Since the return value changes form depending on the number of
arguments, it is generally recommended to use ‘-zip-lists-fill’
(*note -zip-lists-fill::) instead, unless a list of dotted pairs is
explicitly desired.
(-zip-fill 0 '(1 2 3) '(4 5))
⇒ ((1 . 4) (2 . 5) (3 . 0))
(-zip-fill 0 () '(1 2 3))
⇒ ((0 . 1) (0 . 2) (0 . 3))
(-zip-fill 0 '(1 2) '(3 4) '(5 6))
⇒ ((1 3 5) (2 4 6))
-- Function: -unzip-lists (lists)
Unzip LISTS.
This works just like ‘-zip-lists’ (*note -zip-lists::) (which see),
but takes a list of lists instead of a variable number of
arguments, such that
(-unzip-lists (-zip-lists ARGS...))
is identity (given that the lists comprising ARGS are of the same
length).
(-unzip-lists (-zip-lists '(1 2) '(3 4) '(5 6)))
⇒ ((1 2) (3 4) (5 6))
(-unzip-lists '((1 2 3) (4 5) (6 7) (8 9)))
⇒ ((1 4 6 8) (2 5 7 9))
(-unzip-lists '((1 2 3) (4 5 6)))
⇒ ((1 4) (2 5) (3 6))
-- 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
This works just like ‘-zip’ (*note -zip::) (which see), 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).
is identity (given that the lists are of the same length, and that
‘-zip’ (*note -zip::) is not called with two arguments, because of
the caveat described in its docstring).
Note in particular that calling this on a list of two lists will
return a list of cons-cells such that the above identity works.
Note in particular that calling ‘-unzip’ (*note -unzip::) on a list
of two lists will return a list of dotted pairs.
See also: ‘-zip’ (*note -zip::)
Since the return value changes form depending on the number of
LISTS, it is generally recommended to use ‘-unzip-lists’ (*note
-unzip-lists::) instead.
(-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))
(-unzip (-zip '(1 2) '(3 4) '(5 6)))
⇒ ((1 . 2) (3 . 4) (5 . 6))
(-unzip '((1 2 3) (4 5 6)))
⇒ ((1 . 4) (2 . 5) (3 . 6))
(-unzip '((1 2 3) (4 5) (6 7) (8 9)))
⇒ ((1 4 6 8) (2 5 7 9))
-- Function: -pad (fill-value &rest lists)
Pad each of LISTS with FILL-VALUE until they all have equal
@@ -2139,9 +2222,9 @@ Other list functions not fit to be classified elsewhere.
called with two elements of LIST, and should return non-‘nil’ if
the first element should sort before the second.
(-sort '< '(3 1 2))
(-sort #'< '(3 1 2))
⇒ (1 2 3)
(-sort '> '(3 1 2))
(-sort #'> '(3 1 2))
⇒ (3 2 1)
(--sort (< it other) '(3 1 2))
⇒ (1 2 3)
@@ -2301,8 +2384,8 @@ Functions pretending lists are trees.
structure but all cons are replaced with new ones. This is useful
when you need to clone a structure such as plist or alist.
(let* ((a '(1 2 3)) (b (-clone a))) (nreverse a) b)
⇒ (1 2 3)
(let* ((a (list (list 1))) (b (-clone a))) (setcar (car a) 2) b)
⇒ ((1))

File: dash.info, Node: Threading macros, Next: Binding, Prev: Tree operations, Up: Functions
@@ -3111,12 +3194,12 @@ Functions that manipulate and compose other functions.
(-compose (-partial #’nth n) (-prod f1 f2 ...)) = (-compose fn
(-partial #’nth n))
(funcall (-prodfn '1+ '1- 'number-to-string) '(1 2 3))
(funcall (-prodfn #'1+ #'1- #'number-to-string) '(1 2 3))
⇒ (2 1 "3")
(-map (-prodfn '1+ '1-) '((1 2) (3 4) (5 6) (7 8)))
⇒ ((2 1) (4 3) (6 5) (8 7))
(apply '+ (funcall (-prodfn 'length 'string-to-number) '((1 2 3) "15")))
⇒ 18
(-map (-prodfn #'1- #'1+) '((1 2) (3 4) (5 6)))
⇒ ((0 3) (2 5) (4 7))
(apply #'+ (funcall (-prodfn #'length #'string-to-number) '((t) "5")))
⇒ 6

File: dash.info, Node: Development, Next: FDL, Prev: Functions, Up: Top
@@ -4424,7 +4507,7 @@ Index
(line 63)
* -as->: Threading macros. (line 49)
* -butlast: Other list operations.
(line 333)
(line 405)
* -clone: Tree operations. (line 123)
* -common-prefix: Reductions. (line 242)
* -common-suffix: Reductions. (line 252)
@@ -4458,17 +4541,17 @@ Index
* -elem-indices: Indexing. (line 23)
* -every: Predicates. (line 23)
* -fifth-item: Other list operations.
(line 308)
(line 380)
* -filter: Sublist selection. (line 8)
* -find-index: Indexing. (line 35)
* -find-indices: Indexing. (line 73)
* -find-last-index: Indexing. (line 54)
* -first: Other list operations.
(line 228)
(line 300)
* -first-item: Other list operations.
(line 256)
(line 328)
* -fix: Other list operations.
(line 373)
(line 445)
* -fixfn: Function combinators.
(line 224)
* -flatten: List to list. (line 38)
@@ -4476,7 +4559,7 @@ Index
* -flip: Function combinators.
(line 95)
* -fourth-item: Other list operations.
(line 295)
(line 367)
* -frequencies: Reductions. (line 310)
* -grade-down: Indexing. (line 103)
* -grade-up: Indexing. (line 93)
@@ -4503,13 +4586,13 @@ Index
* -keep: List to list. (line 8)
* -lambda: Binding. (line 247)
* -last: Other list operations.
(line 246)
(line 318)
* -last-item: Other list operations.
(line 321)
(line 393)
* -let: Binding. (line 61)
* -let*: Binding. (line 227)
* -list: Other list operations.
(line 356)
(line 428)
* -map: Maps. (line 10)
* -map-first: Maps. (line 38)
* -map-indexed: Maps. (line 68)
@@ -4530,7 +4613,7 @@ Index
* -orfn: Function combinators.
(line 167)
* -pad: Other list operations.
(line 169)
(line 241)
* -partial: Function combinators.
(line 8)
* -partition: Partitioning. (line 90)
@@ -4558,7 +4641,7 @@ Index
* -reductions-r-from: Reductions. (line 118)
* -remove: Sublist selection. (line 26)
* -remove-at: List to list. (line 151)
* -remove-at-indices: List to list. (line 164)
* -remove-at-indices: List to list. (line 170)
* -remove-first: Sublist selection. (line 44)
* -remove-item: Sublist selection. (line 84)
* -remove-last: Sublist selection. (line 65)
@@ -4577,7 +4660,7 @@ Index
* -running-sum: Reductions. (line 190)
* -same-items?: Set operations. (line 88)
* -second-item: Other list operations.
(line 269)
(line 341)
* -select-by-indices: Sublist selection. (line 211)
* -select-column: Sublist selection. (line 241)
* -select-columns: Sublist selection. (line 222)
@@ -4591,7 +4674,7 @@ Index
* -some->: Threading macros. (line 62)
* -some->>: Threading macros. (line 74)
* -sort: Other list operations.
(line 343)
(line 415)
* -splice: Maps. (line 102)
* -splice-list: Maps. (line 127)
* -split-at: Partitioning. (line 8)
@@ -4600,15 +4683,15 @@ Index
* -split-with: Partitioning. (line 23)
* -sum: Reductions. (line 180)
* -table: Other list operations.
(line 184)
(line 256)
* -table-flat: Other list operations.
(line 203)
(line 275)
* -tails: Reductions. (line 232)
* -take: Sublist selection. (line 121)
* -take-last: Sublist selection. (line 135)
* -take-while: Sublist selection. (line 177)
* -third-item: Other list operations.
(line 282)
(line 354)
* -tree-map: Tree operations. (line 28)
* -tree-map-nodes: Tree operations. (line 39)
* -tree-mapreduce: Tree operations. (line 85)
@@ -4619,16 +4702,22 @@ Index
* -unfold: Unfolding. (line 25)
* -union: Set operations. (line 8)
* -unzip: Other list operations.
(line 147)
(line 215)
* -unzip-lists: Other list operations.
(line 196)
* -update-at: List to list. (line 137)
* -when-let: Binding. (line 9)
* -when-let*: Binding. (line 21)
* -zip: Other list operations.
(line 96)
(line 150)
* -zip-fill: Other list operations.
(line 139)
(line 176)
* -zip-lists: Other list operations.
(line 120)
(line 114)
* -zip-lists-fill: Other list operations.
(line 135)
* -zip-pair: Other list operations.
(line 98)
* -zip-with: Other list operations.
(line 80)
* dash-fontify-mode: Fontification of special variables.
@@ -4640,213 +4729,216 @@ Index

Tag Table:
Node: Top744
Node: Installation2399
Node: Using in a package3161
Node: Fontification of special variables3506
Node: Info symbol lookup4296
Node: Functions4879
Node: Maps6363
Ref: -map6660
Ref: -map-when7033
Ref: -map-first7607
Ref: -map-last8202
Ref: -map-indexed8792
Ref: -annotate9478
Ref: -splice10082
Ref: -splice-list11157
Ref: -mapcat11616
Ref: -copy11989
Node: Sublist selection12177
Ref: -filter12370
Ref: -remove12923
Ref: -remove-first13472
Ref: -remove-last14320
Ref: -remove-item15050
Ref: -non-nil15450
Ref: -slice15732
Ref: -take16261
Ref: -take-last16679
Ref: -drop17116
Ref: -drop-last17563
Ref: -take-while17995
Ref: -drop-while18622
Ref: -select-by-indices19255
Ref: -select-columns19766
Ref: -select-column20469
Node: List to list20932
Ref: -keep21124
Ref: -concat21700
Ref: -flatten22228
Ref: -flatten-n22990
Ref: -replace23374
Ref: -replace-first23835
Ref: -replace-last24330
Ref: -insert-at24818
Ref: -replace-at25143
Ref: -update-at25530
Ref: -remove-at26071
Ref: -remove-at-indices26556
Node: Reductions27135
Ref: -reduce-from27331
Ref: -reduce-r-from28055
Ref: -reduce29318
Ref: -reduce-r30069
Ref: -reductions-from31347
Ref: -reductions-r-from32153
Ref: -reductions32983
Ref: -reductions-r33694
Ref: -count34439
Ref: -sum34669
Ref: -running-sum34857
Ref: -product35178
Ref: -running-product35386
Ref: -inits35727
Ref: -tails35972
Ref: -common-prefix36216
Ref: -common-suffix36510
Ref: -min36804
Ref: -min-by37030
Ref: -max37551
Ref: -max-by37776
Ref: -frequencies38302
Node: Unfolding38917
Ref: -iterate39158
Ref: -unfold39605
Ref: -repeat40410
Ref: -cycle40694
Node: Predicates41093
Ref: -some41270
Ref: -every41699
Ref: -any?42413
Ref: -all?42762
Ref: -none?43504
Ref: -only-some?43824
Ref: -contains?44369
Ref: -is-prefix?44875
Ref: -is-suffix?45207
Ref: -is-infix?45539
Ref: -cons-pair?45899
Node: Partitioning46230
Ref: -split-at46418
Ref: -split-with47082
Ref: -split-on47722
Ref: -split-when48393
Ref: -separate49036
Ref: -partition49570
Ref: -partition-all50019
Ref: -partition-in-steps50444
Ref: -partition-all-in-steps50990
Ref: -partition-by51504
Ref: -partition-by-header51882
Ref: -partition-after-pred52483
Ref: -partition-before-pred52936
Ref: -partition-before-item53321
Ref: -partition-after-item53628
Ref: -group-by53930
Node: Indexing54363
Ref: -elem-index54565
Ref: -elem-indices55052
Ref: -find-index55511
Ref: -find-last-index56180
Ref: -find-indices56831
Ref: -grade-up57593
Ref: -grade-down58000
Node: Set operations58414
Ref: -union58597
Ref: -difference59027
Ref: -intersection59455
Ref: -powerset59884
Ref: -permutations60161
Ref: -distinct60599
Ref: -same-items?60993
Node: Other list operations61602
Ref: -rotate61827
Ref: -cons*62180
Ref: -snoc62602
Ref: -interpose63014
Ref: -interleave63308
Ref: -iota63674
Ref: -zip-with64157
Ref: -zip64871
Ref: -zip-lists65700
Ref: -zip-fill66398
Ref: -unzip66720
Ref: -pad67462
Ref: -table67947
Ref: -table-flat68733
Ref: -first69738
Ref: -last70271
Ref: -first-item70617
Ref: -second-item71029
Ref: -third-item71446
Ref: -fourth-item71821
Ref: -fifth-item72199
Ref: -last-item72574
Ref: -butlast72935
Ref: -sort73180
Ref: -list73672
Ref: -fix74241
Node: Tree operations74730
Ref: -tree-seq74926
Ref: -tree-map75787
Ref: -tree-map-nodes76227
Ref: -tree-reduce77091
Ref: -tree-reduce-from77973
Ref: -tree-mapreduce78573
Ref: -tree-mapreduce-from79432
Ref: -clone80717
Node: Threading macros81044
Ref: ->81269
Ref: ->>81757
Ref: -->82260
Ref: -as->82816
Ref: -some->83270
Ref: -some->>83655
Ref: -some-->84102
Ref: -doto84669
Node: Binding85222
Ref: -when-let85429
Ref: -when-let*85890
Ref: -if-let86419
Ref: -if-let*86785
Ref: -let87408
Ref: -let*93498
Ref: -lambda94435
Ref: -setq95241
Node: Side effects96042
Ref: -each96236
Ref: -each-while96763
Ref: -each-indexed97383
Ref: -each-r97975
Ref: -each-r-while98417
Ref: -dotimes99061
Node: Destructive operations99614
Ref: !cons99832
Ref: !cdr100036
Node: Function combinators100229
Ref: -partial100433
Ref: -rpartial100951
Ref: -juxt101599
Ref: -compose102051
Ref: -applify102658
Ref: -on103088
Ref: -flip103860
Ref: -rotate-args104384
Ref: -const105013
Ref: -cut105355
Ref: -not105835
Ref: -orfn106379
Ref: -andfn107172
Ref: -iteratefn107959
Ref: -fixfn108661
Ref: -prodfn110235
Node: Development111396
Node: Contribute111685
Node: Contributors112697
Node: FDL114790
Node: GPL140110
Node: Index177859
Node: Top742
Node: Installation2397
Node: Using in a package3159
Node: Fontification of special variables3504
Node: Info symbol lookup4294
Node: Functions4877
Node: Maps6361
Ref: -map6658
Ref: -map-when7031
Ref: -map-first7605
Ref: -map-last8200
Ref: -map-indexed8790
Ref: -annotate9476
Ref: -splice10080
Ref: -splice-list11155
Ref: -mapcat11614
Ref: -copy11987
Node: Sublist selection12175
Ref: -filter12368
Ref: -remove12921
Ref: -remove-first13470
Ref: -remove-last14318
Ref: -remove-item15048
Ref: -non-nil15448
Ref: -slice15730
Ref: -take16259
Ref: -take-last16677
Ref: -drop17114
Ref: -drop-last17561
Ref: -take-while17993
Ref: -drop-while18620
Ref: -select-by-indices19253
Ref: -select-columns19764
Ref: -select-column20467
Node: List to list20930
Ref: -keep21122
Ref: -concat21698
Ref: -flatten22226
Ref: -flatten-n22988
Ref: -replace23372
Ref: -replace-first23833
Ref: -replace-last24328
Ref: -insert-at24816
Ref: -replace-at25141
Ref: -update-at25528
Ref: -remove-at26069
Ref: -remove-at-indices26696
Node: Reductions27386
Ref: -reduce-from27582
Ref: -reduce-r-from28306
Ref: -reduce29569
Ref: -reduce-r30320
Ref: -reductions-from31598
Ref: -reductions-r-from32404
Ref: -reductions33234
Ref: -reductions-r33945
Ref: -count34690
Ref: -sum34920
Ref: -running-sum35108
Ref: -product35429
Ref: -running-product35637
Ref: -inits35978
Ref: -tails36223
Ref: -common-prefix36468
Ref: -common-suffix36762
Ref: -min37056
Ref: -min-by37282
Ref: -max37803
Ref: -max-by38028
Ref: -frequencies38554
Node: Unfolding39169
Ref: -iterate39410
Ref: -unfold39857
Ref: -repeat40662
Ref: -cycle40946
Node: Predicates41343
Ref: -some41520
Ref: -every41949
Ref: -any?42663
Ref: -all?43012
Ref: -none?43754
Ref: -only-some?44074
Ref: -contains?44619
Ref: -is-prefix?45125
Ref: -is-suffix?45457
Ref: -is-infix?45789
Ref: -cons-pair?46149
Node: Partitioning46480
Ref: -split-at46668
Ref: -split-with47332
Ref: -split-on47972
Ref: -split-when48643
Ref: -separate49286
Ref: -partition49820
Ref: -partition-all50269
Ref: -partition-in-steps50694
Ref: -partition-all-in-steps51240
Ref: -partition-by51754
Ref: -partition-by-header52132
Ref: -partition-after-pred52733
Ref: -partition-before-pred53186
Ref: -partition-before-item53571
Ref: -partition-after-item53878
Ref: -group-by54180
Node: Indexing54613
Ref: -elem-index54815
Ref: -elem-indices55302
Ref: -find-index55761
Ref: -find-last-index56430
Ref: -find-indices57081
Ref: -grade-up57843
Ref: -grade-down58250
Node: Set operations58664
Ref: -union58847
Ref: -difference59277
Ref: -intersection59705
Ref: -powerset60134
Ref: -permutations60411
Ref: -distinct60849
Ref: -same-items?61243
Node: Other list operations61852
Ref: -rotate62077
Ref: -cons*62430
Ref: -snoc62852
Ref: -interpose63264
Ref: -interleave63558
Ref: -iota63924
Ref: -zip-with64407
Ref: -zip-pair65215
Ref: -zip-lists65781
Ref: -zip-lists-fill66579
Ref: -zip67289
Ref: -zip-fill68316
Ref: -unzip-lists69230
Ref: -unzip69853
Ref: -pad70846
Ref: -table71331
Ref: -table-flat72117
Ref: -first73122
Ref: -last73655
Ref: -first-item74001
Ref: -second-item74413
Ref: -third-item74830
Ref: -fourth-item75205
Ref: -fifth-item75583
Ref: -last-item75958
Ref: -butlast76319
Ref: -sort76564
Ref: -list77058
Ref: -fix77627
Node: Tree operations78116
Ref: -tree-seq78312
Ref: -tree-map79173
Ref: -tree-map-nodes79613
Ref: -tree-reduce80477
Ref: -tree-reduce-from81359
Ref: -tree-mapreduce81959
Ref: -tree-mapreduce-from82818
Ref: -clone84103
Node: Threading macros84441
Ref: ->84666
Ref: ->>85154
Ref: -->85657
Ref: -as->86213
Ref: -some->86667
Ref: -some->>87052
Ref: -some-->87499
Ref: -doto88066
Node: Binding88619
Ref: -when-let88826
Ref: -when-let*89287
Ref: -if-let89816
Ref: -if-let*90182
Ref: -let90805
Ref: -let*96895
Ref: -lambda97832
Ref: -setq98638
Node: Side effects99439
Ref: -each99633
Ref: -each-while100160
Ref: -each-indexed100780
Ref: -each-r101372
Ref: -each-r-while101814
Ref: -dotimes102458
Node: Destructive operations103011
Ref: !cons103229
Ref: !cdr103433
Node: Function combinators103626
Ref: -partial103830
Ref: -rpartial104348
Ref: -juxt104996
Ref: -compose105448
Ref: -applify106055
Ref: -on106485
Ref: -flip107257
Ref: -rotate-args107781
Ref: -const108410
Ref: -cut108752
Ref: -not109232
Ref: -orfn109776
Ref: -andfn110569
Ref: -iteratefn111356
Ref: -fixfn112058
Ref: -prodfn113632
Node: Development114783
Node: Contribute115072
Node: Contributors116084
Node: FDL118177
Node: GPL143497
Node: Index181246

End Tag Table