diff --git a/elpa/dash-2.17.0/dash-autoloads.el b/elpa/dash-2.17.0/dash-autoloads.el deleted file mode 100644 index c5e7902..0000000 --- a/elpa/dash-2.17.0/dash-autoloads.el +++ /dev/null @@ -1,26 +0,0 @@ -;;; dash-autoloads.el --- automatically extracted autoloads -;; -;;; Code: - -(add-to-list 'load-path (directory-file-name - (or (file-name-directory #$) (car load-path)))) - - -;;;### (autoloads nil "dash" "dash.el" (0 0 0 0)) -;;; Generated autoloads from dash.el - -(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "dash" '("dash-" "-keep" "-butlast" "-non" "-only-some" "-zip" "-e" "->" "-a" "-gr" "-when-let" "-d" "-l" "-s" "-p" "-r" "-m" "-i" "-f" "-u" "-value-to-list" "-t" "--" "-c" "!cons" "!cdr"))) - -;;;*** - -;;;### (autoloads nil nil ("dash-pkg.el") (0 0 0 0)) - -;;;*** - -;; Local Variables: -;; version-control: never -;; no-byte-compile: t -;; no-update-autoloads: t -;; coding: utf-8 -;; End: -;;; dash-autoloads.el ends here diff --git a/elpa/dash-2.17.0/dash-pkg.el b/elpa/dash-2.17.0/dash-pkg.el deleted file mode 100644 index 109c36e..0000000 --- a/elpa/dash-2.17.0/dash-pkg.el +++ /dev/null @@ -1,9 +0,0 @@ -(define-package "dash" "2.17.0" "A modern list library for Emacs" 'nil :keywords - '("lists") - :authors - '(("Magnar Sveen" . "magnars@gmail.com")) - :maintainer - '("Magnar Sveen" . "magnars@gmail.com")) -;; Local Variables: -;; no-byte-compile: t -;; End: diff --git a/elpa/dash-20201231.1620/dash-autoloads.el b/elpa/dash-20201231.1620/dash-autoloads.el new file mode 100644 index 0000000..0b16ab1 --- /dev/null +++ b/elpa/dash-20201231.1620/dash-autoloads.el @@ -0,0 +1,70 @@ +;;; dash-autoloads.el --- automatically extracted autoloads +;; +;;; Code: + +(add-to-list 'load-path (directory-file-name + (or (file-name-directory #$) (car load-path)))) + + +;;;### (autoloads nil "dash" "dash.el" (0 0 0 0)) +;;; Generated autoloads from dash.el + +(autoload 'dash-fontify-mode "dash" "\ +Toggle fontification of Dash special variables. + +If called interactively, enable Dash-Fontify mode if ARG is +positive, and disable it if ARG is zero or negative. If called +from Lisp, also enable the mode if ARG is omitted or nil, and +toggle it if ARG is `toggle'; disable the mode otherwise. + +Dash-Fontify mode is a buffer-local minor mode intended for Emacs +Lisp buffers. Enabling it causes the special variables bound in +anaphoric Dash macros to be fontified. These anaphoras include +`it', `it-index', `acc', and `other'. In older Emacs versions +which do not dynamically detect macros, Dash-Fontify mode +additionally fontifies Dash macro calls. + +See also `dash-fontify-mode-lighter' and +`global-dash-fontify-mode'. + +\(fn &optional ARG)" t nil) + +(put 'global-dash-fontify-mode 'globalized-minor-mode t) + +(defvar global-dash-fontify-mode nil "\ +Non-nil if Global Dash-Fontify mode is enabled. +See the `global-dash-fontify-mode' command +for a description of this minor mode. +Setting this variable directly does not take effect; +either customize it (see the info node `Easy Customization') +or call the function `global-dash-fontify-mode'.") + +(custom-autoload 'global-dash-fontify-mode "dash" nil) + +(autoload 'global-dash-fontify-mode "dash" "\ +Toggle Dash-Fontify mode in all buffers. +With prefix ARG, enable Global Dash-Fontify mode if ARG is positive; +otherwise, disable it. If called from Lisp, enable the mode if +ARG is omitted or nil. + +Dash-Fontify mode is enabled in all buffers where +`dash--turn-on-fontify-mode' would do it. +See `dash-fontify-mode' for more information on Dash-Fontify mode. + +\(fn &optional ARG)" t nil) + +(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "dash" '("!cdr" "!cons" "--" "->" "-a" "-butlast" "-c" "-d" "-e" "-f" "-gr" "-i" "-keep" "-l" "-m" "-non" "-only-some" "-p" "-r" "-s" "-t" "-u" "-value-to-list" "-when-let" "-zip" "dash-"))) + +;;;*** + +;;;### (autoloads nil nil ("dash-pkg.el") (0 0 0 0)) + +;;;*** + +;; Local Variables: +;; version-control: never +;; no-byte-compile: t +;; no-update-autoloads: t +;; coding: utf-8 +;; End: +;;; dash-autoloads.el ends here diff --git a/elpa/dash-20201231.1620/dash-pkg.el b/elpa/dash-20201231.1620/dash-pkg.el new file mode 100644 index 0000000..0315400 --- /dev/null +++ b/elpa/dash-20201231.1620/dash-pkg.el @@ -0,0 +1,9 @@ +(define-package "dash" "20201231.1620" "A modern list library for Emacs" 'nil :commit "78fee36e7e7c02595e51fcacf067308be115c22c" :authors + (("Magnar Sveen" . "magnars@gmail.com")) + :maintainer + ("Magnar Sveen" . "magnars@gmail.com") + :keywords + ("extensions" "lisp")) +;; Local Variables: +;; no-byte-compile: t +;; End: diff --git a/elpa/dash-2.17.0/dash.el b/elpa/dash-20201231.1620/dash.el similarity index 87% rename from elpa/dash-2.17.0/dash.el rename to elpa/dash-20201231.1620/dash.el index bc713ce..162680c 100644 --- a/elpa/dash-2.17.0/dash.el +++ b/elpa/dash-20201231.1620/dash.el @@ -4,7 +4,7 @@ ;; Author: Magnar Sveen ;; Version: 2.17.0 -;; Keywords: lists +;; Keywords: extensions, lisp ;; This program is free software; you can redistribute it and/or modify ;; it under the terms of the GNU General Public License as published by @@ -40,22 +40,11 @@ (require 'cl))) (defgroup dash () - "Customize group for dash.el" + "Customize group for Dash, a modern list library." + :group 'extensions :group 'lisp :prefix "dash-") -(defun dash--enable-fontlock (symbol value) - (when value - (dash-enable-font-lock)) - (set-default symbol value)) - -(defcustom dash-enable-fontlock nil - "If non-nil, enable fontification of dash functions, macros and -special values." - :type 'boolean - :set 'dash--enable-fontlock - :group 'dash) - (defmacro !cons (car cdr) "Destructive: Set CDR to the cons of CAR and CDR." `(setq ,cdr (cons ,car ,cdr))) @@ -102,10 +91,9 @@ Note: `it' is not required in each form." (defun -each (list fn) "Call FN with every item in LIST. Return nil, used for side-effects only." + (declare (indent 1)) (--each list (funcall fn it))) -(put '-each 'lisp-indent-function 1) - (defalias '--each-indexed '--each) (defun -each-indexed (list fn) @@ -114,31 +102,30 @@ Note: `it' is not required in each form." In the anaphoric form `--each-indexed', the index is exposed as symbol `it-index'. See also: `-map-indexed'." + (declare (indent 1)) (--each list (funcall fn it-index it))) -(put '-each-indexed 'lisp-indent-function 1) (defmacro --each-while (list pred &rest body) "Anaphoric form of `-each-while'." (declare (debug (form form body)) (indent 2)) - (let ((l (make-symbol "list")) - (c (make-symbol "continue"))) + (let ((l (make-symbol "list"))) `(let ((,l ,list) - (,c t) - (it-index 0)) - (while (and ,l ,c) - (let ((it (car ,l))) - (if (not ,pred) (setq ,c nil) ,@body)) - (setq it-index (1+ it-index)) - (!cdr ,l))))) + (it-index 0) + it) + (ignore it) + (while (when ,l + (setq it (pop ,l)) + ,pred) + ,@body + (setq it-index (1+ it-index)))))) (defun -each-while (list pred fn) "Call FN with every item in LIST while (PRED item) is non-nil. Return nil, used for side-effects only." + (declare (indent 2)) (--each-while list (funcall pred it) (funcall fn it))) -(put '-each-while 'lisp-indent-function 2) - (defmacro --each-r (list &rest body) "Anaphoric form of `-each-r'." (declare (debug (form body)) @@ -195,10 +182,9 @@ Return nil, used for side-effects only." (defun -dotimes (num fn) "Repeatedly calls FN (presumably for side-effects) passing in integers from 0 through NUM-1." + (declare (indent 1)) (--dotimes num (funcall fn it))) -(put '-dotimes 'lisp-indent-function 1) - (defun -map (fn list) "Return a new list consisting of the result of applying FN to the items in LIST." (mapcar fn list)) @@ -1328,16 +1314,18 @@ 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. +return a list of cons-cells such that the above identity works. See also: `-zip'" (apply '-zip lists)) (defun -cycle (list) - "Return an infinite copy of LIST that will cycle through the -elements and repeat from the beginning." + "Return an infinite circular copy of LIST. +The returned list cycles through the elements of LIST and repeats +from the beginning." (declare (pure t) (side-effect-free t)) - (let ((newlist (-map 'identity list))) + ;; Also works with sequences that aren't lists. + (let ((newlist (append list ()))) (nconc newlist newlist))) (defun -pad (fill-value &rest lists) @@ -1581,7 +1569,7 @@ and when that result is non-nil, through the next form, etc." ,@more)))) (defmacro -some--> (x &optional form &rest more) - "When expr in 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." (declare (debug ->) (indent 1)) @@ -2775,298 +2763,157 @@ structure such as plist or alist." (declare (pure t) (side-effect-free t)) (-tree-map 'identity list)) -(defun dash-enable-font-lock () - "Add syntax highlighting to dash functions, macros and magic values." - (eval-after-load 'lisp-mode - '(progn - (let ((new-keywords '( - "!cons" - "!cdr" - "-each" - "--each" - "-each-indexed" - "--each-indexed" - "-each-while" - "--each-while" - "-doto" - "-dotimes" - "--dotimes" - "-map" - "--map" - "-reduce-from" - "--reduce-from" - "-reduce" - "--reduce" - "-reduce-r-from" - "--reduce-r-from" - "-reduce-r" - "--reduce-r" - "-reductions-from" - "-reductions-r-from" - "-reductions" - "-reductions-r" - "-filter" - "--filter" - "-select" - "--select" - "-remove" - "--remove" - "-reject" - "--reject" - "-remove-first" - "--remove-first" - "-reject-first" - "--reject-first" - "-remove-last" - "--remove-last" - "-reject-last" - "--reject-last" - "-remove-item" - "-non-nil" - "-keep" - "--keep" - "-map-indexed" - "--map-indexed" - "-splice" - "--splice" - "-splice-list" - "--splice-list" - "-map-when" - "--map-when" - "-replace-where" - "--replace-where" - "-map-first" - "--map-first" - "-map-last" - "--map-last" - "-replace" - "-replace-first" - "-replace-last" - "-flatten" - "-flatten-n" - "-concat" - "-mapcat" - "--mapcat" - "-copy" - "-cons*" - "-snoc" - "-first" - "--first" - "-find" - "--find" - "-some" - "--some" - "-any" - "--any" - "-last" - "--last" - "-first-item" - "-second-item" - "-third-item" - "-fourth-item" - "-fifth-item" - "-last-item" - "-butlast" - "-count" - "--count" - "-any?" - "--any?" - "-some?" - "--some?" - "-any-p" - "--any-p" - "-some-p" - "--some-p" - "-some->" - "-some->>" - "-some-->" - "-all?" - "-all-p" - "--all?" - "--all-p" - "-every?" - "--every?" - "-all-p" - "--all-p" - "-every-p" - "--every-p" - "-none?" - "--none?" - "-none-p" - "--none-p" - "-only-some?" - "--only-some?" - "-only-some-p" - "--only-some-p" - "-slice" - "-take" - "-drop" - "-drop-last" - "-take-last" - "-take-while" - "--take-while" - "-drop-while" - "--drop-while" - "-split-at" - "-rotate" - "-insert-at" - "-replace-at" - "-update-at" - "--update-at" - "-remove-at" - "-remove-at-indices" - "-split-with" - "--split-with" - "-split-on" - "-split-when" - "--split-when" - "-separate" - "--separate" - "-partition-all-in-steps" - "-partition-in-steps" - "-partition-all" - "-partition" - "-partition-after-item" - "-partition-after-pred" - "-partition-before-item" - "-partition-before-pred" - "-partition-by" - "--partition-by" - "-partition-by-header" - "--partition-by-header" - "-group-by" - "--group-by" - "-interpose" - "-interleave" - "-unzip" - "-zip-with" - "--zip-with" - "-zip" - "-zip-fill" - "-zip-lists" - "-zip-pair" - "-cycle" - "-pad" - "-annotate" - "--annotate" - "-table" - "-table-flat" - "-partial" - "-elem-index" - "-elem-indices" - "-find-indices" - "--find-indices" - "-find-index" - "--find-index" - "-find-last-index" - "--find-last-index" - "-select-by-indices" - "-select-columns" - "-select-column" - "-grade-up" - "-grade-down" - "->" - "->>" - "-->" - "-as->" - "-when-let" - "-when-let*" - "--when-let" - "-if-let" - "-if-let*" - "--if-let" - "-let*" - "-let" - "-lambda" - "-distinct" - "-uniq" - "-union" - "-intersection" - "-difference" - "-powerset" - "-permutations" - "-inits" - "-tails" - "-common-prefix" - "-common-suffix" - "-contains?" - "-contains-p" - "-same-items?" - "-same-items-p" - "-is-prefix-p" - "-is-prefix?" - "-is-suffix-p" - "-is-suffix?" - "-is-infix-p" - "-is-infix?" - "-sort" - "--sort" - "-list" - "-repeat" - "-sum" - "-running-sum" - "-product" - "-running-product" - "-max" - "-min" - "-max-by" - "--max-by" - "-min-by" - "--min-by" - "-iterate" - "--iterate" - "-fix" - "--fix" - "-unfold" - "--unfold" - "-cons-pair?" - "-cons-pair-p" - "-cons-to-list" - "-value-to-list" - "-tree-mapreduce-from" - "--tree-mapreduce-from" - "-tree-mapreduce" - "--tree-mapreduce" - "-tree-map" - "--tree-map" - "-tree-reduce-from" - "--tree-reduce-from" - "-tree-reduce" - "--tree-reduce" - "-tree-seq" - "--tree-seq" - "-tree-map-nodes" - "--tree-map-nodes" - "-clone" - "-rpartial" - "-juxt" - "-applify" - "-on" - "-flip" - "-const" - "-cut" - "-orfn" - "-andfn" - "-iteratefn" - "-fixfn" - "-prodfn" - )) - (special-variables '( - "it" - "it-index" - "acc" - "other" - ))) - (font-lock-add-keywords 'emacs-lisp-mode `((,(concat "\\_<" (regexp-opt special-variables 'paren) "\\_>") - 1 font-lock-variable-name-face)) 'append) - (font-lock-add-keywords 'emacs-lisp-mode `((,(concat "(\\s-*" (regexp-opt new-keywords 'paren) "\\_>") - 1 font-lock-keyword-face)) 'append)) - (--each (buffer-list) - (with-current-buffer it - (when (and (eq major-mode 'emacs-lisp-mode) - (boundp 'font-lock-mode) - font-lock-mode) - (font-lock-refresh-defaults))))))) +;;; Font lock + +(defvar dash--keywords + `(;; TODO: Do not fontify the following automatic variables + ;; globally; detect and limit to their local anaphoric scope. + (,(concat "\\_<" (regexp-opt '("acc" "it" "it-index" "other")) "\\_>") + 0 font-lock-variable-name-face) + ;; Elisp macro fontification was static prior to Emacs 25. + ,@(when (< emacs-major-version 25) + (let ((macs '("!cdr" + "!cons" + "-->" + "--all?" + "--annotate" + "--any?" + "--count" + "--dotimes" + "--doto" + "--drop-while" + "--each" + "--each-r" + "--each-r-while" + "--each-while" + "--filter" + "--find-index" + "--find-indices" + "--find-last-index" + "--first" + "--fix" + "--group-by" + "--if-let" + "--iterate" + "--keep" + "--last" + "--map" + "--map-first" + "--map-indexed" + "--map-last" + "--map-when" + "--mapcat" + "--max-by" + "--min-by" + "--none?" + "--only-some?" + "--partition-by" + "--partition-by-header" + "--reduce" + "--reduce-from" + "--reduce-r" + "--reduce-r-from" + "--remove" + "--remove-first" + "--remove-last" + "--separate" + "--some" + "--sort" + "--splice" + "--splice-list" + "--split-when" + "--split-with" + "--take-while" + "--tree-map" + "--tree-map-nodes" + "--tree-mapreduce" + "--tree-mapreduce-from" + "--tree-reduce" + "--tree-reduce-from" + "--tree-seq" + "--unfold" + "--update-at" + "--when-let" + "--zip-with" + "->" + "->>" + "-as->" + "-doto" + "-if-let" + "-if-let*" + "-lambda" + "-let" + "-let*" + "-setq" + "-some-->" + "-some->" + "-some->>" + "-split-on" + "-when-let" + "-when-let*"))) + `((,(concat "(" (regexp-opt macs 'symbols)) . 1))))) + "Font lock keywords for `dash-fontify-mode'.") + +(defcustom dash-fontify-mode-lighter nil + "Mode line lighter for `dash-fontify-mode'. +Either a string to display in the mode line when +`dash-fontify-mode' is on, or nil to display +nothing (the default)." + :package-version '(dash . "2.18.0") + :group 'dash + :type '(choice (string :tag "Lighter" :value " Dash") + (const :tag "Nothing" nil))) + +;;;###autoload +(define-minor-mode dash-fontify-mode + "Toggle fontification of Dash special variables. + +Dash-Fontify mode is a buffer-local minor mode intended for Emacs +Lisp buffers. Enabling it causes the special variables bound in +anaphoric Dash macros to be fontified. These anaphoras include +`it', `it-index', `acc', and `other'. In older Emacs versions +which do not dynamically detect macros, Dash-Fontify mode +additionally fontifies Dash macro calls. + +See also `dash-fontify-mode-lighter' and +`global-dash-fontify-mode'." + :group 'dash :lighter dash-fontify-mode-lighter + (if dash-fontify-mode + (font-lock-add-keywords nil dash--keywords t) + (font-lock-remove-keywords nil dash--keywords)) + (cond ((fboundp 'font-lock-flush) ;; Added in Emacs 25. + (font-lock-flush)) + ;; `font-lock-fontify-buffer' unconditionally enables + ;; `font-lock-mode' and is marked `interactive-only' in later + ;; Emacs versions which have `font-lock-flush', so we guard + ;; and pacify as needed, respectively. + (font-lock-mode + (with-no-warnings + (font-lock-fontify-buffer))))) + +(defun dash--turn-on-fontify-mode () + "Enable `dash-fontify-mode' if in an Emacs Lisp buffer." + (when (derived-mode-p #'emacs-lisp-mode) + (dash-fontify-mode))) + +;;;###autoload +(define-globalized-minor-mode global-dash-fontify-mode + dash-fontify-mode dash--turn-on-fontify-mode + :group 'dash) + +(defcustom dash-enable-fontlock nil + "If non-nil, fontify Dash macro calls and special variables." + :group 'dash + :set (lambda (sym val) + (set-default sym val) + (global-dash-fontify-mode (if val 1 0))) + :type 'boolean) + +(make-obsolete-variable + 'dash-enable-fontlock #'global-dash-fontify-mode "2.18.0") + +(define-obsolete-function-alias + 'dash-enable-font-lock #'global-dash-fontify-mode "2.18.0") (provide 'dash) ;;; dash.el ends here diff --git a/elpa/dash-2.17.0/dash.info b/elpa/dash-20201231.1620/dash.info similarity index 95% rename from elpa/dash-2.17.0/dash.info rename to elpa/dash-20201231.1620/dash.info index ee791c4..25eb46f 100644 --- a/elpa/dash-2.17.0/dash.info +++ b/elpa/dash-20201231.1620/dash.info @@ -58,7 +58,7 @@ This manual is for ‘dash.el’ version 2.12.1. Installation * Using in a package:: -* Syntax highlighting of dash functions:: +* Fontification of special variables:: Functions @@ -91,7 +91,8 @@ File: dash.info, Node: Installation, Next: Functions, Prev: Top, Up: Top 1 Installation ************** -It’s available on Melpa (https://melpa.org/); use ‘M-x package-install’: +It’s available on GNU ELPA (https://elpa.gnu.org/) and MELPA +(https://melpa.org/); use ‘M-x package-install’: ‘M-x package-install dash’ Install the dash library. @@ -105,10 +106,10 @@ your load path somewhere. * Menu: * Using in a package:: -* Syntax highlighting of dash functions:: +* Fontification of special variables::  -File: dash.info, Node: Using in a package, Next: Syntax highlighting of dash functions, Up: Installation +File: dash.info, Node: Using in a package, Next: Fontification of special variables, Up: Installation 1.1 Using in a package ====================== @@ -122,15 +123,21 @@ To get function combinators: ;; Package-Requires: ((dash "2.12.1") (dash-functional "1.2.0") (emacs "24"))  -File: dash.info, Node: Syntax highlighting of dash functions, Prev: Using in a package, Up: Installation +File: dash.info, Node: Fontification of special variables, Prev: Using in a package, Up: Installation -1.2 Syntax highlighting of dash functions -========================================= +1.2 Fontification of special variables +====================================== -Font lock of dash functions in emacs lisp buffers is now optional. -Include this in your emacs settings to get syntax highlighting: +Font lock of special Dash variables (‘it’, ‘acc’, etc.) in Emacs Lisp +buffers can optionally be enabled with the autoloaded minor mode +‘dash-fontify-mode’. In older Emacs versions which do not dynamically +detect macros, the minor mode also fontifies Dash macro calls. - (eval-after-load 'dash '(dash-enable-font-lock)) + To automatically enable the minor mode in all Emacs Lisp buffers, +just call its autoloaded global counterpart ‘global-dash-fontify-mode’, +either interactively or from your ‘user-init-file’: + + (global-dash-fontify-mode)  File: dash.info, Node: Functions, Next: Development, Prev: Installation, Up: Top @@ -1689,7 +1696,7 @@ 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. + return a list of cons-cells such that the above identity works. See also: ‘-zip’ (*note -zip::) @@ -1701,8 +1708,8 @@ Other list functions not fit to be classified elsewhere. ⇒ '((1 . 3) (2 . 4)) -- Function: -cycle (list) - Return an infinite copy of LIST that will cycle through the - elements and repeat from the beginning. + Return an infinite circular copy of LIST. The returned list cycles + through the elements of LIST and repeats from the beginning. (-take 5 (-cycle '(1 2 3))) ⇒ '(1 2 3 1 2) @@ -2132,7 +2139,7 @@ File: dash.info, Node: Threading macros, Next: Binding, Prev: Tree operations ⇒ 106 -- Macro: -some--> (x &optional form &rest more) - When expr in non-nil, thread it through the first form (via ‘-->’ + When expr is non-nil, thread it through the first form (via ‘-->’ (*note -->::)), and when that result is non-nil, through the next form, etc. @@ -2467,10 +2474,12 @@ Functions iterating over lists for side-effect only. Call FN with every item in LIST while (PRED item) is non-nil. Return nil, used for side-effects only. - (let (s) (-each-while '(2 4 5 6) 'even? (lambda (item) (!cons item s))) s) + (let (s) (-each-while '(2 4 5 6) 'even? (lambda (item) (push item s))) s) ⇒ '(4 2) - (let (s) (--each-while '(1 2 3 4) (< it 3) (!cons it s)) s) + (let (s) (--each-while '(1 2 3 4) (< it 3) (push it s)) s) ⇒ '(2 1) + (let ((s 0)) (--each-while '(1 3 4 5) (odd? it) (setq s (+ s it))) s) + ⇒ 4 -- Function: -each-indexed (list fn) Call (FN index item) for each item in LIST. @@ -2564,8 +2573,8 @@ These combinators require Emacs 24 for its lexical scope. So they are offered in a separate package: ‘dash-functional‘. -- Function: -partial (fn &rest args) - Takes a function FN and fewer than the normal arguments to FN, and - returns a fn that takes a variable number of additional ARGS. When + Take a function FN and fewer than the normal arguments to FN, and + return a fn that takes a variable number of additional ARGS. When called, the returned function calls FN with ARGS first and then additional args. @@ -2740,7 +2749,7 @@ offered in a separate package: ‘dash-functional‘. 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 comparison test. + to provide an appropriate approximate 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 @@ -2981,7 +2990,7 @@ Index * !cons: Destructive operations. (line 6) * -->: Threading macros. (line 32) -* --doto: Side-effects. (line 81) +* --doto: Side-effects. (line 83) * ->: Threading macros. (line 6) * ->>: Threading macros. (line 19) * -all?: Predicates. (line 18) @@ -3013,15 +3022,15 @@ Index (line 168) * -difference: Set operations. (line 20) * -distinct: Set operations. (line 62) -* -dotimes: Side-effects. (line 61) -* -doto: Side-effects. (line 70) +* -dotimes: Side-effects. (line 63) +* -doto: Side-effects. (line 72) * -drop: Sublist selection. (line 124) * -drop-last: Sublist selection. (line 136) * -drop-while: Sublist selection. (line 157) * -each: Side-effects. (line 8) -* -each-indexed: Side-effects. (line 28) -* -each-r: Side-effects. (line 41) -* -each-r-while: Side-effects. (line 52) +* -each-indexed: Side-effects. (line 30) +* -each-r: Side-effects. (line 43) +* -each-r-while: Side-effects. (line 54) * -each-while: Side-effects. (line 19) * -elem-index: Indexing. (line 9) * -elem-indices: Indexing. (line 21) @@ -3201,206 +3210,206 @@ Index  Tag Table: Node: Top946 -Node: Installation2425 -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 +Node: Installation2422 +Node: Using in a package2989 +Node: Fontification of special variables3350 +Node: Functions4054 +Node: Maps5265 +Ref: -map5560 +Ref: -map-when5901 +Ref: -map-first6479 +Ref: -map-last6957 +Ref: -map-indexed7430 +Ref: -annotate7910 +Ref: -splice8400 +Ref: -splice-list9181 +Ref: -mapcat9643 +Ref: -copy10019 +Node: Sublist selection10223 +Ref: -filter10416 +Ref: -remove10868 +Ref: -remove-first11274 +Ref: -remove-last11801 +Ref: -remove-item12322 +Ref: -non-nil12717 +Ref: -slice12876 +Ref: -take13408 +Ref: -take-last13716 +Ref: -drop14039 +Ref: -drop-last14312 +Ref: -take-while14572 +Ref: -drop-while14922 +Ref: -select-by-indices15278 +Ref: -select-columns15792 +Ref: -select-column16498 +Node: List to list16962 +Ref: -keep17154 +Ref: -concat17657 +Ref: -flatten17954 +Ref: -flatten-n18713 +Ref: -replace19100 +Ref: -replace-first19563 +Ref: -replace-last20060 +Ref: -insert-at20550 +Ref: -replace-at20877 +Ref: -update-at21267 +Ref: -remove-at21758 +Ref: -remove-at-indices22246 +Node: Reductions22828 +Ref: -reduce-from22997 +Ref: -reduce-r-from23763 +Ref: -reduce24530 +Ref: -reduce-r25259 +Ref: -reductions-from26130 +Ref: -reductions-r-from26845 +Ref: -reductions27570 +Ref: -reductions-r28195 +Ref: -count28830 +Ref: -sum29054 +Ref: -running-sum29243 +Ref: -product29536 +Ref: -running-product29745 +Ref: -inits30058 +Ref: -tails30306 +Ref: -common-prefix30553 +Ref: -common-suffix30850 +Ref: -min31147 +Ref: -min-by31373 +Ref: -max31896 +Ref: -max-by32121 +Node: Unfolding32649 +Ref: -iterate32888 +Ref: -unfold33333 +Node: Predicates34141 +Ref: -any?34265 +Ref: -all?34585 +Ref: -none?34915 +Ref: -only-some?35217 +Ref: -contains?35702 +Ref: -same-items?36091 +Ref: -is-prefix?36476 +Ref: -is-suffix?36799 +Ref: -is-infix?37122 +Node: Partitioning37476 +Ref: -split-at37664 +Ref: -split-with37949 +Ref: -split-on38352 +Ref: -split-when39028 +Ref: -separate39668 +Ref: -partition40110 +Ref: -partition-all40562 +Ref: -partition-in-steps40990 +Ref: -partition-all-in-steps41487 +Ref: -partition-by41972 +Ref: -partition-by-header42354 +Ref: -partition-after-pred42958 +Ref: -partition-before-pred43302 +Ref: -partition-before-item43653 +Ref: -partition-after-item43964 +Ref: -group-by44270 +Node: Indexing44707 +Ref: -elem-index44909 +Ref: -elem-indices45304 +Ref: -find-index45687 +Ref: -find-last-index46176 +Ref: -find-indices46680 +Ref: -grade-up47088 +Ref: -grade-down47491 +Node: Set operations47901 +Ref: -union48084 +Ref: -difference48526 +Ref: -intersection48943 +Ref: -powerset49380 +Ref: -permutations49593 +Ref: -distinct49893 +Node: Other list operations50271 +Ref: -rotate50496 +Ref: -repeat50866 +Ref: -cons*51129 +Ref: -snoc51516 +Ref: -interpose51929 +Ref: -interleave52227 +Ref: -zip-with52596 +Ref: -zip53313 +Ref: -zip-lists54145 +Ref: -zip-fill54846 +Ref: -unzip55169 +Ref: -cycle55914 +Ref: -pad56316 +Ref: -table56639 +Ref: -table-flat57428 +Ref: -first58436 +Ref: -some58808 +Ref: -last59117 +Ref: -first-item59451 +Ref: -second-item59867 +Ref: -third-item60147 +Ref: -fourth-item60425 +Ref: -fifth-item60691 +Ref: -last-item60953 +Ref: -butlast61245 +Ref: -sort61492 +Ref: -list61981 +Ref: -fix62312 +Node: Tree operations62852 +Ref: -tree-seq63048 +Ref: -tree-map63906 +Ref: -tree-map-nodes64349 +Ref: -tree-reduce65199 +Ref: -tree-reduce-from66081 +Ref: -tree-mapreduce66682 +Ref: -tree-mapreduce-from67542 +Ref: -clone68828 +Node: Threading macros69156 +Ref: ->69301 +Ref: ->>69792 +Ref: -->70297 +Ref: -as->70853 +Ref: -some->71308 +Ref: -some->>71682 +Ref: -some-->72118 +Node: Binding72589 +Ref: -when-let72801 +Ref: -when-let*73286 +Ref: -if-let73809 +Ref: -if-let*74204 +Ref: -let74821 +Ref: -let*80911 +Ref: -lambda81851 +Ref: -setq82648 +Node: Side-effects83464 +Ref: -each83658 +Ref: -each-while84065 +Ref: -each-indexed84523 +Ref: -each-r85041 +Ref: -each-r-while85474 +Ref: -dotimes85849 +Ref: -doto86152 +Ref: --doto86580 +Node: Destructive operations86855 +Ref: !cons87028 +Ref: !cdr87234 +Node: Function combinators87429 +Ref: -partial87703 +Ref: -rpartial88097 +Ref: -juxt88500 +Ref: -compose88932 +Ref: -applify89485 +Ref: -on89916 +Ref: -flip90442 +Ref: -const90754 +Ref: -cut91093 +Ref: -not91579 +Ref: -orfn91889 +Ref: -andfn92323 +Ref: -iteratefn92818 +Ref: -fixfn93521 +Ref: -prodfn95084 +Node: Development96152 +Node: Contribute96501 +Node: Changes97249 +Node: Contributors100247 +Node: Index101866  End Tag Table diff --git a/elpa/dash-2.17.0/dir b/elpa/dash-20201231.1620/dir similarity index 100% rename from elpa/dash-2.17.0/dir rename to elpa/dash-20201231.1620/dir diff --git a/init.el b/init.el index bfc1ad0..25439a7 100644 --- a/init.el +++ b/init.el @@ -576,8 +576,7 @@ ;; * Essential external packages -(use-package dash - :pin "melpa-stable") +(use-package dash) (use-package hydra :pin "melpa-stable")