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") '("lists")
:authors :authors
'(("Magnar Sveen" . "magnars@gmail.com")) '(("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. ;; Copyright (C) 2012-2016 Free Software Foundation, Inc.
;; Author: Magnar Sveen <magnars@gmail.com> ;; Author: Magnar Sveen <magnars@gmail.com>
;; Version: 2.16.0 ;; Version: 2.17.0
;; Keywords: lists ;; Keywords: lists
;; This program is free software; you can redistribute it and/or modify ;; This program is free software; you can redistribute it and/or modify
@ -33,6 +33,12 @@
;;; Code: ;;; 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 () (defgroup dash ()
"Customize group for dash.el" "Customize group for dash.el"
:group 'lisp :group 'lisp
@ -397,7 +403,7 @@ See also: `-remove', `-map-last'"
(defalias '--reject-last '--remove-last) (defalias '--reject-last '--remove-last)
(defun -remove-item (item list) (defun -remove-item (item list)
"Remove all occurences of ITEM from LIST. "Remove all occurrences of ITEM from LIST.
Comparison is done with `equal'." Comparison is done with `equal'."
(declare (pure t) (side-effect-free t)) (declare (pure t) (side-effect-free t))
@ -497,7 +503,7 @@ See also: `-replace-at'"
(--map-when (equal it old) new list)) (--map-when (equal it old) new list))
(defun -replace-first (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'. Elements are compared using `equal'.
@ -506,7 +512,7 @@ See also: `-map-first'"
(--map-first (equal old it) new list)) (--map-first (equal old it) new list))
(defun -replace-last (old 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'. Elements are compared using `equal'.
@ -682,7 +688,10 @@ See also: `-third-item'.
\(fn LIST)") \(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. "Return the third item of LIST, or nil if LIST is too short.
See also: `-fourth-item'. See also: `-fourth-item'.
@ -703,28 +712,18 @@ See also: `-last-item'."
(declare (pure t) (side-effect-free t)) (declare (pure t) (side-effect-free t))
(car (cdr (cdr (cdr (cdr list)))))) (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) (defun -last-item (list)
"Return the last item of LIST, or nil on an empty list." "Return the last item of LIST, or nil on an empty list."
(declare (pure t) (side-effect-free t)) (declare (pure t) (side-effect-free t))
(car (last list))) (car (last list)))
;; TODO: gv was introduced in 24.3, so we can remove the if statement ;; Use `with-no-warnings' to suppress unbound `-last-item' or
;; when support for earlier versions is dropped ;; undefined `gv--defsetter' warnings arising from both
(eval-when-compile ;; `gv-define-setter' and `defsetf' in certain Emacs versions.
(with-no-warnings
(if (fboundp 'gv-define-setter) (if (fboundp 'gv-define-setter)
(gv-define-setter -last-item (val x) `(setcar (last ,x) ,val)) (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) (defun -butlast (list)
"Return a list of all items in list except for the last." "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'." and the elements from LIST2 as symbol `other'."
(--zip-with (funcall fn it other) list1 list2)) (--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) (defun -zip (&rest lists)
"Zip LISTS together. Group the head of each list, followed by the "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 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 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. of cons cells. Otherwise, return the groupings as a list of lists.
Please note! This distinction is being removed in an upcoming 3.0 Use `-zip-lists' if you need the return value to always be a list
release of Dash. If you rely on this behavior, use -zip-pair instead." of lists.
Alias: `-zip-pair'
See also: `-zip-lists'"
(declare (pure t) (side-effect-free t)) (declare (pure t) (side-effect-free t))
(when lists (when lists
(let (results) (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 lists (mapcar 'cdr lists)))
(setq results (nreverse results)) (setq results (nreverse results))
(if (= (length lists) 2) (if (= (length lists) 2)
;; to support backward compatability, return ;; to support backward compatibility, return
;; a cons cell if two lists were provided ;; a cons cell if two lists were provided
(--map (cons (car it) (cadr it)) results) (--map (cons (car it) (cadr it)) results)
results)))) results))))
@ -1306,6 +1327,9 @@ a variable number of arguments, such that
is identity (given that the lists are the same length). 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'" See also: `-zip'"
(apply '-zip lists)) (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) (defmacro -some-> (x &optional form &rest more)
"When expr is non-nil, thread it through the first form (via `->'), "When expr is non-nil, thread it through the first form (via `->'),
and when that result is non-nil, through the next form, etc." and when that result is non-nil, through the next form, etc."
(declare (debug ->)) (declare (debug ->)
(indent 1))
(if (null form) x (if (null form) x
(let ((result (make-symbol "result"))) (let ((result (make-symbol "result")))
`(-some-> (-when-let (,result ,x) `(-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) (defmacro -some->> (x &optional form &rest more)
"When expr is non-nil, thread it through the first form (via `->>'), "When expr is non-nil, thread it through the first form (via `->>'),
and when that result is non-nil, through the next form, etc." and when that result is non-nil, through the next form, etc."
(declare (debug ->)) (declare (debug ->)
(indent 1))
(if (null form) x (if (null form) x
(let ((result (make-symbol "result"))) (let ((result (make-symbol "result")))
`(-some->> (-when-let (,result ,x) `(-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) (defmacro -some--> (x &optional form &rest more)
"When expr in non-nil, thread it through the first form (via `-->'), "When expr in non-nil, thread it through the first form (via `-->'),
and when that result is non-nil, through the next form, etc." and when that result is non-nil, through the next form, etc."
(declare (debug ->)) (declare (debug ->)
(indent 1))
(if (null form) x (if (null form) x
(let ((result (make-symbol "result"))) (let ((result (make-symbol "result")))
`(-some--> (-when-let (,result ,x) `(-some--> (-when-let (,result ,x)
@ -1654,7 +1681,7 @@ All returned symbols are guaranteed to be unique."
(defun dash--get-expand-function (type) (defun dash--get-expand-function (type)
"Get expand function name for 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) (defun dash--match-cons-1 (match-form source &optional props)
"Match MATCH-FORM against SOURCE. "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. or with `-compare-fn' if that's non-nil.
Alias: `-uniq'" Alias: `-uniq'"
(let (result) ;; Implementation note: The speedup gained from hash table lookup
(--each list (unless (-contains? result it) (!cons it result))) ;; starts to outweigh its overhead for lists of length greater than
(nreverse result))) ;; 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) (defalias '-uniq '-distinct)
@ -2329,7 +2369,11 @@ or with `-compare-fn' if that's non-nil."
(defun -inits (list) (defun -inits (list)
"Return all prefixes of 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) (defun -tails (list)
"Return all suffixes of LIST" "Return all suffixes of LIST"
@ -2899,6 +2943,7 @@ structure such as plist or alist."
"--zip-with" "--zip-with"
"-zip" "-zip"
"-zip-fill" "-zip-fill"
"-zip-lists"
"-zip-pair" "-zip-pair"
"-cycle" "-cycle"
"-pad" "-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 1 Installation
************** **************
It’s available on marmalade (http://marmalade-repo.org/) and Melpa It’s available on Melpa (https://melpa.org/); use ‘M-x package-install’:
(https://melpa.org/); use ‘M-x package-install’:
‘M-x package-install <RET> dash’ ‘M-x package-install <RET> dash’
Install the dash library. 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) ⇒ '(1 2 3 4 5 6 7 8 9)
-- Function: -remove-item (item list) -- Function: -remove-item (item list)
Remove all occurences of ITEM from LIST. Remove all occurrences of ITEM from LIST.
Comparison is done with ‘equal’. Comparison is done with ‘equal’.
@ -619,7 +618,7 @@ Functions returning a modified copy of the input list.
⇒ nil ⇒ nil
-- Function: -replace-first (old new list) -- 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’. Elements are compared using ‘equal’.
@ -633,7 +632,7 @@ Functions returning a modified copy of the input list.
⇒ nil ⇒ nil
-- Function: -replace-last (old new list) -- 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’. 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 Partition directly after each time PRED is true on an element of
LIST. LIST.
(-partition-after-pred (function oddp) '()) (-partition-after-pred #'odd? '())
⇒ '() ⇒ '()
(-partition-after-pred (function oddp) '(1)) (-partition-after-pred #'odd? '(1))
⇒ '((1)) ⇒ '((1))
(-partition-after-pred (function oddp) '(0 1)) (-partition-after-pred #'odd? '(0 1))
⇒ '((0 1)) ⇒ '((0 1))
-- Function: -partition-before-pred (pred list) -- Function: -partition-before-pred (pred list)
Partition directly before each time PRED is true on an element of Partition directly before each time PRED is true on an element of
LIST. LIST.
(-partition-before-pred (function oddp) '()) (-partition-before-pred #'odd? '())
⇒ '() ⇒ '()
(-partition-before-pred (function oddp) '(1)) (-partition-before-pred #'odd? '(1))
⇒ '((1)) ⇒ '((1))
(-partition-before-pred (function oddp) '(0 1)) (-partition-before-pred #'odd? '(0 1))
⇒ '((0) (1)) ⇒ '((0) (1))
-- Function: -partition-before-item (item list) -- Function: -partition-before-item (item list)
@ -1530,6 +1529,8 @@ Operations pretending lists are sets.
⇒ '() ⇒ '()
(-distinct '(1 2 2 4)) (-distinct '(1 2 2 4))
⇒ '(1 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 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 list of cons cells. Otherwise, return the groupings as a list of
lists. lists.
Please note! This distinction is being removed in an upcoming 3.0 Use ‘-zip-lists’ (*note -zip-lists::) if you need the return value
release of Dash. If you rely on this behavior, use -zip-pair to always be a list of lists.
instead.
Alias: ‘-zip-pair’
See also: ‘-zip-lists’ (*note -zip-lists::)
(-zip '(1 2 3) '(4 5 6)) (-zip '(1 2 3) '(4 5 6))
⇒ '((1 . 4) (2 . 5) (3 . 6)) ⇒ '((1 . 4) (2 . 5) (3 . 6))
(-zip '(1 2 3) '(4 5 6 7)) (-zip '(1 2 3) '(4 5 6 7))
⇒ '((1 . 4) (2 . 5) (3 . 6)) ⇒ '((1 . 4) (2 . 5) (3 . 6))
(-zip '(1 2 3 4) '(4 5 6)) (-zip '(1 2) '(3 4 5) '(6))
⇒ '((1 . 4) (2 . 5) (3 . 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) -- Function: -zip-fill (fill-value &rest lists)
Zip LISTS, with FILL-VALUE padded onto the shorter lists. The 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). 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::) See also: ‘-zip’ (*note -zip::)
(-unzip (-zip '(1 2 3) '(a b c) '("e" "f" "g"))) (-unzip (-zip '(1 2 3) '(a b c) '("e" "f" "g")))
⇒ '((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))) (-unzip '((1 2) (3 4) (5 6) (7 8) (9 10)))
⇒ '((1 3 5 7 9) (2 4 6 8 10)) ⇒ '((1 3 5 7 9) (2 4 6 8 10))
(-unzip '((1 2) (3 4)))
⇒ '((1 . 3) (2 . 4))
-- Function: -cycle (list) -- Function: -cycle (list)
Return an infinite copy of LIST that will cycle through the 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))) (-map (-applify '+) '((1 1 1) (1 2 3) (5 5 5)))
⇒ '(3 6 15) ⇒ '(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)))) ⇒ '((1 (1 (1))) (1 (2 (3))) (5 (5 (5))))
(funcall (-applify '<) '(3 6)) (funcall (-applify '<) '(3 6))
⇒ t ⇒ t
@ -2707,12 +2735,12 @@ offered in a separate package: ‘dash-functional‘.
FN must be a unary function. The returned lambda takes a single FN must be a unary function. The returned lambda takes a single
argument, X, the initial value for the fixpoint iteration. The argument, X, the initial value for the fixpoint iteration. The
iteration halts when either of the following conditions is iteration halts when either of the following conditions is
satisified: satisfied:
1. Iteration converges to the fixpoint, with equality being tested 1. Iteration converges to the fixpoint, with equality being tested
using EQUAL-TEST. If EQUAL-TEST is not specified, ‘equal’ is used. using EQUAL-TEST. If EQUAL-TEST is not specified, ‘equal’ is used.
For functions over the floating point numbers, it may be necessary 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 2. HALT-TEST returns a non-nil value. HALT-TEST defaults to a
simple counter that returns t after ‘-fixfn-max-iterations’, to simple counter that returns t after ‘-fixfn-max-iterations’, to
@ -2965,7 +2993,7 @@ Index
(line 55) (line 55)
* -as->: Threading macros. (line 46) * -as->: Threading macros. (line 46)
* -butlast: Other list operations. * -butlast: Other list operations.
(line 313) (line 340)
* -clone: Tree operations. (line 122) * -clone: Tree operations. (line 122)
* -common-prefix: Reductions. (line 223) * -common-prefix: Reductions. (line 223)
* -common-suffix: Reductions. (line 233) * -common-suffix: Reductions. (line 233)
@ -2982,7 +3010,7 @@ Index
* -cut: Function combinators. * -cut: Function combinators.
(line 104) (line 104)
* -cycle: Other list operations. * -cycle: Other list operations.
(line 141) (line 168)
* -difference: Set operations. (line 20) * -difference: Set operations. (line 20)
* -distinct: Set operations. (line 62) * -distinct: Set operations. (line 62)
* -dotimes: Side-effects. (line 61) * -dotimes: Side-effects. (line 61)
@ -2998,17 +3026,17 @@ Index
* -elem-index: Indexing. (line 9) * -elem-index: Indexing. (line 9)
* -elem-indices: Indexing. (line 21) * -elem-indices: Indexing. (line 21)
* -fifth-item: Other list operations. * -fifth-item: Other list operations.
(line 293) (line 320)
* -filter: Sublist selection. (line 8) * -filter: Sublist selection. (line 8)
* -find-index: Indexing. (line 32) * -find-index: Indexing. (line 32)
* -find-indices: Indexing. (line 60) * -find-indices: Indexing. (line 60)
* -find-last-index: Indexing. (line 46) * -find-last-index: Indexing. (line 46)
* -first: Other list operations. * -first: Other list operations.
(line 207) (line 234)
* -first-item: Other list operations. * -first-item: Other list operations.
(line 244) (line 271)
* -fix: Other list operations. * -fix: Other list operations.
(line 349) (line 376)
* -fixfn: Function combinators. * -fixfn: Function combinators.
(line 175) (line 175)
* -flatten: List to list. (line 33) * -flatten: List to list. (line 33)
@ -3016,7 +3044,7 @@ Index
* -flip: Function combinators. * -flip: Function combinators.
(line 80) (line 80)
* -fourth-item: Other list operations. * -fourth-item: Other list operations.
(line 283) (line 310)
* -grade-down: Indexing. (line 81) * -grade-down: Indexing. (line 81)
* -grade-up: Indexing. (line 71) * -grade-up: Indexing. (line 71)
* -group-by: Partitioning. (line 187) * -group-by: Partitioning. (line 187)
@ -3040,13 +3068,13 @@ Index
* -keep: List to list. (line 8) * -keep: List to list. (line 8)
* -lambda: Binding. (line 252) * -lambda: Binding. (line 252)
* -last: Other list operations. * -last: Other list operations.
(line 234) (line 261)
* -last-item: Other list operations. * -last-item: Other list operations.
(line 303) (line 330)
* -let: Binding. (line 65) * -let: Binding. (line 65)
* -let*: Binding. (line 232) * -let*: Binding. (line 232)
* -list: Other list operations. * -list: Other list operations.
(line 336) (line 363)
* -map: Maps. (line 10) * -map: Maps. (line 10)
* -map-first: Maps. (line 37) * -map-first: Maps. (line 37)
* -map-indexed: Maps. (line 65) * -map-indexed: Maps. (line 65)
@ -3067,7 +3095,7 @@ Index
* -orfn: Function combinators. * -orfn: Function combinators.
(line 126) (line 126)
* -pad: Other list operations. * -pad: Other list operations.
(line 152) (line 179)
* -partial: Function combinators. * -partial: Function combinators.
(line 9) (line 9)
* -partition: Partitioning. (line 74) * -partition: Partitioning. (line 74)
@ -3113,7 +3141,7 @@ Index
* -running-sum: Reductions. (line 169) * -running-sum: Reductions. (line 169)
* -same-items?: Predicates. (line 72) * -same-items?: Predicates. (line 72)
* -second-item: Other list operations. * -second-item: Other list operations.
(line 259) (line 286)
* -select-by-indices: Sublist selection. (line 168) * -select-by-indices: Sublist selection. (line 168)
* -select-column: Sublist selection. (line 198) * -select-column: Sublist selection. (line 198)
* -select-columns: Sublist selection. (line 179) * -select-columns: Sublist selection. (line 179)
@ -3123,12 +3151,12 @@ Index
* -snoc: Other list operations. * -snoc: Other list operations.
(line 44) (line 44)
* -some: Other list operations. * -some: Other list operations.
(line 221) (line 248)
* -some-->: Threading macros. (line 83) * -some-->: Threading macros. (line 83)
* -some->: Threading macros. (line 59) * -some->: Threading macros. (line 59)
* -some->>: Threading macros. (line 71) * -some->>: Threading macros. (line 71)
* -sort: Other list operations. * -sort: Other list operations.
(line 323) (line 350)
* -splice: Maps. (line 90) * -splice: Maps. (line 90)
* -splice-list: Maps. (line 110) * -splice-list: Maps. (line 110)
* -split-at: Partitioning. (line 8) * -split-at: Partitioning. (line 8)
@ -3137,15 +3165,15 @@ Index
* -split-with: Partitioning. (line 17) * -split-with: Partitioning. (line 17)
* -sum: Reductions. (line 159) * -sum: Reductions. (line 159)
* -table: Other list operations. * -table: Other list operations.
(line 163) (line 190)
* -table-flat: Other list operations. * -table-flat: Other list operations.
(line 182) (line 209)
* -tails: Reductions. (line 213) * -tails: Reductions. (line 213)
* -take: Sublist selection. (line 101) * -take: Sublist selection. (line 101)
* -take-last: Sublist selection. (line 112) * -take-last: Sublist selection. (line 112)
* -take-while: Sublist selection. (line 146) * -take-while: Sublist selection. (line 146)
* -third-item: Other list operations. * -third-item: Other list operations.
(line 271) (line 298)
* -tree-map: Tree operations. (line 28) * -tree-map: Tree operations. (line 28)
* -tree-map-nodes: Tree operations. (line 39) * -tree-map-nodes: Tree operations. (line 39)
* -tree-mapreduce: Tree operations. (line 84) * -tree-mapreduce: Tree operations. (line 84)
@ -3156,14 +3184,16 @@ Index
* -unfold: Unfolding. (line 25) * -unfold: Unfolding. (line 25)
* -union: Set operations. (line 8) * -union: Set operations. (line 8)
* -unzip: Other list operations. * -unzip: Other list operations.
(line 124) (line 146)
* -update-at: List to list. (line 132) * -update-at: List to list. (line 132)
* -when-let: Binding. (line 9) * -when-let: Binding. (line 9)
* -when-let*: Binding. (line 23) * -when-let*: Binding. (line 23)
* -zip: Other list operations. * -zip: Other list operations.
(line 95) (line 95)
* -zip-fill: Other list operations. * -zip-fill: Other list operations.
(line 116) (line 138)
* -zip-lists: Other list operations.
(line 119)
* -zip-with: Other list operations. * -zip-with: Other list operations.
(line 79) (line 79)
@ -3172,204 +3202,205 @@ Index
Tag Table: Tag Table:
Node: Top946 Node: Top946
Node: Installation2425 Node: Installation2425
Node: Using in a package3001 Node: Using in a package2958
Node: Syntax highlighting of dash functions3365 Node: Syntax highlighting of dash functions3322
Node: Functions3748 Node: Functions3705
Node: Maps4959 Node: Maps4916
Ref: -map5254 Ref: -map5211
Ref: -map-when5595 Ref: -map-when5552
Ref: -map-first6173 Ref: -map-first6130
Ref: -map-last6651 Ref: -map-last6608
Ref: -map-indexed7124 Ref: -map-indexed7081
Ref: -annotate7604 Ref: -annotate7561
Ref: -splice8094 Ref: -splice8051
Ref: -splice-list8875 Ref: -splice-list8832
Ref: -mapcat9337 Ref: -mapcat9294
Ref: -copy9713 Ref: -copy9670
Node: Sublist selection9917 Node: Sublist selection9874
Ref: -filter10110 Ref: -filter10067
Ref: -remove10562 Ref: -remove10519
Ref: -remove-first10968 Ref: -remove-first10925
Ref: -remove-last11495 Ref: -remove-last11452
Ref: -remove-item12016 Ref: -remove-item11973
Ref: -non-nil12410 Ref: -non-nil12368
Ref: -slice12569 Ref: -slice12527
Ref: -take13101 Ref: -take13059
Ref: -take-last13409 Ref: -take-last13367
Ref: -drop13732 Ref: -drop13690
Ref: -drop-last14005 Ref: -drop-last13963
Ref: -take-while14265 Ref: -take-while14223
Ref: -drop-while14615 Ref: -drop-while14573
Ref: -select-by-indices14971 Ref: -select-by-indices14929
Ref: -select-columns15485 Ref: -select-columns15443
Ref: -select-column16191 Ref: -select-column16149
Node: List to list16655 Node: List to list16613
Ref: -keep16847 Ref: -keep16805
Ref: -concat17350 Ref: -concat17308
Ref: -flatten17647 Ref: -flatten17605
Ref: -flatten-n18406 Ref: -flatten-n18364
Ref: -replace18793 Ref: -replace18751
Ref: -replace-first19256 Ref: -replace-first19214
Ref: -replace-last19752 Ref: -replace-last19711
Ref: -insert-at20241 Ref: -insert-at20201
Ref: -replace-at20568 Ref: -replace-at20528
Ref: -update-at20958 Ref: -update-at20918
Ref: -remove-at21449 Ref: -remove-at21409
Ref: -remove-at-indices21937 Ref: -remove-at-indices21897
Node: Reductions22519 Node: Reductions22479
Ref: -reduce-from22688 Ref: -reduce-from22648
Ref: -reduce-r-from23454 Ref: -reduce-r-from23414
Ref: -reduce24221 Ref: -reduce24181
Ref: -reduce-r24950 Ref: -reduce-r24910
Ref: -reductions-from25821 Ref: -reductions-from25781
Ref: -reductions-r-from26536 Ref: -reductions-r-from26496
Ref: -reductions27261 Ref: -reductions27221
Ref: -reductions-r27886 Ref: -reductions-r27846
Ref: -count28521 Ref: -count28481
Ref: -sum28745 Ref: -sum28705
Ref: -running-sum28934 Ref: -running-sum28894
Ref: -product29227 Ref: -product29187
Ref: -running-product29436 Ref: -running-product29396
Ref: -inits29749 Ref: -inits29709
Ref: -tails29997 Ref: -tails29957
Ref: -common-prefix30244 Ref: -common-prefix30204
Ref: -common-suffix30541 Ref: -common-suffix30501
Ref: -min30838 Ref: -min30798
Ref: -min-by31064 Ref: -min-by31024
Ref: -max31587 Ref: -max31547
Ref: -max-by31812 Ref: -max-by31772
Node: Unfolding32340 Node: Unfolding32300
Ref: -iterate32579 Ref: -iterate32539
Ref: -unfold33024 Ref: -unfold32984
Node: Predicates33832 Node: Predicates33792
Ref: -any?33956 Ref: -any?33916
Ref: -all?34276 Ref: -all?34236
Ref: -none?34606 Ref: -none?34566
Ref: -only-some?34908 Ref: -only-some?34868
Ref: -contains?35393 Ref: -contains?35353
Ref: -same-items?35782 Ref: -same-items?35742
Ref: -is-prefix?36167 Ref: -is-prefix?36127
Ref: -is-suffix?36490 Ref: -is-suffix?36450
Ref: -is-infix?36813 Ref: -is-infix?36773
Node: Partitioning37167 Node: Partitioning37127
Ref: -split-at37355 Ref: -split-at37315
Ref: -split-with37640 Ref: -split-with37600
Ref: -split-on38043 Ref: -split-on38003
Ref: -split-when38719 Ref: -split-when38679
Ref: -separate39359 Ref: -separate39319
Ref: -partition39801 Ref: -partition39761
Ref: -partition-all40253 Ref: -partition-all40213
Ref: -partition-in-steps40681 Ref: -partition-in-steps40641
Ref: -partition-all-in-steps41178 Ref: -partition-all-in-steps41138
Ref: -partition-by41663 Ref: -partition-by41623
Ref: -partition-by-header42045 Ref: -partition-by-header42005
Ref: -partition-after-pred42649 Ref: -partition-after-pred42609
Ref: -partition-before-pred43020 Ref: -partition-before-pred42953
Ref: -partition-before-item43398 Ref: -partition-before-item43304
Ref: -partition-after-item43709 Ref: -partition-after-item43615
Ref: -group-by44015 Ref: -group-by43921
Node: Indexing44452 Node: Indexing44358
Ref: -elem-index44654 Ref: -elem-index44560
Ref: -elem-indices45049 Ref: -elem-indices44955
Ref: -find-index45432 Ref: -find-index45338
Ref: -find-last-index45921 Ref: -find-last-index45827
Ref: -find-indices46425 Ref: -find-indices46331
Ref: -grade-up46833 Ref: -grade-up46739
Ref: -grade-down47236 Ref: -grade-down47142
Node: Set operations47646 Node: Set operations47552
Ref: -union47829 Ref: -union47735
Ref: -difference48271 Ref: -difference48177
Ref: -intersection48688 Ref: -intersection48594
Ref: -powerset49125 Ref: -powerset49031
Ref: -permutations49338 Ref: -permutations49244
Ref: -distinct49638 Ref: -distinct49544
Node: Other list operations49962 Node: Other list operations49922
Ref: -rotate50187 Ref: -rotate50147
Ref: -repeat50557 Ref: -repeat50517
Ref: -cons*50820 Ref: -cons*50780
Ref: -snoc51207 Ref: -snoc51167
Ref: -interpose51620 Ref: -interpose51580
Ref: -interleave51918 Ref: -interleave51878
Ref: -zip-with52287 Ref: -zip-with52247
Ref: -zip53004 Ref: -zip52964
Ref: -zip-fill53810 Ref: -zip-lists53796
Ref: -unzip54133 Ref: -zip-fill54497
Ref: -cycle54667 Ref: -unzip54820
Ref: -pad55040 Ref: -cycle55565
Ref: -table55363 Ref: -pad55938
Ref: -table-flat56152 Ref: -table56261
Ref: -first57160 Ref: -table-flat57050
Ref: -some57532 Ref: -first58058
Ref: -last57841 Ref: -some58430
Ref: -first-item58175 Ref: -last58739
Ref: -second-item58591 Ref: -first-item59073
Ref: -third-item58871 Ref: -second-item59489
Ref: -fourth-item59149 Ref: -third-item59769
Ref: -fifth-item59415 Ref: -fourth-item60047
Ref: -last-item59677 Ref: -fifth-item60313
Ref: -butlast59969 Ref: -last-item60575
Ref: -sort60216 Ref: -butlast60867
Ref: -list60705 Ref: -sort61114
Ref: -fix61036 Ref: -list61603
Node: Tree operations61576 Ref: -fix61934
Ref: -tree-seq61772 Node: Tree operations62474
Ref: -tree-map62630 Ref: -tree-seq62670
Ref: -tree-map-nodes63073 Ref: -tree-map63528
Ref: -tree-reduce63923 Ref: -tree-map-nodes63971
Ref: -tree-reduce-from64805 Ref: -tree-reduce64821
Ref: -tree-mapreduce65406 Ref: -tree-reduce-from65703
Ref: -tree-mapreduce-from66266 Ref: -tree-mapreduce66304
Ref: -clone67552 Ref: -tree-mapreduce-from67164
Node: Threading macros67880 Ref: -clone68450
Ref: ->68025 Node: Threading macros68778
Ref: ->>68516 Ref: ->68923
Ref: -->69021 Ref: ->>69414
Ref: -as->69577 Ref: -->69919
Ref: -some->70032 Ref: -as->70475
Ref: -some->>70406 Ref: -some->70930
Ref: -some-->70842 Ref: -some->>71304
Node: Binding71313 Ref: -some-->71740
Ref: -when-let71525 Node: Binding72211
Ref: -when-let*72010 Ref: -when-let72423
Ref: -if-let72533 Ref: -when-let*72908
Ref: -if-let*72928 Ref: -if-let73431
Ref: -let73545 Ref: -if-let*73826
Ref: -let*79635 Ref: -let74443
Ref: -lambda80575 Ref: -let*80533
Ref: -setq81372 Ref: -lambda81473
Node: Side-effects82188 Ref: -setq82270
Ref: -each82382 Node: Side-effects83086
Ref: -each-while82789 Ref: -each83280
Ref: -each-indexed83149 Ref: -each-while83687
Ref: -each-r83667 Ref: -each-indexed84047
Ref: -each-r-while84100 Ref: -each-r84565
Ref: -dotimes84475 Ref: -each-r-while84998
Ref: -doto84778 Ref: -dotimes85373
Ref: --doto85206 Ref: -doto85676
Node: Destructive operations85481 Ref: --doto86104
Ref: !cons85654 Node: Destructive operations86379
Ref: !cdr85860 Ref: !cons86552
Node: Function combinators86055 Ref: !cdr86758
Ref: -partial86329 Node: Function combinators86953
Ref: -rpartial86725 Ref: -partial87227
Ref: -juxt87128 Ref: -rpartial87623
Ref: -compose87560 Ref: -juxt88026
Ref: -applify88113 Ref: -compose88458
Ref: -on88560 Ref: -applify89011
Ref: -flip89086 Ref: -on89442
Ref: -const89398 Ref: -flip89968
Ref: -cut89737 Ref: -const90280
Ref: -not90223 Ref: -cut90619
Ref: -orfn90533 Ref: -not91105
Ref: -andfn90967 Ref: -orfn91415
Ref: -iteratefn91462 Ref: -andfn91849
Ref: -fixfn92165 Ref: -iteratefn92344
Ref: -prodfn93728 Ref: -fixfn93047
Node: Development94796 Ref: -prodfn94609
Node: Contribute95145 Node: Development95677
Node: Changes95893 Node: Contribute96026
Node: Contributors98891 Node: Changes96774
Node: Index100510 Node: Contributors99772
Node: Index101391
 
End Tag Table End Tag Table

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