dbo/.emacs.d
dbo
/
.emacs.d
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Update dash

This commit is contained in:
Daniel - 2020-03-22 10:57:42 +01:00
parent 113045a648
commit 50028af0b4
No known key found for this signature in database
GPG Key ID: 1C7071A75BB72D64
5 changed files with 344 additions and 268 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

0
elpa/dash-2.16.0/dash-autoloads.el → elpa/dash-2.17.0/dash-autoloads.el
View File

2
elpa/dash-2.16.0/dash-pkg.el → elpa/dash-2.17.0/dash-pkg.el
View File

@ -1,4 +1,4 @@
(define-package "dash" "2.16.0" "A modern list library for Emacs" 'nil :keywords
(define-package "dash" "2.17.0" "A modern list library for Emacs" 'nil :keywords
'("lists")
:authors
'(("Magnar Sveen" . "magnars@gmail.com"))

107
elpa/dash-2.16.0/dash.el → elpa/dash-2.17.0/dash.el
View File

@ -3,7 +3,7 @@
;; Copyright (C) 2012-2016 Free Software Foundation, Inc.
;; Author: Magnar Sveen <magnars@gmail.com>
;; Version: 2.16.0
;; Version: 2.17.0
;; Keywords: lists
;; This program is free software; you can redistribute it and/or modify
@ -33,6 +33,12 @@
;;; Code:
;; TODO: `gv' was introduced in Emacs 24.3, so remove this and all
;; calls to `defsetf' when support for earlier versions is dropped.
(eval-when-compile
(unless (fboundp 'gv-define-setter)
(require 'cl)))
(defgroup dash ()
"Customize group for dash.el"
:group 'lisp
@ -397,7 +403,7 @@ See also: `-remove', `-map-last'"
(defalias '--reject-last '--remove-last)
(defun -remove-item (item list)
"Remove all occurences of ITEM from LIST.
"Remove all occurrences of ITEM from LIST.
Comparison is done with `equal'."
(declare (pure t) (side-effect-free t))
@ -497,7 +503,7 @@ See also: `-replace-at'"
(--map-when (equal it old) new list))
(defun -replace-first (old new list)
"Replace the first occurence of OLD with NEW in LIST.
"Replace the first occurrence of OLD with NEW in LIST.
Elements are compared using `equal'.
@ -506,7 +512,7 @@ See also: `-map-first'"
(--map-first (equal old it) new list))
(defun -replace-last (old new list)
"Replace the last occurence of OLD with NEW in LIST.
"Replace the last occurrence of OLD with NEW in LIST.
Elements are compared using `equal'.
@ -682,7 +688,10 @@ See also: `-third-item'.
\(fn LIST)")
(defalias '-third-item 'caddr
(defalias '-third-item
(if (fboundp 'caddr)
#'caddr
(lambda (list) (car (cddr list))))
"Return the third item of LIST, or nil if LIST is too short.
See also: `-fourth-item'.
@ -703,28 +712,18 @@ See also: `-last-item'."
(declare (pure t) (side-effect-free t))
(car (cdr (cdr (cdr (cdr list))))))
;; TODO: gv was introduced in 24.3, so we can remove the if statement
;; when support for earlier versions is dropped
(eval-when-compile
(require 'cl)
(if (fboundp 'gv-define-simple-setter)
(gv-define-simple-setter -first-item setcar)
(require 'cl)
(with-no-warnings
(defsetf -first-item (x) (val) `(setcar ,x ,val)))))
(defun -last-item (list)
"Return the last item of LIST, or nil on an empty list."
(declare (pure t) (side-effect-free t))
(car (last list)))
;; TODO: gv was introduced in 24.3, so we can remove the if statement
;; when support for earlier versions is dropped
(eval-when-compile
;; Use `with-no-warnings' to suppress unbound `-last-item' or
;; undefined `gv--defsetter' warnings arising from both
;; `gv-define-setter' and `defsetf' in certain Emacs versions.
(with-no-warnings
(if (fboundp 'gv-define-setter)
(gv-define-setter -last-item (val x) `(setcar (last ,x) ,val))
(with-no-warnings
(defsetf -last-item (x) (val) `(setcar (last ,x) ,val)))))
(defsetf -last-item (x) (val) `(setcar (last ,x) ,val))))
(defun -butlast (list)
"Return a list of all items in list except for the last."
@ -1264,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
@ -1272,8 +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."
Use `-zip-lists' if you need the return value to always be a list
of lists.
Alias: `-zip-pair'
See also: `-zip-lists'"
(declare (pure t) (side-effect-free t))
(when lists
(let (results)
@ -1282,7 +1303,7 @@ release of Dash. If you rely on this behavior, use -zip-pair instead."
(setq lists (mapcar 'cdr lists)))
(setq results (nreverse results))
(if (= (length lists) 2)
;; to support backward compatability, return
;; to support backward compatibility, return
;; a cons cell if two lists were provided
(--map (cons (car it) (cadr it)) results)
results))))
@ -1306,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))
@ -1537,7 +1561,8 @@ VARIABLE to the result of the first form, and so forth."
(defmacro -some-> (x &optional form &rest more)
"When expr is non-nil, thread it through the first form (via `->'),
and when that result is non-nil, through the next form, etc."
(declare (debug ->))
(declare (debug ->)
(indent 1))
(if (null form) x
(let ((result (make-symbol "result")))
`(-some-> (-when-let (,result ,x)
@ -1547,7 +1572,8 @@ and when that result is non-nil, through the next form, etc."
(defmacro -some->> (x &optional form &rest more)
"When expr is non-nil, thread it through the first form (via `->>'),
and when that result is non-nil, through the next form, etc."
(declare (debug ->))
(declare (debug ->)
(indent 1))
(if (null form) x
(let ((result (make-symbol "result")))
`(-some->> (-when-let (,result ,x)
@ -1557,7 +1583,8 @@ and when that result is non-nil, through the next form, etc."
(defmacro -some--> (x &optional form &rest more)
"When expr in non-nil, thread it through the first form (via `-->'),
and when that result is non-nil, through the next form, etc."
(declare (debug ->))
(declare (debug ->)
(indent 1))
(if (null form) x
(let ((result (make-symbol "result")))
`(-some--> (-when-let (,result ,x)
@ -1654,7 +1681,7 @@ All returned symbols are guaranteed to be unique."
(defun dash--get-expand-function (type)
"Get expand function name for TYPE."
(intern (format "dash-expand:%s" type)))
(intern-soft (format "dash-expand:%s" type)))
(defun dash--match-cons-1 (match-form source &optional props)
"Match MATCH-FORM against SOURCE.
@ -2274,9 +2301,22 @@ The test for equality is done with `equal',
or with `-compare-fn' if that's non-nil.
Alias: `-uniq'"
(let (result)
(--each list (unless (-contains? result it) (!cons it result)))
(nreverse result)))
;; Implementation note: The speedup gained from hash table lookup
;; starts to outweigh its overhead for lists of length greater than
;; 32. See discussion in PR #305.
(let* ((len (length list))
(lut (and (> len 32)
;; Check that `-compare-fn' is a valid hash-table
;; lookup function or `nil'.
(memq -compare-fn '(nil equal eq eql))
(make-hash-table :test (or -compare-fn #'equal)
:size len))))
(if lut
(--filter (unless (gethash it lut)
(puthash it t lut))
list)
(--each list (unless (-contains? lut it) (!cons it lut)))
(nreverse lut))))
(defalias '-uniq '-distinct)
@ -2329,7 +2369,11 @@ or with `-compare-fn' if that's non-nil."
(defun -inits (list)
"Return all prefixes of LIST."
(nreverse (-map 'reverse (-tails (nreverse list)))))
(let ((res (list list)))
(setq list (reverse list))
(while list
(push (reverse (!cdr list)) res))
res))
(defun -tails (list)
"Return all suffixes of LIST"
@ -2899,6 +2943,7 @@ structure such as plist or alist."
"--zip-with"
"-zip"
"-zip-fill"
"-zip-lists"
"-zip-pair"
"-cycle"
"-pad"

503
elpa/dash-2.16.0/dash.info → elpa/dash-2.17.0/dash.info
View File

@ -91,8 +91,7 @@ File: dash.info, Node: Installation, Next: Functions, Prev: Top, Up: Top
1 Installation
**************
It’s available on marmalade (http://marmalade-repo.org/) and Melpa
(https://melpa.org/); use ‘M-x package-install’:
It’s available on Melpa (https://melpa.org/); use ‘M-x package-install’:
‘M-x package-install <RET> dash’
Install the dash library.
@ -393,7 +392,7 @@ Functions returning a sublist of the original list.
⇒ '(1 2 3 4 5 6 7 8 9)
-- Function: -remove-item (item list)
Remove all occurences of ITEM from LIST.
Remove all occurrences of ITEM from LIST.
Comparison is done with ‘equal’.
@ -619,7 +618,7 @@ Functions returning a modified copy of the input list.
⇒ nil
-- Function: -replace-first (old new list)
Replace the first occurence of OLD with NEW in LIST.
Replace the first occurrence of OLD with NEW in LIST.
Elements are compared using ‘equal’.
@ -633,7 +632,7 @@ Functions returning a modified copy of the input list.
⇒ nil
-- Function: -replace-last (old new list)
Replace the last occurence of OLD with NEW in LIST.
Replace the last occurrence of OLD with NEW in LIST.
Elements are compared using ‘equal’.
@ -1317,22 +1316,22 @@ Functions partitioning the input list into a list of lists.
Partition directly after each time PRED is true on an element of
LIST.
(-partition-after-pred (function oddp) '())
(-partition-after-pred #'odd? '())
⇒ '()
(-partition-after-pred (function oddp) '(1))
(-partition-after-pred #'odd? '(1))
⇒ '((1))
(-partition-after-pred (function oddp) '(0 1))
(-partition-after-pred #'odd? '(0 1))
⇒ '((0 1))
-- Function: -partition-before-pred (pred list)
Partition directly before each time PRED is true on an element of
LIST.
(-partition-before-pred (function oddp) '())
(-partition-before-pred #'odd? '())
⇒ '()
(-partition-before-pred (function oddp) '(1))
(-partition-before-pred #'odd? '(1))
⇒ '((1))
(-partition-before-pred (function oddp) '(0 1))
(-partition-before-pred #'odd? '(0 1))
⇒ '((0) (1))
-- Function: -partition-before-item (item list)
@ -1530,6 +1529,8 @@ Operations pretending lists are sets.
⇒ '()
(-distinct '(1 2 2 4))
⇒ '(1 2 4)
(-distinct '(t t t))
⇒ '(t)

File: dash.info, Node: Other list operations, Next: Tree operations, Prev: Set operations, Up: Functions
@ -1636,16 +1637,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
@ -1665,12 +1688,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
@ -2587,7 +2615,7 @@ offered in a separate package: ‘dash-functional‘.
(-map (-applify '+) '((1 1 1) (1 2 3) (5 5 5)))
⇒ '(3 6 15)
(-map (-applify (lambda (a b c) (\` ((\, a) ((\, b) ((\, c))))))) '((1 1 1) (1 2 3) (5 5 5)))
(-map (-applify (lambda (a b c) `(,a (,b (,c))))) '((1 1 1) (1 2 3) (5 5 5)))
⇒ '((1 (1 (1))) (1 (2 (3))) (5 (5 (5))))
(funcall (-applify '<) '(3 6))
⇒ t
@ -2707,12 +2735,12 @@ offered in a separate package: ‘dash-functional‘.
FN must be a unary function. The returned lambda takes a single
argument, X, the initial value for the fixpoint iteration. The
iteration halts when either of the following conditions is
satisified:
satisfied:
1. Iteration converges to the fixpoint, with equality being tested
using EQUAL-TEST. If EQUAL-TEST is not specified, ‘equal’ is used.
For functions over the floating point numbers, it may be necessary
to provide an appropriate appoximate comparsion test.
to provide an appropriate appoximate comparison test.
2. HALT-TEST returns a non-nil value. HALT-TEST defaults to a
simple counter that returns t after ‘-fixfn-max-iterations’, to
@ -2965,7 +2993,7 @@ Index
(line 55)
* -as->: Threading macros. (line 46)
* -butlast: Other list operations.
(line 313)
(line 340)
* -clone: Tree operations. (line 122)
* -common-prefix: Reductions. (line 223)
* -common-suffix: Reductions. (line 233)
@ -2982,7 +3010,7 @@ Index
* -cut: Function combinators.
(line 104)
* -cycle: Other list operations.
(line 141)
(line 168)
* -difference: Set operations. (line 20)
* -distinct: Set operations. (line 62)
* -dotimes: Side-effects. (line 61)
@ -2998,17 +3026,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 175)
* -flatten: List to list. (line 33)
@ -3016,7 +3044,7 @@ Index
* -flip: Function combinators.
(line 80)
* -fourth-item: Other list operations.
(line 283)
(line 310)
* -grade-down: Indexing. (line 81)
* -grade-up: Indexing. (line 71)
* -group-by: Partitioning. (line 187)
@ -3040,13 +3068,13 @@ Index
* -keep: List to list. (line 8)
* -lambda: Binding. (line 252)
* -last: Other list operations.
(line 234)
(line 261)
* -last-item: Other list operations.
(line 303)
(line 330)
* -let: Binding. (line 65)
* -let*: Binding. (line 232)
* -list: Other list operations.
(line 336)
(line 363)
* -map: Maps. (line 10)
* -map-first: Maps. (line 37)
* -map-indexed: Maps. (line 65)
@ -3067,7 +3095,7 @@ Index
* -orfn: Function combinators.
(line 126)
* -pad: Other list operations.
(line 152)
(line 179)
* -partial: Function combinators.
(line 9)
* -partition: Partitioning. (line 74)
@ -3113,7 +3141,7 @@ Index
* -running-sum: Reductions. (line 169)
* -same-items?: Predicates. (line 72)
* -second-item: Other list operations.
(line 259)
(line 286)
* -select-by-indices: Sublist selection. (line 168)
* -select-column: Sublist selection. (line 198)
* -select-columns: Sublist selection. (line 179)
@ -3123,12 +3151,12 @@ Index
* -snoc: Other list operations.
(line 44)
* -some: Other list operations.
(line 221)
(line 248)
* -some-->: Threading macros. (line 83)
* -some->: Threading macros. (line 59)
* -some->>: Threading macros. (line 71)
* -sort: Other list operations.
(line 323)
(line 350)
* -splice: Maps. (line 90)
* -splice-list: Maps. (line 110)
* -split-at: Partitioning. (line 8)
@ -3137,15 +3165,15 @@ Index
* -split-with: Partitioning. (line 17)
* -sum: Reductions. (line 159)
* -table: Other list operations.
(line 163)
(line 190)
* -table-flat: Other list operations.
(line 182)
(line 209)
* -tails: Reductions. (line 213)
* -take: Sublist selection. (line 101)
* -take-last: Sublist selection. (line 112)
* -take-while: Sublist selection. (line 146)
* -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 84)
@ -3156,14 +3184,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 132)
* -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)
@ -3172,204 +3202,205 @@ Index
Tag Table:
Node: Top946
Node: Installation2425
Node: Using in a package3001
Node: Syntax highlighting of dash functions3365
Node: Functions3748
Node: Maps4959
Ref: -map5254
Ref: -map-when5595
Ref: -map-first6173
Ref: -map-last6651
Ref: -map-indexed7124
Ref: -annotate7604
Ref: -splice8094
Ref: -splice-list8875
Ref: -mapcat9337
Ref: -copy9713
Node: Sublist selection9917
Ref: -filter10110
Ref: -remove10562
Ref: -remove-first10968
Ref: -remove-last11495
Ref: -remove-item12016
Ref: -non-nil12410
Ref: -slice12569
Ref: -take13101
Ref: -take-last13409
Ref: -drop13732
Ref: -drop-last14005
Ref: -take-while14265
Ref: -drop-while14615
Ref: -select-by-indices14971
Ref: -select-columns15485
Ref: -select-column16191
Node: List to list16655
Ref: -keep16847
Ref: -concat17350
Ref: -flatten17647
Ref: -flatten-n18406
Ref: -replace18793
Ref: -replace-first19256
Ref: -replace-last19752
Ref: -insert-at20241
Ref: -replace-at20568
Ref: -update-at20958
Ref: -remove-at21449
Ref: -remove-at-indices21937
Node: Reductions22519
Ref: -reduce-from22688
Ref: -reduce-r-from23454
Ref: -reduce24221
Ref: -reduce-r24950
Ref: -reductions-from25821
Ref: -reductions-r-from26536
Ref: -reductions27261
Ref: -reductions-r27886
Ref: -count28521
Ref: -sum28745
Ref: -running-sum28934
Ref: -product29227
Ref: -running-product29436
Ref: -inits29749
Ref: -tails29997
Ref: -common-prefix30244
Ref: -common-suffix30541
Ref: -min30838
Ref: -min-by31064
Ref: -max31587
Ref: -max-by31812
Node: Unfolding32340
Ref: -iterate32579
Ref: -unfold33024
Node: Predicates33832
Ref: -any?33956
Ref: -all?34276
Ref: -none?34606
Ref: -only-some?34908
Ref: -contains?35393
Ref: -same-items?35782
Ref: -is-prefix?36167
Ref: -is-suffix?36490
Ref: -is-infix?36813
Node: Partitioning37167
Ref: -split-at37355
Ref: -split-with37640
Ref: -split-on38043
Ref: -split-when38719
Ref: -separate39359
Ref: -partition39801
Ref: -partition-all40253
Ref: -partition-in-steps40681
Ref: -partition-all-in-steps41178
Ref: -partition-by41663
Ref: -partition-by-header42045
Ref: -partition-after-pred42649
Ref: -partition-before-pred43020
Ref: -partition-before-item43398
Ref: -partition-after-item43709
Ref: -group-by44015
Node: Indexing44452
Ref: -elem-index44654
Ref: -elem-indices45049
Ref: -find-index45432
Ref: -find-last-index45921
Ref: -find-indices46425
Ref: -grade-up46833
Ref: -grade-down47236
Node: Set operations47646
Ref: -union47829
Ref: -difference48271
Ref: -intersection48688
Ref: -powerset49125
Ref: -permutations49338
Ref: -distinct49638
Node: Other list operations49962
Ref: -rotate50187
Ref: -repeat50557
Ref: -cons*50820
Ref: -snoc51207
Ref: -interpose51620
Ref: -interleave51918
Ref: -zip-with52287
Ref: -zip53004
Ref: -zip-fill53810
Ref: -unzip54133
Ref: -cycle54667
Ref: -pad55040
Ref: -table55363
Ref: -table-flat56152
Ref: -first57160
Ref: -some57532
Ref: -last57841
Ref: -first-item58175
Ref: -second-item58591
Ref: -third-item58871
Ref: -fourth-item59149
Ref: -fifth-item59415
Ref: -last-item59677
Ref: -butlast59969
Ref: -sort60216
Ref: -list60705
Ref: -fix61036
Node: Tree operations61576
Ref: -tree-seq61772
Ref: -tree-map62630
Ref: -tree-map-nodes63073
Ref: -tree-reduce63923
Ref: -tree-reduce-from64805
Ref: -tree-mapreduce65406
Ref: -tree-mapreduce-from66266
Ref: -clone67552
Node: Threading macros67880
Ref: ->68025
Ref: ->>68516
Ref: -->69021
Ref: -as->69577
Ref: -some->70032
Ref: -some->>70406
Ref: -some-->70842
Node: Binding71313
Ref: -when-let71525
Ref: -when-let*72010
Ref: -if-let72533
Ref: -if-let*72928
Ref: -let73545
Ref: -let*79635
Ref: -lambda80575
Ref: -setq81372
Node: Side-effects82188
Ref: -each82382
Ref: -each-while82789
Ref: -each-indexed83149
Ref: -each-r83667
Ref: -each-r-while84100
Ref: -dotimes84475
Ref: -doto84778
Ref: --doto85206
Node: Destructive operations85481
Ref: !cons85654
Ref: !cdr85860
Node: Function combinators86055
Ref: -partial86329
Ref: -rpartial86725
Ref: -juxt87128
Ref: -compose87560
Ref: -applify88113
Ref: -on88560
Ref: -flip89086
Ref: -const89398
Ref: -cut89737
Ref: -not90223
Ref: -orfn90533
Ref: -andfn90967
Ref: -iteratefn91462
Ref: -fixfn92165
Ref: -prodfn93728
Node: Development94796
Node: Contribute95145
Node: Changes95893
Node: Contributors98891
Node: Index100510
Node: Using in a package2958
Node: Syntax highlighting of dash functions3322
Node: Functions3705
Node: Maps4916
Ref: -map5211
Ref: -map-when5552
Ref: -map-first6130
Ref: -map-last6608
Ref: -map-indexed7081
Ref: -annotate7561
Ref: -splice8051
Ref: -splice-list8832
Ref: -mapcat9294
Ref: -copy9670
Node: Sublist selection9874
Ref: -filter10067
Ref: -remove10519
Ref: -remove-first10925
Ref: -remove-last11452
Ref: -remove-item11973
Ref: -non-nil12368
Ref: -slice12527
Ref: -take13059
Ref: -take-last13367
Ref: -drop13690
Ref: -drop-last13963
Ref: -take-while14223
Ref: -drop-while14573
Ref: -select-by-indices14929
Ref: -select-columns15443
Ref: -select-column16149
Node: List to list16613
Ref: -keep16805
Ref: -concat17308
Ref: -flatten17605
Ref: -flatten-n18364
Ref: -replace18751
Ref: -replace-first19214
Ref: -replace-last19711
Ref: -insert-at20201
Ref: -replace-at20528
Ref: -update-at20918
Ref: -remove-at21409
Ref: -remove-at-indices21897
Node: Reductions22479
Ref: -reduce-from22648
Ref: -reduce-r-from23414
Ref: -reduce24181
Ref: -reduce-r24910
Ref: -reductions-from25781
Ref: -reductions-r-from26496
Ref: -reductions27221
Ref: -reductions-r27846
Ref: -count28481
Ref: -sum28705
Ref: -running-sum28894
Ref: -product29187
Ref: -running-product29396
Ref: -inits29709
Ref: -tails29957
Ref: -common-prefix30204
Ref: -common-suffix30501
Ref: -min30798
Ref: -min-by31024
Ref: -max31547
Ref: -max-by31772
Node: Unfolding32300
Ref: -iterate32539
Ref: -unfold32984
Node: Predicates33792
Ref: -any?33916
Ref: -all?34236
Ref: -none?34566
Ref: -only-some?34868
Ref: -contains?35353
Ref: -same-items?35742
Ref: -is-prefix?36127
Ref: -is-suffix?36450
Ref: -is-infix?36773
Node: Partitioning37127
Ref: -split-at37315
Ref: -split-with37600
Ref: -split-on38003
Ref: -split-when38679
Ref: -separate39319
Ref: -partition39761
Ref: -partition-all40213
Ref: -partition-in-steps40641
Ref: -partition-all-in-steps41138
Ref: -partition-by41623
Ref: -partition-by-header42005
Ref: -partition-after-pred42609
Ref: -partition-before-pred42953
Ref: -partition-before-item43304
Ref: -partition-after-item43615
Ref: -group-by43921
Node: Indexing44358
Ref: -elem-index44560
Ref: -elem-indices44955
Ref: -find-index45338
Ref: -find-last-index45827
Ref: -find-indices46331
Ref: -grade-up46739
Ref: -grade-down47142
Node: Set operations47552
Ref: -union47735
Ref: -difference48177
Ref: -intersection48594
Ref: -powerset49031
Ref: -permutations49244
Ref: -distinct49544
Node: Other list operations49922
Ref: -rotate50147
Ref: -repeat50517
Ref: -cons*50780
Ref: -snoc51167
Ref: -interpose51580
Ref: -interleave51878
Ref: -zip-with52247
Ref: -zip52964
Ref: -zip-lists53796
Ref: -zip-fill54497
Ref: -unzip54820
Ref: -cycle55565
Ref: -pad55938
Ref: -table56261
Ref: -table-flat57050
Ref: -first58058
Ref: -some58430
Ref: -last58739
Ref: -first-item59073
Ref: -second-item59489
Ref: -third-item59769
Ref: -fourth-item60047
Ref: -fifth-item60313
Ref: -last-item60575
Ref: -butlast60867
Ref: -sort61114
Ref: -list61603
Ref: -fix61934
Node: Tree operations62474
Ref: -tree-seq62670
Ref: -tree-map63528
Ref: -tree-map-nodes63971
Ref: -tree-reduce64821
Ref: -tree-reduce-from65703
Ref: -tree-mapreduce66304
Ref: -tree-mapreduce-from67164
Ref: -clone68450
Node: Threading macros68778
Ref: ->68923
Ref: ->>69414
Ref: -->69919
Ref: -as->70475
Ref: -some->70930
Ref: -some->>71304
Ref: -some-->71740
Node: Binding72211
Ref: -when-let72423
Ref: -when-let*72908
Ref: -if-let73431
Ref: -if-let*73826
Ref: -let74443
Ref: -let*80533
Ref: -lambda81473
Ref: -setq82270
Node: Side-effects83086
Ref: -each83280
Ref: -each-while83687
Ref: -each-indexed84047
Ref: -each-r84565
Ref: -each-r-while84998
Ref: -dotimes85373
Ref: -doto85676
Ref: --doto86104
Node: Destructive operations86379
Ref: !cons86552
Ref: !cdr86758
Node: Function combinators86953
Ref: -partial87227
Ref: -rpartial87623
Ref: -juxt88026
Ref: -compose88458
Ref: -applify89011
Ref: -on89442
Ref: -flip89968
Ref: -const90280
Ref: -cut90619
Ref: -not91105
Ref: -orfn91415
Ref: -andfn91849
Ref: -iteratefn92344
Ref: -fixfn93047
Ref: -prodfn94609
Node: Development95677
Node: Contribute96026
Node: Changes96774
Node: Contributors99772
Node: Index101391

End Tag Table

0
elpa/dash-2.16.0/dir → elpa/dash-2.17.0/dir
View File