diff --git a/elpa/dash-2.16.0/dash-autoloads.el b/elpa/dash-2.17.0/dash-autoloads.el similarity index 100% rename from elpa/dash-2.16.0/dash-autoloads.el rename to elpa/dash-2.17.0/dash-autoloads.el diff --git a/elpa/dash-2.16.0/dash-pkg.el b/elpa/dash-2.17.0/dash-pkg.el similarity index 75% rename from elpa/dash-2.16.0/dash-pkg.el rename to elpa/dash-2.17.0/dash-pkg.el index 9cbd898..109c36e 100644 --- a/elpa/dash-2.16.0/dash-pkg.el +++ b/elpa/dash-2.17.0/dash-pkg.el @@ -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")) diff --git a/elpa/dash-2.16.0/dash.el b/elpa/dash-2.17.0/dash.el similarity index 97% rename from elpa/dash-2.16.0/dash.el rename to elpa/dash-2.17.0/dash.el index 587c074..bc713ce 100644 --- a/elpa/dash-2.16.0/dash.el +++ b/elpa/dash-2.17.0/dash.el @@ -3,7 +3,7 @@ ;; Copyright (C) 2012-2016 Free Software Foundation, Inc. ;; Author: Magnar Sveen -;; 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" diff --git a/elpa/dash-2.16.0/dash.info b/elpa/dash-2.17.0/dash.info similarity index 94% rename from elpa/dash-2.16.0/dash.info rename to elpa/dash-2.17.0/dash.info index 86c1b14..ee791c4 100644 --- a/elpa/dash-2.16.0/dash.info +++ b/elpa/dash-2.17.0/dash.info @@ -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 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 diff --git a/elpa/dash-2.16.0/dir b/elpa/dash-2.17.0/dir similarity index 100% rename from elpa/dash-2.16.0/dir rename to elpa/dash-2.17.0/dir