From 408db76b8065999d2b90cbf52289cb8f97b4a393 Mon Sep 17 00:00:00 2001 From: Andreas Gerler Date: Sat, 2 Jan 2021 18:47:40 +0100 Subject: [PATCH] fixup! fix theme for orgmode on 27.1 --- bba.org | 2 +- custom.el | 4 +- elpa/dash-20200119.2310/dash-autoloads.el | 26 - elpa/dash-20200119.2310/dash-pkg.el | 9 - elpa/dash-20210101.1712/dash-autoloads.el | 70 +++ elpa/dash-20210101.1712/dash-pkg.el | 9 + .../dash.el | 594 +++++++----------- .../dash.info | 530 ++++++++-------- .../dir | 0 9 files changed, 585 insertions(+), 659 deletions(-) delete mode 100644 elpa/dash-20200119.2310/dash-autoloads.el delete mode 100644 elpa/dash-20200119.2310/dash-pkg.el create mode 100644 elpa/dash-20210101.1712/dash-autoloads.el create mode 100644 elpa/dash-20210101.1712/dash-pkg.el rename elpa/{dash-20200119.2310 => dash-20210101.1712}/dash.el (86%) rename elpa/{dash-20200119.2310 => dash-20210101.1712}/dash.info (93%) rename elpa/{dash-20200119.2310 => dash-20210101.1712}/dir (100%) diff --git a/bba.org b/bba.org index 18ef6857..09c6142d 100644 --- a/bba.org +++ b/bba.org @@ -405,7 +405,7 @@ Some key bindings taken from [[https://ebzzry.github.io/emacs-pairs.html][emacs- (if (>= emacs-major-version 24) (progn (add-to-list 'load-path "~/.emacs.d/elpa/smartparens-20200105.1259") - (add-to-list 'load-path "~/.emacs.d/elpa/dash-20200119.2310") + (add-to-list 'load-path "~/.emacs.d/elpa/dash-20210101.1712") (require 'smartparens) (smartparens-global-mode 1) (defmacro def-pairs (pairs) diff --git a/custom.el b/custom.el index 3fb1fe33..98135cf5 100644 --- a/custom.el +++ b/custom.el @@ -50,8 +50,8 @@ ;; If you edit it by hand, you could mess it up, so be careful. ;; Your init file should contain only one such instance. ;; If there is more than one, they won't work right. - '(org-block ((t (:inherit shadow :background "#29759c" :foreground "#84cbef" :distant-forground "#131313")))) - '(org-block-begin-line ((t (:background "#07538a" :foreground "#84cbef")))) + '(org-block ((t (:inherit shadow :background "#29759c" :foreground "#84cbef" :distant-forground "#131313" :extend t)))) + '(org-block-begin-line ((t (:background "#07538a" :foreground "#84cbef" :extend t)))) '(org-block-end-line ((t (:inherit org-block-begin-line)))) '(org-document-title ((t (:inherit default :foreground "#62a9cd" :font "Arial" :height 1.5 :underline nil)))) '(org-level-1 ((t (:inherit default :foreground "#62a9cd" :font "Arial" :height 1.6)))) diff --git a/elpa/dash-20200119.2310/dash-autoloads.el b/elpa/dash-20200119.2310/dash-autoloads.el deleted file mode 100644 index c5e79028..00000000 --- a/elpa/dash-20200119.2310/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-20200119.2310/dash-pkg.el b/elpa/dash-20200119.2310/dash-pkg.el deleted file mode 100644 index 91f8535f..00000000 --- a/elpa/dash-20200119.2310/dash-pkg.el +++ /dev/null @@ -1,9 +0,0 @@ -(define-package "dash" "20200119.2310" "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-20210101.1712/dash-autoloads.el b/elpa/dash-20210101.1712/dash-autoloads.el new file mode 100644 index 00000000..0b16ab1c --- /dev/null +++ b/elpa/dash-20210101.1712/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-20210101.1712/dash-pkg.el b/elpa/dash-20210101.1712/dash-pkg.el new file mode 100644 index 00000000..cc822c6c --- /dev/null +++ b/elpa/dash-20210101.1712/dash-pkg.el @@ -0,0 +1,9 @@ +(define-package "dash" "20210101.1712" "A modern list library for Emacs" 'nil :commit "e8ed3d640797a8b816d1d5e2710a960765ab034b" :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-20200119.2310/dash.el b/elpa/dash-20210101.1712/dash.el similarity index 86% rename from elpa/dash-20200119.2310/dash.el rename to elpa/dash-20210101.1712/dash.el index bc713ce2..3c07f3b1 100644 --- a/elpa/dash-20200119.2310/dash.el +++ b/elpa/dash-20210101.1712/dash.el @@ -4,9 +4,9 @@ ;; Author: Magnar Sveen ;; Version: 2.17.0 -;; Keywords: lists +;; Keywords: extensions, lisp -;; This program is free software; you can redistribute it and/or modify +;; 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 ;; the Free Software Foundation, either version 3 of the License, or ;; (at your option) any later version. @@ -17,7 +17,7 @@ ;; GNU General Public License for more details. ;; You should have received a copy of the GNU General Public License -;; along with this program. If not, see . +;; along with this program. If not, see . ;;; Commentary: @@ -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)) @@ -847,50 +833,21 @@ section is returned. Defaults to 1." (push it new-list))) (nreverse new-list))) -(defun -take (n list) - "Return a new list of the first N items in LIST, or all items if there are fewer than N. - -See also: `-take-last'" - (declare (pure t) (side-effect-free t)) - (let (result) - (--dotimes n - (when list - (!cons (car list) result) - (!cdr list))) - (nreverse result))) - -(defun -take-last (n list) - "Return the last N items of LIST in order. - -See also: `-take'" - (declare (pure t) (side-effect-free t)) - (copy-sequence (last list n))) - -(defalias '-drop 'nthcdr - "Return the tail of LIST without the first N items. - -See also: `-drop-last' - -\(fn N LIST)") - -(defun -drop-last (n list) - "Remove the last N items of LIST and return a copy. - -See also: `-drop'" - ;; No alias because we don't want magic optional argument - (declare (pure t) (side-effect-free t)) - (butlast list n)) - (defmacro --take-while (form list) "Anaphoric form of `-take-while'." (declare (debug (form form))) (let ((r (make-symbol "result"))) `(let (,r) - (--each-while ,list ,form (!cons it ,r)) + (--each-while ,list ,form (push it ,r)) (nreverse ,r)))) (defun -take-while (pred list) - "Return a new list of successive items from LIST while (PRED item) returns a non-nil value." + "Take successive items from LIST for which PRED returns non-nil. +PRED is a function of one argument. Return a new list of the +successive elements from the start of LIST for which PRED returns +non-nil. + +See also: `-drop-while'" (--take-while (funcall pred it) list)) (defmacro --drop-while (form list) @@ -898,14 +855,52 @@ See also: `-drop'" (declare (debug (form form))) (let ((l (make-symbol "list"))) `(let ((,l ,list)) - (while (and ,l (let ((it (car ,l))) ,form)) - (!cdr ,l)) - ,l))) + (--each-while ,l ,form (pop ,l)) + (copy-sequence ,l)))) (defun -drop-while (pred list) - "Return the tail of LIST starting from the first item for which (PRED item) returns nil." + "Drop successive items from LIST for which PRED returns non-nil. +PRED is a function of one argument. Return a copy of the tail of +LIST starting from its first element for which PRED returns nil. + +See also: `-take-while'" (--drop-while (funcall pred it) list)) +(defun -take (n list) + "Return a copy of the first N items in LIST. +Return a copy of LIST if it contains N items or fewer. +Return nil if N is zero or less. + +See also: `-take-last'" + (declare (pure t) (side-effect-free t)) + (--take-while (< it-index n) list)) + +(defun -take-last (n list) + "Return a copy of the last N items of LIST in order. +Return a copy of LIST if it contains N items or fewer. +Return nil if N is zero or less. + +See also: `-take'" + (declare (pure t) (side-effect-free t)) + (copy-sequence (last list n))) + +(defun -drop (n list) + "Return a copy of the tail of LIST without the first N items. +Return a copy of LIST if N is zero or less. +Return nil if LIST contains N items or fewer. + +See also: `-drop-last'" + (copy-sequence (nthcdr n list))) + +(defun -drop-last (n list) + "Return a copy of LIST without its last N items. +Return a copy of LIST if N is zero or less. +Return nil if LIST contains N items or fewer. + +See also: `-drop'" + (declare (pure t) (side-effect-free t)) + (nbutlast (copy-sequence list) n)) + (defun -split-at (n list) "Return a list of ((-take N LIST) (-drop N LIST)), in no more than one pass through the list." (declare (pure t) (side-effect-free t)) @@ -1328,16 +1323,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 +1578,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 +2772,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-20200119.2310/dash.info b/elpa/dash-20210101.1712/dash.info similarity index 93% rename from elpa/dash-20200119.2310/dash.info rename to elpa/dash-20210101.1712/dash.info index ee791c47..ab669ce9 100644 --- a/elpa/dash-20200119.2310/dash.info +++ b/elpa/dash-20210101.1712/dash.info @@ -4,7 +4,7 @@ This manual is for ‘dash.el’ version 2.12.1. Copyright © 2012-2015 Magnar Sveen - This program is free software; you can redistribute it and/or + 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 the Free Software Foundation, either version 3 of the License, or (at your option) any later version. @@ -16,7 +16,7 @@ This manual is for ‘dash.el’ version 2.12.1. You should have received a copy of the GNU General Public License along with this program. If not, see - . + . INFO-DIR-SECTION Emacs START-INFO-DIR-ENTRY * Dash: (dash.info). A modern list library for GNU Emacs @@ -32,7 +32,7 @@ This manual is for ‘dash.el’ version 2.12.1. Copyright © 2012-2015 Magnar Sveen - This program is free software; you can redistribute it and/or + 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 the Free Software Foundation, either version 3 of the License, or (at your option) any later version. @@ -44,7 +44,7 @@ This manual is for ‘dash.el’ version 2.12.1. You should have received a copy of the GNU General Public License along with this program. If not, see - . + . * Menu: @@ -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 @@ -426,8 +433,8 @@ Functions returning a sublist of the original list. ⇒ '(2 4 6 8) -- Function: -take (n list) - Return a new list of the first N items in LIST, or all items if - there are fewer than N. + Return a copy of the first N items in LIST. Return a copy of LIST + if it contains N items or fewer. Return nil if N is zero or less. See also: ‘-take-last’ (*note -take-last::) @@ -435,9 +442,13 @@ Functions returning a sublist of the original list. ⇒ '(1 2 3) (-take 17 '(1 2 3 4 5)) ⇒ '(1 2 3 4 5) + (-take 0 '(1 2 3 4 5)) + ⇒ nil -- Function: -take-last (n list) - Return the last N items of LIST in order. + Return a copy of the last N items of LIST in order. Return a copy + of LIST if it contains N items or fewer. Return nil if N is zero + or less. See also: ‘-take’ (*note -take::) @@ -449,41 +460,54 @@ Functions returning a sublist of the original list. ⇒ '(5) -- Function: -drop (n list) - Return the tail of LIST without the first N items. + Return a copy of the tail of LIST without the first N items. + Return a copy of LIST if N is zero or less. Return nil if LIST + contains N items or fewer. See also: ‘-drop-last’ (*note -drop-last::) - (fn N LIST) - (-drop 3 '(1 2 3 4 5)) ⇒ '(4 5) (-drop 17 '(1 2 3 4 5)) - ⇒ '() + ⇒ nil + (-drop 0 '(1 2 3 4 5)) + ⇒ '(1 2 3 4 5) -- Function: -drop-last (n list) - Remove the last N items of LIST and return a copy. + Return a copy of LIST without its last N items. Return a copy of + LIST if N is zero or less. Return nil if LIST contains N items or + fewer. See also: ‘-drop’ (*note -drop::) (-drop-last 3 '(1 2 3 4 5)) ⇒ '(1 2) (-drop-last 17 '(1 2 3 4 5)) - ⇒ '() + ⇒ nil + (-drop-last 0 '(1 2 3 4 5)) + ⇒ '(1 2 3 4 5) -- Function: -take-while (pred list) - Return a new list of successive items from LIST while (PRED item) - returns a non-nil value. + Take successive items from LIST for which PRED returns non-nil. + PRED is a function of one argument. Return a new list of the + successive elements from the start of LIST for which PRED returns + non-nil. + + See also: ‘-drop-while’ (*note -drop-while::) (-take-while 'even? '(1 2 3 4)) - ⇒ '() + ⇒ nil (-take-while 'even? '(2 4 5 6)) ⇒ '(2 4) (--take-while (< it 4) '(1 2 3 4 3 2 1)) ⇒ '(1 2 3) -- Function: -drop-while (pred list) - Return the tail of LIST starting from the first item for which - (PRED item) returns nil. + Drop successive items from LIST for which PRED returns non-nil. + PRED is a function of one argument. Return a copy of the tail of + LIST starting from its first element for which PRED returns nil. + + See also: ‘-take-while’ (*note -take-while::) (-drop-while 'even? '(1 2 3 4)) ⇒ '(1 2 3 4) @@ -1689,7 +1713,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 +1725,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 +2156,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 +2491,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 +2590,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 +2766,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 +3007,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 +3039,15 @@ Index (line 168) * -difference: Set operations. (line 20) * -distinct: Set operations. (line 62) -* -dotimes: Side-effects. (line 61) -* -doto: Side-effects. (line 70) -* -drop: Sublist selection. (line 124) -* -drop-last: Sublist selection. (line 136) -* -drop-while: Sublist selection. (line 157) +* -dotimes: Side-effects. (line 63) +* -doto: Side-effects. (line 72) +* -drop: Sublist selection. (line 128) +* -drop-last: Sublist selection. (line 142) +* -drop-while: Sublist selection. (line 171) * -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) @@ -3142,9 +3168,9 @@ Index * -same-items?: Predicates. (line 72) * -second-item: Other list operations. (line 286) -* -select-by-indices: Sublist selection. (line 168) -* -select-column: Sublist selection. (line 198) -* -select-columns: Sublist selection. (line 179) +* -select-by-indices: Sublist selection. (line 185) +* -select-column: Sublist selection. (line 215) +* -select-columns: Sublist selection. (line 196) * -separate: Partitioning. (line 63) * -setq: Binding. (line 274) * -slice: Sublist selection. (line 85) @@ -3170,8 +3196,8 @@ Index (line 209) * -tails: Reductions. (line 213) * -take: Sublist selection. (line 101) -* -take-last: Sublist selection. (line 112) -* -take-while: Sublist selection. (line 146) +* -take-last: Sublist selection. (line 114) +* -take-while: Sublist selection. (line 156) * -third-item: Other list operations. (line 298) * -tree-map: Tree operations. (line 28) @@ -3200,207 +3226,207 @@ 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: Top947 +Node: Installation2424 +Node: Using in a package2991 +Node: Fontification of special variables3352 +Node: Functions4056 +Node: Maps5267 +Ref: -map5562 +Ref: -map-when5903 +Ref: -map-first6481 +Ref: -map-last6959 +Ref: -map-indexed7432 +Ref: -annotate7912 +Ref: -splice8402 +Ref: -splice-list9183 +Ref: -mapcat9645 +Ref: -copy10021 +Node: Sublist selection10225 +Ref: -filter10418 +Ref: -remove10870 +Ref: -remove-first11276 +Ref: -remove-last11803 +Ref: -remove-item12324 +Ref: -non-nil12719 +Ref: -slice12878 +Ref: -take13410 +Ref: -take-last13819 +Ref: -drop14252 +Ref: -drop-last14682 +Ref: -take-while15110 +Ref: -drop-while15636 +Ref: -select-by-indices16160 +Ref: -select-columns16674 +Ref: -select-column17380 +Node: List to list17844 +Ref: -keep18036 +Ref: -concat18539 +Ref: -flatten18836 +Ref: -flatten-n19595 +Ref: -replace19982 +Ref: -replace-first20445 +Ref: -replace-last20942 +Ref: -insert-at21432 +Ref: -replace-at21759 +Ref: -update-at22149 +Ref: -remove-at22640 +Ref: -remove-at-indices23128 +Node: Reductions23710 +Ref: -reduce-from23879 +Ref: -reduce-r-from24645 +Ref: -reduce25412 +Ref: -reduce-r26141 +Ref: -reductions-from27012 +Ref: -reductions-r-from27727 +Ref: -reductions28452 +Ref: -reductions-r29077 +Ref: -count29712 +Ref: -sum29936 +Ref: -running-sum30125 +Ref: -product30418 +Ref: -running-product30627 +Ref: -inits30940 +Ref: -tails31188 +Ref: -common-prefix31435 +Ref: -common-suffix31732 +Ref: -min32029 +Ref: -min-by32255 +Ref: -max32778 +Ref: -max-by33003 +Node: Unfolding33531 +Ref: -iterate33770 +Ref: -unfold34215 +Node: Predicates35023 +Ref: -any?35147 +Ref: -all?35467 +Ref: -none?35797 +Ref: -only-some?36099 +Ref: -contains?36584 +Ref: -same-items?36973 +Ref: -is-prefix?37358 +Ref: -is-suffix?37681 +Ref: -is-infix?38004 +Node: Partitioning38358 +Ref: -split-at38546 +Ref: -split-with38831 +Ref: -split-on39234 +Ref: -split-when39910 +Ref: -separate40550 +Ref: -partition40992 +Ref: -partition-all41444 +Ref: -partition-in-steps41872 +Ref: -partition-all-in-steps42369 +Ref: -partition-by42854 +Ref: -partition-by-header43236 +Ref: -partition-after-pred43840 +Ref: -partition-before-pred44184 +Ref: -partition-before-item44535 +Ref: -partition-after-item44846 +Ref: -group-by45152 +Node: Indexing45589 +Ref: -elem-index45791 +Ref: -elem-indices46186 +Ref: -find-index46569 +Ref: -find-last-index47058 +Ref: -find-indices47562 +Ref: -grade-up47970 +Ref: -grade-down48373 +Node: Set operations48783 +Ref: -union48966 +Ref: -difference49408 +Ref: -intersection49825 +Ref: -powerset50262 +Ref: -permutations50475 +Ref: -distinct50775 +Node: Other list operations51153 +Ref: -rotate51378 +Ref: -repeat51748 +Ref: -cons*52011 +Ref: -snoc52398 +Ref: -interpose52811 +Ref: -interleave53109 +Ref: -zip-with53478 +Ref: -zip54195 +Ref: -zip-lists55027 +Ref: -zip-fill55728 +Ref: -unzip56051 +Ref: -cycle56796 +Ref: -pad57198 +Ref: -table57521 +Ref: -table-flat58310 +Ref: -first59318 +Ref: -some59690 +Ref: -last59999 +Ref: -first-item60333 +Ref: -second-item60749 +Ref: -third-item61029 +Ref: -fourth-item61307 +Ref: -fifth-item61573 +Ref: -last-item61835 +Ref: -butlast62127 +Ref: -sort62374 +Ref: -list62863 +Ref: -fix63194 +Node: Tree operations63734 +Ref: -tree-seq63930 +Ref: -tree-map64788 +Ref: -tree-map-nodes65231 +Ref: -tree-reduce66081 +Ref: -tree-reduce-from66963 +Ref: -tree-mapreduce67564 +Ref: -tree-mapreduce-from68424 +Ref: -clone69710 +Node: Threading macros70038 +Ref: ->70183 +Ref: ->>70674 +Ref: -->71179 +Ref: -as->71735 +Ref: -some->72190 +Ref: -some->>72564 +Ref: -some-->73000 +Node: Binding73471 +Ref: -when-let73683 +Ref: -when-let*74168 +Ref: -if-let74691 +Ref: -if-let*75086 +Ref: -let75703 +Ref: -let*81793 +Ref: -lambda82733 +Ref: -setq83530 +Node: Side-effects84346 +Ref: -each84540 +Ref: -each-while84947 +Ref: -each-indexed85405 +Ref: -each-r85923 +Ref: -each-r-while86356 +Ref: -dotimes86731 +Ref: -doto87034 +Ref: --doto87462 +Node: Destructive operations87737 +Ref: !cons87910 +Ref: !cdr88116 +Node: Function combinators88311 +Ref: -partial88585 +Ref: -rpartial88979 +Ref: -juxt89382 +Ref: -compose89814 +Ref: -applify90367 +Ref: -on90798 +Ref: -flip91324 +Ref: -const91636 +Ref: -cut91975 +Ref: -not92461 +Ref: -orfn92771 +Ref: -andfn93205 +Ref: -iteratefn93700 +Ref: -fixfn94403 +Ref: -prodfn95966 +Node: Development97034 +Node: Contribute97383 +Node: Changes98131 +Node: Contributors101129 +Node: Index102748  End Tag Table diff --git a/elpa/dash-20200119.2310/dir b/elpa/dash-20210101.1712/dir similarity index 100% rename from elpa/dash-20200119.2310/dir rename to elpa/dash-20210101.1712/dir -- 2.47.3