From 42ef36f8363fbe164066d75518268696f1dddfb0 Mon Sep 17 00:00:00 2001 From: Daniel Borchmann Date: Sat, 21 Dec 2019 18:52:50 +0100 Subject: [PATCH] Pin essential packages to melpa-stable --- .gitignore | 17 +- .../bind-key-autoloads.el | 11 +- elpa/bind-key-2.4/bind-key-pkg.el | 2 + .../bind-key.el | 2 +- elpa/bind-key-20180513.430/bind-key-pkg.el | 2 - elpa/bind-key-readme.txt | 70 + .../dash-autoloads.el | 4 + elpa/dash-2.16.0/dash-pkg.el | 9 + .../dash.el | 57 +- elpa/dash-2.16.0/dash.info | 3379 +++++++++++++++++ elpa/dash-2.16.0/dir | 18 + elpa/dash-20190920.1035/dash-pkg.el | 2 - .../dash-functional-autoloads.el | 16 + .../dash-functional-pkg.el | 2 + .../dash-functional.el | 219 ++ elpa/dash-readme.txt | 8 + .../diminish-autoloads.el | 11 +- elpa/diminish-0.45/diminish-pkg.el | 2 + .../diminish.el | 15 +- elpa/diminish-20170419.1736/diminish-pkg.el | 2 - elpa/diminish-readme.txt | 70 + .../exec-path-from-shell-autoloads.el | 0 .../exec-path-from-shell-pkg.el | 2 + .../exec-path-from-shell.el | 4 +- .../exec-path-from-shell-pkg.el | 2 - elpa/exec-path-from-shell-readme.txt | 45 + .../hydra-autoloads.el | 0 .../hydra-examples.el | 0 .../hydra-ox.el | 0 .../hydra-pkg.el | 2 +- .../hydra.el | 69 +- elpa/hydra-readme.txt | 51 + .../lv-autoloads.el | 0 elpa/lv-0.15.0/lv-pkg.el | 2 + elpa/{lv-20191214.1357 => lv-0.15.0}/lv.el | 28 +- elpa/lv-20191214.1357/lv-pkg.el | 2 - elpa/lv-readme.txt | 9 + .../dir | 0 .../use-package-autoloads.el | 3 +- .../use-package-bind-key.el | 0 .../use-package-core.el | 10 +- .../use-package-delight.el | 0 .../use-package-diminish.el | 0 .../use-package-ensure.el | 0 .../use-package-jump.el | 0 .../use-package-lint.el | 0 .../use-package-pkg.el | 2 +- .../use-package.el | 0 .../use-package.info | 2 +- elpa/use-package-readme.txt | 8 + init.el | 13 +- 51 files changed, 4020 insertions(+), 152 deletions(-) rename elpa/{bind-key-20180513.430 => bind-key-2.4}/bind-key-autoloads.el (85%) create mode 100644 elpa/bind-key-2.4/bind-key-pkg.el rename elpa/{bind-key-20180513.430 => bind-key-2.4}/bind-key.el (99%) delete mode 100644 elpa/bind-key-20180513.430/bind-key-pkg.el create mode 100644 elpa/bind-key-readme.txt rename elpa/{dash-20190920.1035 => dash-2.16.0}/dash-autoloads.el (91%) create mode 100644 elpa/dash-2.16.0/dash-pkg.el rename elpa/{dash-20190920.1035 => dash-2.16.0}/dash.el (98%) create mode 100644 elpa/dash-2.16.0/dash.info create mode 100644 elpa/dash-2.16.0/dir delete mode 100644 elpa/dash-20190920.1035/dash-pkg.el create mode 100644 elpa/dash-functional-20180107.1618/dash-functional-autoloads.el create mode 100644 elpa/dash-functional-20180107.1618/dash-functional-pkg.el create mode 100644 elpa/dash-functional-20180107.1618/dash-functional.el create mode 100644 elpa/dash-readme.txt rename elpa/{diminish-20170419.1736 => diminish-0.45}/diminish-autoloads.el (88%) create mode 100644 elpa/diminish-0.45/diminish-pkg.el rename elpa/{diminish-20170419.1736 => diminish-0.45}/diminish.el (97%) delete mode 100644 elpa/diminish-20170419.1736/diminish-pkg.el create mode 100644 elpa/diminish-readme.txt rename elpa/{exec-path-from-shell-20190426.2227 => exec-path-from-shell-1.12}/exec-path-from-shell-autoloads.el (100%) create mode 100644 elpa/exec-path-from-shell-1.12/exec-path-from-shell-pkg.el rename elpa/{exec-path-from-shell-20190426.2227 => exec-path-from-shell-1.12}/exec-path-from-shell.el (98%) delete mode 100644 elpa/exec-path-from-shell-20190426.2227/exec-path-from-shell-pkg.el create mode 100644 elpa/exec-path-from-shell-readme.txt rename elpa/{hydra-20191125.955 => hydra-0.15.0}/hydra-autoloads.el (100%) rename elpa/{hydra-20191125.955 => hydra-0.15.0}/hydra-examples.el (100%) rename elpa/{hydra-20191125.955 => hydra-0.15.0}/hydra-ox.el (100%) rename elpa/{hydra-20191125.955 => hydra-0.15.0}/hydra-pkg.el (78%) rename elpa/{hydra-20191125.955 => hydra-0.15.0}/hydra.el (97%) create mode 100644 elpa/hydra-readme.txt rename elpa/{lv-20191214.1357 => lv-0.15.0}/lv-autoloads.el (100%) create mode 100644 elpa/lv-0.15.0/lv-pkg.el rename elpa/{lv-20191214.1357 => lv-0.15.0}/lv.el (81%) delete mode 100644 elpa/lv-20191214.1357/lv-pkg.el create mode 100644 elpa/lv-readme.txt rename elpa/{use-package-20191126.2034 => use-package-2.4}/dir (100%) rename elpa/{use-package-20191126.2034 => use-package-2.4}/use-package-autoloads.el (99%) rename elpa/{use-package-20191126.2034 => use-package-2.4}/use-package-bind-key.el (100%) rename elpa/{use-package-20191126.2034 => use-package-2.4}/use-package-core.el (99%) rename elpa/{use-package-20191126.2034 => use-package-2.4}/use-package-delight.el (100%) rename elpa/{use-package-20191126.2034 => use-package-2.4}/use-package-diminish.el (100%) rename elpa/{use-package-20191126.2034 => use-package-2.4}/use-package-ensure.el (100%) rename elpa/{use-package-20191126.2034 => use-package-2.4}/use-package-jump.el (100%) rename elpa/{use-package-20191126.2034 => use-package-2.4}/use-package-lint.el (100%) rename elpa/{use-package-20191126.2034 => use-package-2.4}/use-package-pkg.el (76%) rename elpa/{use-package-20191126.2034 => use-package-2.4}/use-package.el (100%) rename elpa/{use-package-20191126.2034 => use-package-2.4}/use-package.info (99%) create mode 100644 elpa/use-package-readme.txt diff --git a/.gitignore b/.gitignore index 3fbff20..872f6db 100644 --- a/.gitignore +++ b/.gitignore @@ -8,15 +8,14 @@ /ebackup/ /el-get/ /elpa/* -!/elpa/diminish-20* -!/elpa/bind-key-20* -!/elpa/use-package-20* -!/elpa/dash-20* -!/elpa/hydra-20* -!/elpa/page-break-lines-20* -!/elpa/multiple-cursors-20* -!/elpa/exec-path-from-shell-20* -!/elpa/lv-20* +!/elpa/diminish-* +!/elpa/bind-key-* +!/elpa/use-package-* +!/elpa/dash-* +!/elpa/hydra-* +!/elpa/page-break-lines-* +!/elpa/exec-path-from-shell-* +!/elpa/lv-* /emms/ /eshell/history /eshell/lastdir diff --git a/elpa/bind-key-20180513.430/bind-key-autoloads.el b/elpa/bind-key-2.4/bind-key-autoloads.el similarity index 85% rename from elpa/bind-key-20180513.430/bind-key-autoloads.el rename to elpa/bind-key-2.4/bind-key-autoloads.el index d7c5756..7f4d424 100644 --- a/elpa/bind-key-20180513.430/bind-key-autoloads.el +++ b/elpa/bind-key-2.4/bind-key-autoloads.el @@ -1,10 +1,12 @@ ;;; bind-key-autoloads.el --- automatically extracted autoloads ;; ;;; Code: -(add-to-list 'load-path (directory-file-name (or (file-name-directory #$) (car load-path)))) + +(add-to-list 'load-path (directory-file-name + (or (file-name-directory #$) (car load-path)))) + -;;;### (autoloads nil "bind-key" "bind-key.el" (23441 26626 910934 -;;;;;; 47000)) +;;;### (autoloads nil "bind-key" "bind-key.el" (0 0 0 0)) ;;; Generated autoloads from bind-key.el (autoload 'bind-key "bind-key" "\ @@ -69,11 +71,14 @@ Display all the personal keybindings defined by `bind-key'. \(fn)" t nil) +(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "bind-key" '("compare-keybindings" "get-binding-description" "bind-key" "personal-keybindings" "override-global-m"))) + ;;;*** ;; Local Variables: ;; version-control: never ;; no-byte-compile: t ;; no-update-autoloads: t +;; coding: utf-8 ;; End: ;;; bind-key-autoloads.el ends here diff --git a/elpa/bind-key-2.4/bind-key-pkg.el b/elpa/bind-key-2.4/bind-key-pkg.el new file mode 100644 index 0000000..b4ca946 --- /dev/null +++ b/elpa/bind-key-2.4/bind-key-pkg.el @@ -0,0 +1,2 @@ +;;; -*- no-byte-compile: t -*- +(define-package "bind-key" "2.4" "A simple way to manage personal keybindings" 'nil :commit "39a8b8812c2c9f6f0b299e6a04e504ef393694ce" :keywords '("keys" "keybinding" "config" "dotemacs") :authors '(("John Wiegley" . "johnw@newartisans.com")) :maintainer '("John Wiegley" . "johnw@newartisans.com") :url "https://github.com/jwiegley/use-package") diff --git a/elpa/bind-key-20180513.430/bind-key.el b/elpa/bind-key-2.4/bind-key.el similarity index 99% rename from elpa/bind-key-20180513.430/bind-key.el rename to elpa/bind-key-2.4/bind-key.el index 34202a3..a28351f 100644 --- a/elpa/bind-key-20180513.430/bind-key.el +++ b/elpa/bind-key-2.4/bind-key.el @@ -7,7 +7,7 @@ ;; Created: 16 Jun 2012 ;; Modified: 29 Nov 2017 ;; Version: 2.4 -;; Package-Version: 20180513.430 +;; Package-Version: 2.4 ;; Keywords: keys keybinding config dotemacs ;; URL: https://github.com/jwiegley/use-package diff --git a/elpa/bind-key-20180513.430/bind-key-pkg.el b/elpa/bind-key-20180513.430/bind-key-pkg.el deleted file mode 100644 index 4521bb1..0000000 --- a/elpa/bind-key-20180513.430/bind-key-pkg.el +++ /dev/null @@ -1,2 +0,0 @@ -;;; -*- no-byte-compile: t -*- -(define-package "bind-key" "20180513.430" "A simple way to manage personal keybindings" 'nil :commit "3fb8f39f5901a4c0ef7887283e56e60b541675ea" :keywords '("keys" "keybinding" "config" "dotemacs") :authors '(("John Wiegley" . "johnw@newartisans.com")) :maintainer '("John Wiegley" . "johnw@newartisans.com") :url "https://github.com/jwiegley/use-package") diff --git a/elpa/bind-key-readme.txt b/elpa/bind-key-readme.txt new file mode 100644 index 0000000..67e866c --- /dev/null +++ b/elpa/bind-key-readme.txt @@ -0,0 +1,70 @@ +If you have lots of keybindings set in your .emacs file, it can be hard to +know which ones you haven't set yet, and which may now be overriding some +new default in a new emacs version. This module aims to solve that +problem. + +Bind keys as follows in your .emacs: + + (require 'bind-key) + + (bind-key "C-c x" 'my-ctrl-c-x-command) + +If the keybinding argument is a vector, it is passed straight to +`define-key', so remapping a key with `[remap COMMAND]' works as +expected: + + (bind-key [remap original-ctrl-c-x-command] 'my-ctrl-c-x-command) + +If you want the keybinding to override all minor modes that may also bind +the same key, use the `bind-key*' form: + + (bind-key* "" 'other-window) + +If you want to rebind a key only in a particular keymap, use: + + (bind-key "C-c x" 'my-ctrl-c-x-command some-other-mode-map) + +To unbind a key within a keymap (for example, to stop your favorite major +mode from changing a binding that you don't want to override everywhere), +use `unbind-key': + + (unbind-key "C-c x" some-other-mode-map) + +To bind multiple keys at once, or set up a prefix map, a `bind-keys' macro +is provided. It accepts keyword arguments, please see its documentation +for a detailed description. + +To add keys into a specific map, use :map argument + + (bind-keys :map dired-mode-map + ("o" . dired-omit-mode) + ("a" . some-custom-dired-function)) + +To set up a prefix map, use `:prefix-map' and `:prefix' arguments (both are +required) + + (bind-keys :prefix-map my-customize-prefix-map + :prefix "C-c c" + ("f" . customize-face) + ("v" . customize-variable)) + +You can combine all the keywords together. Additionally, +`:prefix-docstring' can be specified to set documentation of created +`:prefix-map' variable. + +To bind multiple keys in a `bind-key*' way (to be sure that your bindings +will not be overridden by other modes), you may use `bind-keys*' macro: + + (bind-keys* + ("C-o" . other-window) + ("C-M-n" . forward-page) + ("C-M-p" . backward-page)) + +After Emacs loads, you can see a summary of all your personal keybindings +currently in effect with this command: + + M-x describe-personal-keybindings + +This display will tell you if you've overriden a default keybinding, and +what the default was. Also, it will tell you if the key was rebound after +your binding it with `bind-key', and what it was rebound it to. diff --git a/elpa/dash-20190920.1035/dash-autoloads.el b/elpa/dash-2.16.0/dash-autoloads.el similarity index 91% rename from elpa/dash-20190920.1035/dash-autoloads.el rename to elpa/dash-2.16.0/dash-autoloads.el index 8bacbc8..c5e7902 100644 --- a/elpa/dash-20190920.1035/dash-autoloads.el +++ b/elpa/dash-2.16.0/dash-autoloads.el @@ -11,6 +11,10 @@ (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: diff --git a/elpa/dash-2.16.0/dash-pkg.el b/elpa/dash-2.16.0/dash-pkg.el new file mode 100644 index 0000000..9cbd898 --- /dev/null +++ b/elpa/dash-2.16.0/dash-pkg.el @@ -0,0 +1,9 @@ +(define-package "dash" "2.16.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-20190920.1035/dash.el b/elpa/dash-2.16.0/dash.el similarity index 98% rename from elpa/dash-20190920.1035/dash.el rename to elpa/dash-2.16.0/dash.el index 858c868..587c074 100644 --- a/elpa/dash-20190920.1035/dash.el +++ b/elpa/dash-2.16.0/dash.el @@ -4,7 +4,6 @@ ;; Author: Magnar Sveen ;; Version: 2.16.0 -;; Package-Version: 20190920.1035 ;; Keywords: lists ;; This program is free software; you can redistribute it and/or modify @@ -34,12 +33,6 @@ ;;; Code: -;; TODO: `gv' was introduced in Emacs 24.3, so remove this and all -;; calls to `defsetf' when support for earlier versions is dropped. -(eval-when-compile - (unless (fboundp 'gv-define-setter) - (require 'cl))) - (defgroup dash () "Customize group for dash.el" :group 'lisp @@ -689,10 +682,7 @@ See also: `-third-item'. \(fn LIST)") -(defalias '-third-item - (if (fboundp 'caddr) - #'caddr - (lambda (list) (car (cddr list)))) +(defalias '-third-item 'caddr "Return the third item of LIST, or nil if LIST is too short. See also: `-fourth-item'. @@ -713,18 +703,28 @@ See also: `-last-item'." (declare (pure t) (side-effect-free t)) (car (cdr (cdr (cdr (cdr list)))))) +;; TODO: gv was introduced in 24.3, so we can remove the if statement +;; when support for earlier versions is dropped +(eval-when-compile + (require 'cl) + (if (fboundp 'gv-define-simple-setter) + (gv-define-simple-setter -first-item setcar) + (require 'cl) + (with-no-warnings + (defsetf -first-item (x) (val) `(setcar ,x ,val))))) + (defun -last-item (list) "Return the last item of LIST, or nil on an empty list." (declare (pure t) (side-effect-free t)) (car (last list))) -;; Use `with-no-warnings' to suppress unbound `-last-item' or -;; undefined `gv--defsetter' warnings arising from both -;; `gv-define-setter' and `defsetf' in certain Emacs versions. -(with-no-warnings +;; TODO: gv was introduced in 24.3, so we can remove the if statement +;; when support for earlier versions is dropped +(eval-when-compile (if (fboundp 'gv-define-setter) (gv-define-setter -last-item (val x) `(setcar (last ,x) ,val)) - (defsetf -last-item (x) (val) `(setcar (last ,x) ,val)))) + (with-no-warnings + (defsetf -last-item (x) (val) `(setcar (last ,x) ,val))))) (defun -butlast (list) "Return a list of all items in list except for the last." @@ -2274,22 +2274,9 @@ The test for equality is done with `equal', or with `-compare-fn' if that's non-nil. Alias: `-uniq'" - ;; Implementation note: The speedup gained from hash table lookup - ;; starts to outweigh its overhead for lists of length greater than - ;; 32. See discussion in PR #305. - (let* ((len (length list)) - (lut (and (> len 32) - ;; Check that `-compare-fn' is a valid hash-table - ;; lookup function or `nil'. - (memq -compare-fn '(nil equal eq eql)) - (make-hash-table :test (or -compare-fn #'equal) - :size len)))) - (if lut - (--filter (unless (gethash it lut) - (puthash it t lut)) - list) - (--each list (unless (-contains? lut it) (!cons it lut))) - (nreverse lut)))) + (let (result) + (--each list (unless (-contains? result it) (!cons it result))) + (nreverse result))) (defalias '-uniq '-distinct) @@ -2342,11 +2329,7 @@ or with `-compare-fn' if that's non-nil." (defun -inits (list) "Return all prefixes of LIST." - (let ((res (list list))) - (setq list (reverse list)) - (while list - (push (reverse (!cdr list)) res)) - res)) + (nreverse (-map 'reverse (-tails (nreverse list))))) (defun -tails (list) "Return all suffixes of LIST" diff --git a/elpa/dash-2.16.0/dash.info b/elpa/dash-2.16.0/dash.info new file mode 100644 index 0000000..86c1b14 --- /dev/null +++ b/elpa/dash-2.16.0/dash.info @@ -0,0 +1,3379 @@ +This is dash.info, produced by makeinfo version 6.5 from dash.texi. + +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 + 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. + + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 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 + . +INFO-DIR-SECTION Emacs +START-INFO-DIR-ENTRY +* Dash: (dash.info). A modern list library for GNU Emacs +END-INFO-DIR-ENTRY + + +File: dash.info, Node: Top, Next: Installation, Up: (dir) + +dash +**** + +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 + 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. + + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 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 + . + +* Menu: + +* Installation:: +* Functions:: +* Development:: +* Index:: + +— The Detailed Node Listing — + +Installation + +* Using in a package:: +* Syntax highlighting of dash functions:: + +Functions + +* Maps:: +* Sublist selection:: +* List to list:: +* Reductions:: +* Unfolding:: +* Predicates:: +* Partitioning:: +* Indexing:: +* Set operations:: +* Other list operations:: +* Tree operations:: +* Threading macros:: +* Binding:: +* Side-effects:: +* Destructive operations:: +* Function combinators:: + +Development + +* Contribute:: How to contribute +* Changes:: List of significant changes by version +* Contributors:: List of contributors + + +File: dash.info, Node: Installation, Next: Functions, Prev: Top, Up: Top + +1 Installation +************** + +It’s available on marmalade (http://marmalade-repo.org/) and Melpa +(https://melpa.org/); use ‘M-x package-install’: + +‘M-x package-install dash’ + Install the dash library. + +‘M-x package-install dash-functional’ + Optional, if you want the function combinators. + + Alternatively, you can just dump dash.el or dash-functional.el in +your load path somewhere. + +* Menu: + +* Using in a package:: +* Syntax highlighting of dash functions:: + + +File: dash.info, Node: Using in a package, Next: Syntax highlighting of dash functions, Up: Installation + +1.1 Using in a package +====================== + +Add this to the big comment block at the top: + + ;; Package-Requires: ((dash "2.12.1")) + +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 + +1.2 Syntax highlighting of dash functions +========================================= + +Font lock of dash functions in emacs lisp buffers is now optional. +Include this in your emacs settings to get syntax highlighting: + + (eval-after-load 'dash '(dash-enable-font-lock)) + + +File: dash.info, Node: Functions, Next: Development, Prev: Installation, Up: Top + +2 Functions +*********** + +This chapter contains reference documentation for the dash application +programming interface (API). All functions and constructs in the library +are prefixed with a dash (-). + + There are also anaphoric versions of functions where that makes +sense, prefixed with two dashes instead of one. + + For instance, while ‘-map’ takes a function to map over the list, one +can also use the anaphoric form with double dashes - which will then be +executed with ‘it’ exposed as the list item. Here’s an example: + + (-map (lambda (n) (* n n)) '(1 2 3 4)) ;; normal version + + (--map (* it it) '(1 2 3 4)) ;; anaphoric version + +Of course, the original can also be written like + + (defun square (n) (* n n)) + + (-map 'square '(1 2 3 4)) + +which demonstrates the usefulness of both versions. + +* Menu: + +* Maps:: +* Sublist selection:: +* List to list:: +* Reductions:: +* Unfolding:: +* Predicates:: +* Partitioning:: +* Indexing:: +* Set operations:: +* Other list operations:: +* Tree operations:: +* Threading macros:: +* Binding:: +* Side-effects:: +* Destructive operations:: +* Function combinators:: + + +File: dash.info, Node: Maps, Next: Sublist selection, Up: Functions + +2.1 Maps +======== + +Functions in this category take a transforming function, which is then +applied sequentially to each or selected elements of the input list. +The results are collected in order and returned as new list. + + -- Function: -map (fn list) + Return a new list consisting of the result of applying FN to the + items in LIST. + + (-map (lambda (num) (* num num)) '(1 2 3 4)) + ⇒ '(1 4 9 16) + (-map 'square '(1 2 3 4)) + ⇒ '(1 4 9 16) + (--map (* it it) '(1 2 3 4)) + ⇒ '(1 4 9 16) + + -- Function: -map-when (pred rep list) + Return a new list where the elements in LIST that do not match the + PRED function are unchanged, and where the elements in LIST that do + match the PRED function are mapped through the REP function. + + Alias: ‘-replace-where’ + + See also: ‘-update-at’ (*note -update-at::) + + (-map-when 'even? 'square '(1 2 3 4)) + ⇒ '(1 4 3 16) + (--map-when (> it 2) (* it it) '(1 2 3 4)) + ⇒ '(1 2 9 16) + (--map-when (= it 2) 17 '(1 2 3 4)) + ⇒ '(1 17 3 4) + + -- Function: -map-first (pred rep list) + Replace first item in LIST satisfying PRED with result of REP + called on this item. + + See also: ‘-map-when’ (*note -map-when::), ‘-replace-first’ (*note + -replace-first::) + + (-map-first 'even? 'square '(1 2 3 4)) + ⇒ '(1 4 3 4) + (--map-first (> it 2) (* it it) '(1 2 3 4)) + ⇒ '(1 2 9 4) + (--map-first (= it 2) 17 '(1 2 3 2)) + ⇒ '(1 17 3 2) + + -- Function: -map-last (pred rep list) + Replace last item in LIST satisfying PRED with result of REP called + on this item. + + See also: ‘-map-when’ (*note -map-when::), ‘-replace-last’ (*note + -replace-last::) + + (-map-last 'even? 'square '(1 2 3 4)) + ⇒ '(1 2 3 16) + (--map-last (> it 2) (* it it) '(1 2 3 4)) + ⇒ '(1 2 3 16) + (--map-last (= it 2) 17 '(1 2 3 2)) + ⇒ '(1 2 3 17) + + -- Function: -map-indexed (fn list) + Return a new list consisting of the result of (FN index item) for + each item in LIST. + + In the anaphoric form ‘--map-indexed’, the index is exposed as + symbol ‘it-index’. + + See also: ‘-each-indexed’ (*note -each-indexed::). + + (-map-indexed (lambda (index item) (- item index)) '(1 2 3 4)) + ⇒ '(1 1 1 1) + (--map-indexed (- it it-index) '(1 2 3 4)) + ⇒ '(1 1 1 1) + + -- Function: -annotate (fn list) + Return a list of cons cells where each cell is FN applied to each + element of LIST paired with the unmodified element of LIST. + + (-annotate '1+ '(1 2 3)) + ⇒ '((2 . 1) (3 . 2) (4 . 3)) + (-annotate 'length '(("h" "e" "l" "l" "o") ("hello" "world"))) + ⇒ '((5 "h" "e" "l" "l" "o") (2 "hello" "world")) + (--annotate (< 1 it) '(0 1 2 3)) + ⇒ '((nil . 0) (nil . 1) (t . 2) (t . 3)) + + -- Function: -splice (pred fun list) + Splice lists generated by FUN in place of elements matching PRED in + LIST. + + FUN takes the element matching PRED as input. + + This function can be used as replacement for ‘,@’ in case you need + to splice several lists at marked positions (for example with + keywords). + + See also: ‘-splice-list’ (*note -splice-list::), ‘-insert-at’ + (*note -insert-at::) + + (-splice 'even? (lambda (x) (list x x)) '(1 2 3 4)) + ⇒ '(1 2 2 3 4 4) + (--splice 't (list it it) '(1 2 3 4)) + ⇒ '(1 1 2 2 3 3 4 4) + (--splice (equal it :magic) '((list of) (magical) (code)) '((foo) (bar) :magic (baz))) + ⇒ '((foo) (bar) (list of) (magical) (code) (baz)) + + -- Function: -splice-list (pred new-list list) + Splice NEW-LIST in place of elements matching PRED in LIST. + + See also: ‘-splice’ (*note -splice::), ‘-insert-at’ (*note + -insert-at::) + + (-splice-list 'keywordp '(a b c) '(1 :foo 2)) + ⇒ '(1 a b c 2) + (-splice-list 'keywordp nil '(1 :foo 2)) + ⇒ '(1 2) + (--splice-list (keywordp it) '(a b c) '(1 :foo 2)) + ⇒ '(1 a b c 2) + + -- Function: -mapcat (fn list) + Return the concatenation of the result of mapping FN over LIST. + Thus function FN should return a list. + + (-mapcat 'list '(1 2 3)) + ⇒ '(1 2 3) + (-mapcat (lambda (item) (list 0 item)) '(1 2 3)) + ⇒ '(0 1 0 2 0 3) + (--mapcat (list 0 it) '(1 2 3)) + ⇒ '(0 1 0 2 0 3) + + -- Function: -copy (arg) + Create a shallow copy of LIST. + + (fn LIST) + + (-copy '(1 2 3)) + ⇒ '(1 2 3) + (let ((a '(1 2 3))) (eq a (-copy a))) + ⇒ nil + + +File: dash.info, Node: Sublist selection, Next: List to list, Prev: Maps, Up: Functions + +2.2 Sublist selection +===================== + +Functions returning a sublist of the original list. + + -- Function: -filter (pred list) + Return a new list of the items in LIST for which PRED returns a + non-nil value. + + Alias: ‘-select’ + + See also: ‘-keep’ (*note -keep::), ‘-remove’ (*note -remove::). + + (-filter (lambda (num) (= 0 (% num 2))) '(1 2 3 4)) + ⇒ '(2 4) + (-filter 'even? '(1 2 3 4)) + ⇒ '(2 4) + (--filter (= 0 (% it 2)) '(1 2 3 4)) + ⇒ '(2 4) + + -- Function: -remove (pred list) + Return a new list of the items in LIST for which PRED returns nil. + + Alias: ‘-reject’ + + See also: ‘-filter’ (*note -filter::). + + (-remove (lambda (num) (= 0 (% num 2))) '(1 2 3 4)) + ⇒ '(1 3) + (-remove 'even? '(1 2 3 4)) + ⇒ '(1 3) + (--remove (= 0 (% it 2)) '(1 2 3 4)) + ⇒ '(1 3) + + -- Function: -remove-first (pred list) + Return a new list with the first item matching PRED removed. + + Alias: ‘-reject-first’ + + See also: ‘-remove’ (*note -remove::), ‘-map-first’ (*note + -map-first::) + + (-remove-first 'even? '(1 3 5 4 7 8 10)) + ⇒ '(1 3 5 7 8 10) + (-remove-first 'stringp '(1 2 "first" "second" "third")) + ⇒ '(1 2 "second" "third") + (--remove-first (> it 3) '(1 2 3 4 5 6 7 8 9 10)) + ⇒ '(1 2 3 5 6 7 8 9 10) + + -- Function: -remove-last (pred list) + Return a new list with the last item matching PRED removed. + + Alias: ‘-reject-last’ + + See also: ‘-remove’ (*note -remove::), ‘-map-last’ (*note + -map-last::) + + (-remove-last 'even? '(1 3 5 4 7 8 10 11)) + ⇒ '(1 3 5 4 7 8 11) + (-remove-last 'stringp '(1 2 "last" "second" "third")) + ⇒ '(1 2 "last" "second") + (--remove-last (> it 3) '(1 2 3 4 5 6 7 8 9 10)) + ⇒ '(1 2 3 4 5 6 7 8 9) + + -- Function: -remove-item (item list) + Remove all occurences of ITEM from LIST. + + Comparison is done with ‘equal’. + + (-remove-item 3 '(1 2 3 2 3 4 5 3)) + ⇒ '(1 2 2 4 5) + (-remove-item 'foo '(foo bar baz foo)) + ⇒ '(bar baz) + (-remove-item "bob" '("alice" "bob" "eve" "bob" "dave")) + ⇒ '("alice" "eve" "dave") + + -- Function: -non-nil (list) + Return all non-nil elements of LIST. + + (-non-nil '(1 nil 2 nil nil 3 4 nil 5 nil)) + ⇒ '(1 2 3 4 5) + + -- Function: -slice (list from &optional to step) + Return copy of LIST, starting from index FROM to index TO. + + FROM or TO may be negative. These values are then interpreted + modulo the length of the list. + + If STEP is a number, only each STEPth item in the resulting section + is returned. Defaults to 1. + + (-slice '(1 2 3 4 5) 1) + ⇒ '(2 3 4 5) + (-slice '(1 2 3 4 5) 0 3) + ⇒ '(1 2 3) + (-slice '(1 2 3 4 5 6 7 8 9) 1 -1 2) + ⇒ '(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. + + See also: ‘-take-last’ (*note -take-last::) + + (-take 3 '(1 2 3 4 5)) + ⇒ '(1 2 3) + (-take 17 '(1 2 3 4 5)) + ⇒ '(1 2 3 4 5) + + -- Function: -take-last (n list) + Return the last N items of LIST in order. + + See also: ‘-take’ (*note -take::) + + (-take-last 3 '(1 2 3 4 5)) + ⇒ '(3 4 5) + (-take-last 17 '(1 2 3 4 5)) + ⇒ '(1 2 3 4 5) + (-take-last 1 '(1 2 3 4 5)) + ⇒ '(5) + + -- Function: -drop (n list) + Return the tail of LIST without the first N items. + + 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)) + ⇒ '() + + -- Function: -drop-last (n list) + Remove the last N items of LIST and return a copy. + + See also: ‘-drop’ (*note -drop::) + + (-drop-last 3 '(1 2 3 4 5)) + ⇒ '(1 2) + (-drop-last 17 '(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-while 'even? '(1 2 3 4)) + ⇒ '() + (-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-while 'even? '(1 2 3 4)) + ⇒ '(1 2 3 4) + (-drop-while 'even? '(2 4 5 6)) + ⇒ '(5 6) + (--drop-while (< it 4) '(1 2 3 4 3 2 1)) + ⇒ '(4 3 2 1) + + -- Function: -select-by-indices (indices list) + Return a list whose elements are elements from LIST selected as + ‘(nth i list)‘ for all i from INDICES. + + (-select-by-indices '(4 10 2 3 6) '("v" "e" "l" "o" "c" "i" "r" "a" "p" "t" "o" "r")) + ⇒ '("c" "o" "l" "o" "r") + (-select-by-indices '(2 1 0) '("a" "b" "c")) + ⇒ '("c" "b" "a") + (-select-by-indices '(0 1 2 0 1 3 3 1) '("f" "a" "r" "l")) + ⇒ '("f" "a" "r" "f" "a" "l" "l" "a") + + -- Function: -select-columns (columns table) + Select COLUMNS from TABLE. + + TABLE is a list of lists where each element represents one row. It + is assumed each row has the same length. + + Each row is transformed such that only the specified COLUMNS are + selected. + + See also: ‘-select-column’ (*note -select-column::), + ‘-select-by-indices’ (*note -select-by-indices::) + + (-select-columns '(0 2) '((1 2 3) (a b c) (:a :b :c))) + ⇒ '((1 3) (a c) (:a :c)) + (-select-columns '(1) '((1 2 3) (a b c) (:a :b :c))) + ⇒ '((2) (b) (:b)) + (-select-columns nil '((1 2 3) (a b c) (:a :b :c))) + ⇒ '(nil nil nil) + + -- Function: -select-column (column table) + Select COLUMN from TABLE. + + TABLE is a list of lists where each element represents one row. It + is assumed each row has the same length. + + The single selected column is returned as a list. + + See also: ‘-select-columns’ (*note -select-columns::), + ‘-select-by-indices’ (*note -select-by-indices::) + + (-select-column 1 '((1 2 3) (a b c) (:a :b :c))) + ⇒ '(2 b :b) + + +File: dash.info, Node: List to list, Next: Reductions, Prev: Sublist selection, Up: Functions + +2.3 List to list +================ + +Functions returning a modified copy of the input list. + + -- Function: -keep (fn list) + Return a new list of the non-nil results of applying FN to the + items in LIST. + + If you want to select the original items satisfying a predicate use + ‘-filter’ (*note -filter::). + + (-keep 'cdr '((1 2 3) (4 5) (6))) + ⇒ '((2 3) (5)) + (-keep (lambda (num) (when (> num 3) (* 10 num))) '(1 2 3 4 5 6)) + ⇒ '(40 50 60) + (--keep (when (> it 3) (* 10 it)) '(1 2 3 4 5 6)) + ⇒ '(40 50 60) + + -- Function: -concat (&rest lists) + Return a new list with the concatenation of the elements in the + supplied LISTS. + + (-concat '(1)) + ⇒ '(1) + (-concat '(1) '(2)) + ⇒ '(1 2) + (-concat '(1) '(2 3) '(4)) + ⇒ '(1 2 3 4) + + -- Function: -flatten (l) + Take a nested list L and return its contents as a single, flat + list. + + Note that because ‘nil’ represents a list of zero elements (an + empty list), any mention of nil in L will disappear after + flattening. If you need to preserve nils, consider ‘-flatten-n’ + (*note -flatten-n::) or map them to some unique symbol and then map + them back. + + Conses of two atoms are considered "terminals", that is, they + aren’t flattened further. + + See also: ‘-flatten-n’ (*note -flatten-n::) + + (-flatten '((1))) + ⇒ '(1) + (-flatten '((1 (2 3) (((4 (5))))))) + ⇒ '(1 2 3 4 5) + (-flatten '(1 2 (3 . 4))) + ⇒ '(1 2 (3 . 4)) + + -- Function: -flatten-n (num list) + Flatten NUM levels of a nested LIST. + + See also: ‘-flatten’ (*note -flatten::) + + (-flatten-n 1 '((1 2) ((3 4) ((5 6))))) + ⇒ '(1 2 (3 4) ((5 6))) + (-flatten-n 2 '((1 2) ((3 4) ((5 6))))) + ⇒ '(1 2 3 4 (5 6)) + (-flatten-n 3 '((1 2) ((3 4) ((5 6))))) + ⇒ '(1 2 3 4 5 6) + + -- Function: -replace (old new list) + Replace all OLD items in LIST with NEW. + + Elements are compared using ‘equal’. + + See also: ‘-replace-at’ (*note -replace-at::) + + (-replace 1 "1" '(1 2 3 4 3 2 1)) + ⇒ '("1" 2 3 4 3 2 "1") + (-replace "foo" "bar" '("a" "nice" "foo" "sentence" "about" "foo")) + ⇒ '("a" "nice" "bar" "sentence" "about" "bar") + (-replace 1 2 nil) + ⇒ nil + + -- Function: -replace-first (old new list) + Replace the first occurence of OLD with NEW in LIST. + + Elements are compared using ‘equal’. + + See also: ‘-map-first’ (*note -map-first::) + + (-replace-first 1 "1" '(1 2 3 4 3 2 1)) + ⇒ '("1" 2 3 4 3 2 1) + (-replace-first "foo" "bar" '("a" "nice" "foo" "sentence" "about" "foo")) + ⇒ '("a" "nice" "bar" "sentence" "about" "foo") + (-replace-first 1 2 nil) + ⇒ nil + + -- Function: -replace-last (old new list) + Replace the last occurence of OLD with NEW in LIST. + + Elements are compared using ‘equal’. + + See also: ‘-map-last’ (*note -map-last::) + + (-replace-last 1 "1" '(1 2 3 4 3 2 1)) + ⇒ '(1 2 3 4 3 2 "1") + (-replace-last "foo" "bar" '("a" "nice" "foo" "sentence" "about" "foo")) + ⇒ '("a" "nice" "foo" "sentence" "about" "bar") + (-replace-last 1 2 nil) + ⇒ nil + + -- Function: -insert-at (n x list) + Return a list with X inserted into LIST at position N. + + See also: ‘-splice’ (*note -splice::), ‘-splice-list’ (*note + -splice-list::) + + (-insert-at 1 'x '(a b c)) + ⇒ '(a x b c) + (-insert-at 12 'x '(a b c)) + ⇒ '(a b c x) + + -- Function: -replace-at (n x list) + Return a list with element at Nth position in LIST replaced with X. + + See also: ‘-replace’ (*note -replace::) + + (-replace-at 0 9 '(0 1 2 3 4 5)) + ⇒ '(9 1 2 3 4 5) + (-replace-at 1 9 '(0 1 2 3 4 5)) + ⇒ '(0 9 2 3 4 5) + (-replace-at 4 9 '(0 1 2 3 4 5)) + ⇒ '(0 1 2 3 9 5) + + -- Function: -update-at (n func list) + Return a list with element at Nth position in LIST replaced with + ‘(func (nth n list))‘. + + See also: ‘-map-when’ (*note -map-when::) + + (-update-at 0 (lambda (x) (+ x 9)) '(0 1 2 3 4 5)) + ⇒ '(9 1 2 3 4 5) + (-update-at 1 (lambda (x) (+ x 8)) '(0 1 2 3 4 5)) + ⇒ '(0 9 2 3 4 5) + (--update-at 2 (length it) '("foo" "bar" "baz" "quux")) + ⇒ '("foo" "bar" 3 "quux") + + -- Function: -remove-at (n list) + Return a list with element at Nth position in LIST removed. + + See also: ‘-remove-at-indices’ (*note -remove-at-indices::), + ‘-remove’ (*note -remove::) + + (-remove-at 0 '("0" "1" "2" "3" "4" "5")) + ⇒ '("1" "2" "3" "4" "5") + (-remove-at 1 '("0" "1" "2" "3" "4" "5")) + ⇒ '("0" "2" "3" "4" "5") + (-remove-at 2 '("0" "1" "2" "3" "4" "5")) + ⇒ '("0" "1" "3" "4" "5") + + -- Function: -remove-at-indices (indices list) + Return a list whose elements are elements from LIST without + elements selected as ‘(nth i list)‘ for all i from INDICES. + + See also: ‘-remove-at’ (*note -remove-at::), ‘-remove’ (*note + -remove::) + + (-remove-at-indices '(0) '("0" "1" "2" "3" "4" "5")) + ⇒ '("1" "2" "3" "4" "5") + (-remove-at-indices '(0 2 4) '("0" "1" "2" "3" "4" "5")) + ⇒ '("1" "3" "5") + (-remove-at-indices '(0 5) '("0" "1" "2" "3" "4" "5")) + ⇒ '("1" "2" "3" "4") + + +File: dash.info, Node: Reductions, Next: Unfolding, Prev: List to list, Up: Functions + +2.4 Reductions +============== + +Functions reducing lists into single value. + + -- Function: -reduce-from (fn initial-value list) + Return the result of applying FN to INITIAL-VALUE and the first + item in LIST, then applying FN to that result and the 2nd item, + etc. If LIST contains no items, return INITIAL-VALUE and do not + call FN. + + In the anaphoric form ‘--reduce-from’, the accumulated value is + exposed as symbol ‘acc’. + + See also: ‘-reduce’ (*note -reduce::), ‘-reduce-r’ (*note + -reduce-r::) + + (-reduce-from '- 10 '(1 2 3)) + ⇒ 4 + (-reduce-from (lambda (memo item) (format "(%s - %d)" memo item)) "10" '(1 2 3)) + ⇒ "(((10 - 1) - 2) - 3)" + (--reduce-from (concat acc " " it) "START" '("a" "b" "c")) + ⇒ "START a b c" + + -- Function: -reduce-r-from (fn initial-value list) + Replace conses with FN, nil with INITIAL-VALUE and evaluate the + resulting expression. If LIST is empty, INITIAL-VALUE is returned + and FN is not called. + + Note: this function works the same as ‘-reduce-from’ (*note + -reduce-from::) but the operation associates from right instead of + from left. + + See also: ‘-reduce-r’ (*note -reduce-r::), ‘-reduce’ (*note + -reduce::) + + (-reduce-r-from '- 10 '(1 2 3)) + ⇒ -8 + (-reduce-r-from (lambda (item memo) (format "(%d - %s)" item memo)) "10" '(1 2 3)) + ⇒ "(1 - (2 - (3 - 10)))" + (--reduce-r-from (concat it " " acc) "END" '("a" "b" "c")) + ⇒ "a b c END" + + -- Function: -reduce (fn list) + Return the result of applying FN to the first 2 items in LIST, then + applying FN to that result and the 3rd item, etc. If LIST contains + no items, return the result of calling FN with no arguments. If + LIST contains a single item, return that item and do not call FN. + + In the anaphoric form ‘--reduce’, the accumulated value is exposed + as symbol ‘acc’. + + See also: ‘-reduce-from’ (*note -reduce-from::), ‘-reduce-r’ (*note + -reduce-r::) + + (-reduce '- '(1 2 3 4)) + ⇒ -8 + (-reduce 'list '(1 2 3 4)) + ⇒ '(((1 2) 3) 4) + (--reduce (format "%s-%d" acc it) '(1 2 3)) + ⇒ "1-2-3" + + -- Function: -reduce-r (fn list) + Replace conses with FN and evaluate the resulting expression. The + final nil is ignored. If LIST contains no items, return the result + of calling FN with no arguments. If LIST contains a single item, + return that item and do not call FN. + + The first argument of FN is the new item, the second is the + accumulated value. + + Note: this function works the same as ‘-reduce’ (*note -reduce::) + but the operation associates from right instead of from left. + + See also: ‘-reduce-r-from’ (*note -reduce-r-from::), ‘-reduce’ + (*note -reduce::) + + (-reduce-r '- '(1 2 3 4)) + ⇒ -2 + (-reduce-r (lambda (item memo) (format "%s-%d" memo item)) '(1 2 3)) + ⇒ "3-2-1" + (--reduce-r (format "%s-%d" acc it) '(1 2 3)) + ⇒ "3-2-1" + + -- Function: -reductions-from (fn init list) + Return a list of the intermediate values of the reduction. + + See ‘-reduce-from’ (*note -reduce-from::) for explanation of the + arguments. + + See also: ‘-reductions’ (*note -reductions::), ‘-reductions-r’ + (*note -reductions-r::), ‘-reduce-r’ (*note -reduce-r::) + + (-reductions-from (lambda (a i) (format "(%s FN %d)" a i)) "INIT" '(1 2 3 4)) + ⇒ '("INIT" "(INIT FN 1)" "((INIT FN 1) FN 2)" "(((INIT FN 1) FN 2) FN 3)" "((((INIT FN 1) FN 2) FN 3) FN 4)") + (-reductions-from 'max 0 '(2 1 4 3)) + ⇒ '(0 2 2 4 4) + (-reductions-from '* 1 '(1 2 3 4)) + ⇒ '(1 1 2 6 24) + + -- Function: -reductions-r-from (fn init list) + Return a list of the intermediate values of the reduction. + + See ‘-reduce-r-from’ (*note -reduce-r-from::) for explanation of + the arguments. + + See also: ‘-reductions-r’ (*note -reductions-r::), ‘-reductions’ + (*note -reductions::), ‘-reduce’ (*note -reduce::) + + (-reductions-r-from (lambda (i a) (format "(%d FN %s)" i a)) "INIT" '(1 2 3 4)) + ⇒ '("(1 FN (2 FN (3 FN (4 FN INIT))))" "(2 FN (3 FN (4 FN INIT)))" "(3 FN (4 FN INIT))" "(4 FN INIT)" "INIT") + (-reductions-r-from 'max 0 '(2 1 4 3)) + ⇒ '(4 4 4 3 0) + (-reductions-r-from '* 1 '(1 2 3 4)) + ⇒ '(24 24 12 4 1) + + -- Function: -reductions (fn list) + Return a list of the intermediate values of the reduction. + + See ‘-reduce’ (*note -reduce::) for explanation of the arguments. + + See also: ‘-reductions-from’ (*note -reductions-from::), + ‘-reductions-r’ (*note -reductions-r::), ‘-reduce-r’ (*note + -reduce-r::) + + (-reductions (lambda (a i) (format "(%s FN %d)" a i)) '(1 2 3 4)) + ⇒ '(1 "(1 FN 2)" "((1 FN 2) FN 3)" "(((1 FN 2) FN 3) FN 4)") + (-reductions '+ '(1 2 3 4)) + ⇒ '(1 3 6 10) + (-reductions '* '(1 2 3 4)) + ⇒ '(1 2 6 24) + + -- Function: -reductions-r (fn list) + Return a list of the intermediate values of the reduction. + + See ‘-reduce-r’ (*note -reduce-r::) for explanation of the + arguments. + + See also: ‘-reductions-r-from’ (*note -reductions-r-from::), + ‘-reductions’ (*note -reductions::), ‘-reduce’ (*note -reduce::) + + (-reductions-r (lambda (i a) (format "(%d FN %s)" i a)) '(1 2 3 4)) + ⇒ '("(1 FN (2 FN (3 FN 4)))" "(2 FN (3 FN 4))" "(3 FN 4)" 4) + (-reductions-r '+ '(1 2 3 4)) + ⇒ '(10 9 7 4) + (-reductions-r '* '(1 2 3 4)) + ⇒ '(24 24 12 4) + + -- Function: -count (pred list) + Counts the number of items in LIST where (PRED item) is non-nil. + + (-count 'even? '(1 2 3 4 5)) + ⇒ 2 + (--count (< it 4) '(1 2 3 4)) + ⇒ 3 + + -- Function: -sum (list) + Return the sum of LIST. + + (-sum '()) + ⇒ 0 + (-sum '(1)) + ⇒ 1 + (-sum '(1 2 3 4)) + ⇒ 10 + + -- Function: -running-sum (list) + Return a list with running sums of items in LIST. + + LIST must be non-empty. + + (-running-sum '(1 2 3 4)) + ⇒ '(1 3 6 10) + (-running-sum '(1)) + ⇒ '(1) + (-running-sum '()) + ⇒ error + + -- Function: -product (list) + Return the product of LIST. + + (-product '()) + ⇒ 1 + (-product '(1)) + ⇒ 1 + (-product '(1 2 3 4)) + ⇒ 24 + + -- Function: -running-product (list) + Return a list with running products of items in LIST. + + LIST must be non-empty. + + (-running-product '(1 2 3 4)) + ⇒ '(1 2 6 24) + (-running-product '(1)) + ⇒ '(1) + (-running-product '()) + ⇒ error + + -- Function: -inits (list) + Return all prefixes of LIST. + + (-inits '(1 2 3 4)) + ⇒ '(nil (1) (1 2) (1 2 3) (1 2 3 4)) + (-inits nil) + ⇒ '(nil) + (-inits '(1)) + ⇒ '(nil (1)) + + -- Function: -tails (list) + Return all suffixes of LIST + + (-tails '(1 2 3 4)) + ⇒ '((1 2 3 4) (2 3 4) (3 4) (4) nil) + (-tails nil) + ⇒ '(nil) + (-tails '(1)) + ⇒ '((1) nil) + + -- Function: -common-prefix (&rest lists) + Return the longest common prefix of LISTS. + + (-common-prefix '(1)) + ⇒ '(1) + (-common-prefix '(1 2) '(3 4) '(1 2)) + ⇒ nil + (-common-prefix '(1 2) '(1 2 3) '(1 2 3 4)) + ⇒ '(1 2) + + -- Function: -common-suffix (&rest lists) + Return the longest common suffix of LISTS. + + (-common-suffix '(1)) + ⇒ '(1) + (-common-suffix '(1 2) '(3 4) '(1 2)) + ⇒ nil + (-common-suffix '(1 2 3 4) '(2 3 4) '(3 4)) + ⇒ '(3 4) + + -- Function: -min (list) + Return the smallest value from LIST of numbers or markers. + + (-min '(0)) + ⇒ 0 + (-min '(3 2 1)) + ⇒ 1 + (-min '(1 2 3)) + ⇒ 1 + + -- Function: -min-by (comparator list) + Take a comparison function COMPARATOR and a LIST and return the + least element of the list by the comparison function. + + See also combinator ‘-on’ (*note -on::) which can transform the + values before comparing them. + + (-min-by '> '(4 3 6 1)) + ⇒ 1 + (--min-by (> (car it) (car other)) '((1 2 3) (2) (3 2))) + ⇒ '(1 2 3) + (--min-by (> (length it) (length other)) '((1 2 3) (2) (3 2))) + ⇒ '(2) + + -- Function: -max (list) + Return the largest value from LIST of numbers or markers. + + (-max '(0)) + ⇒ 0 + (-max '(3 2 1)) + ⇒ 3 + (-max '(1 2 3)) + ⇒ 3 + + -- Function: -max-by (comparator list) + Take a comparison function COMPARATOR and a LIST and return the + greatest element of the list by the comparison function. + + See also combinator ‘-on’ (*note -on::) which can transform the + values before comparing them. + + (-max-by '> '(4 3 6 1)) + ⇒ 6 + (--max-by (> (car it) (car other)) '((1 2 3) (2) (3 2))) + ⇒ '(3 2) + (--max-by (> (length it) (length other)) '((1 2 3) (2) (3 2))) + ⇒ '(1 2 3) + + +File: dash.info, Node: Unfolding, Next: Predicates, Prev: Reductions, Up: Functions + +2.5 Unfolding +============= + +Operations dual to reductions, building lists from seed value rather +than consuming a list to produce a single value. + + -- Function: -iterate (fun init n) + Return a list of iterated applications of FUN to INIT. + + This means a list of form: + + (init (fun init) (fun (fun init)) ...) + + N is the length of the returned list. + + (-iterate '1+ 1 10) + ⇒ '(1 2 3 4 5 6 7 8 9 10) + (-iterate (lambda (x) (+ x x)) 2 5) + ⇒ '(2 4 8 16 32) + (--iterate (* it it) 2 5) + ⇒ '(2 4 16 256 65536) + + -- Function: -unfold (fun seed) + Build a list from SEED using FUN. + + This is "dual" operation to ‘-reduce-r’ (*note -reduce-r::): while + -reduce-r consumes a list to produce a single value, ‘-unfold’ + (*note -unfold::) takes a seed value and builds a (potentially + infinite!) list. + + FUN should return ‘nil’ to stop the generating process, or a cons + (A . B), where A will be prepended to the result and B is the new + seed. + + (-unfold (lambda (x) (unless (= x 0) (cons x (1- x)))) 10) + ⇒ '(10 9 8 7 6 5 4 3 2 1) + (--unfold (when it (cons it (cdr it))) '(1 2 3 4)) + ⇒ '((1 2 3 4) (2 3 4) (3 4) (4)) + (--unfold (when it (cons it (butlast it))) '(1 2 3 4)) + ⇒ '((1 2 3 4) (1 2 3) (1 2) (1)) + + +File: dash.info, Node: Predicates, Next: Partitioning, Prev: Unfolding, Up: Functions + +2.6 Predicates +============== + + -- Function: -any? (pred list) + Return t if (PRED x) is non-nil for any x in LIST, else nil. + + Alias: ‘-any-p’, ‘-some?’, ‘-some-p’ + + (-any? 'even? '(1 2 3)) + ⇒ t + (-any? 'even? '(1 3 5)) + ⇒ nil + (-any? 'null '(1 3 5)) + ⇒ nil + + -- Function: -all? (pred list) + Return t if (PRED x) is non-nil for all x in LIST, else nil. + + Alias: ‘-all-p’, ‘-every?’, ‘-every-p’ + + (-all? 'even? '(1 2 3)) + ⇒ nil + (-all? 'even? '(2 4 6)) + ⇒ t + (--all? (= 0 (% it 2)) '(2 4 6)) + ⇒ t + + -- Function: -none? (pred list) + Return t if (PRED x) is nil for all x in LIST, else nil. + + Alias: ‘-none-p’ + + (-none? 'even? '(1 2 3)) + ⇒ nil + (-none? 'even? '(1 3 5)) + ⇒ t + (--none? (= 0 (% it 2)) '(1 2 3)) + ⇒ nil + + -- Function: -only-some? (pred list) + Return ‘t‘ if at least one item of LIST matches PRED and at least + one item of LIST does not match PRED. Return ‘nil‘ both if all + items match the predicate or if none of the items match the + predicate. + + Alias: ‘-only-some-p’ + + (-only-some? 'even? '(1 2 3)) + ⇒ t + (-only-some? 'even? '(1 3 5)) + ⇒ nil + (-only-some? 'even? '(2 4 6)) + ⇒ nil + + -- Function: -contains? (list element) + Return non-nil if LIST contains ELEMENT. + + The test for equality is done with ‘equal’, or with ‘-compare-fn’ + if that’s non-nil. + + Alias: ‘-contains-p’ + + (-contains? '(1 2 3) 1) + ⇒ t + (-contains? '(1 2 3) 2) + ⇒ t + (-contains? '(1 2 3) 4) + ⇒ nil + + -- Function: -same-items? (list list2) + Return true if LIST and LIST2 has the same items. + + The order of the elements in the lists does not matter. + + Alias: ‘-same-items-p’ + + (-same-items? '(1 2 3) '(1 2 3)) + ⇒ t + (-same-items? '(1 2 3) '(3 2 1)) + ⇒ t + (-same-items? '(1 2 3) '(1 2 3 4)) + ⇒ nil + + -- Function: -is-prefix? (prefix list) + Return non-nil if PREFIX is prefix of LIST. + + Alias: ‘-is-prefix-p’ + + (-is-prefix? '(1 2 3) '(1 2 3 4 5)) + ⇒ t + (-is-prefix? '(1 2 3 4 5) '(1 2 3)) + ⇒ nil + (-is-prefix? '(1 3) '(1 2 3 4 5)) + ⇒ nil + + -- Function: -is-suffix? (suffix list) + Return non-nil if SUFFIX is suffix of LIST. + + Alias: ‘-is-suffix-p’ + + (-is-suffix? '(3 4 5) '(1 2 3 4 5)) + ⇒ t + (-is-suffix? '(1 2 3 4 5) '(3 4 5)) + ⇒ nil + (-is-suffix? '(3 5) '(1 2 3 4 5)) + ⇒ nil + + -- Function: -is-infix? (infix list) + Return non-nil if INFIX is infix of LIST. + + This operation runs in O(n^2) time + + Alias: ‘-is-infix-p’ + + (-is-infix? '(1 2 3) '(1 2 3 4 5)) + ⇒ t + (-is-infix? '(2 3 4) '(1 2 3 4 5)) + ⇒ t + (-is-infix? '(3 4 5) '(1 2 3 4 5)) + ⇒ t + + +File: dash.info, Node: Partitioning, Next: Indexing, Prev: Predicates, Up: Functions + +2.7 Partitioning +================ + +Functions partitioning the input list into a list of lists. + + -- Function: -split-at (n list) + Return a list of ((-take N LIST) (-drop N LIST)), in no more than + one pass through the list. + + (-split-at 3 '(1 2 3 4 5)) + ⇒ '((1 2 3) (4 5)) + (-split-at 17 '(1 2 3 4 5)) + ⇒ '((1 2 3 4 5) nil) + + -- Function: -split-with (pred list) + Return a list of ((-take-while PRED LIST) (-drop-while PRED LIST)), + in no more than one pass through the list. + + (-split-with 'even? '(1 2 3 4)) + ⇒ '(nil (1 2 3 4)) + (-split-with 'even? '(2 4 5 6)) + ⇒ '((2 4) (5 6)) + (--split-with (< it 4) '(1 2 3 4 3 2 1)) + ⇒ '((1 2 3) (4 3 2 1)) + + -- Macro: -split-on (item list) + Split the LIST each time ITEM is found. + + Unlike ‘-partition-by’ (*note -partition-by::), the ITEM is + discarded from the results. Empty lists are also removed from the + result. + + Comparison is done by ‘equal’. + + See also ‘-split-when’ (*note -split-when::) + + (-split-on '| '(Nil | Leaf a | Node [Tree a])) + ⇒ '((Nil) (Leaf a) (Node [Tree a])) + (-split-on ':endgroup '("a" "b" :endgroup "c" :endgroup "d" "e")) + ⇒ '(("a" "b") ("c") ("d" "e")) + (-split-on ':endgroup '("a" "b" :endgroup :endgroup "d" "e")) + ⇒ '(("a" "b") ("d" "e")) + + -- Function: -split-when (fn list) + Split the LIST on each element where FN returns non-nil. + + Unlike ‘-partition-by’ (*note -partition-by::), the "matched" + element is discarded from the results. Empty lists are also + removed from the result. + + This function can be thought of as a generalization of + ‘split-string’. + + (-split-when 'even? '(1 2 3 4 5 6)) + ⇒ '((1) (3) (5)) + (-split-when 'even? '(1 2 3 4 6 8 9)) + ⇒ '((1) (3) (9)) + (--split-when (memq it '(&optional &rest)) '(a b &optional c d &rest args)) + ⇒ '((a b) (c d) (args)) + + -- Function: -separate (pred list) + Return a list of ((-filter PRED LIST) (-remove PRED LIST)), in one + pass through the list. + + (-separate (lambda (num) (= 0 (% num 2))) '(1 2 3 4 5 6 7)) + ⇒ '((2 4 6) (1 3 5 7)) + (--separate (< it 5) '(3 7 5 9 3 2 1 4 6)) + ⇒ '((3 3 2 1 4) (7 5 9 6)) + (-separate 'cdr '((1 2) (1) (1 2 3) (4))) + ⇒ '(((1 2) (1 2 3)) ((1) (4))) + + -- Function: -partition (n list) + Return a new list with the items in LIST grouped into N-sized + sublists. If there are not enough items to make the last group + N-sized, those items are discarded. + + (-partition 2 '(1 2 3 4 5 6)) + ⇒ '((1 2) (3 4) (5 6)) + (-partition 2 '(1 2 3 4 5 6 7)) + ⇒ '((1 2) (3 4) (5 6)) + (-partition 3 '(1 2 3 4 5 6 7)) + ⇒ '((1 2 3) (4 5 6)) + + -- Function: -partition-all (n list) + Return a new list with the items in LIST grouped into N-sized + sublists. The last group may contain less than N items. + + (-partition-all 2 '(1 2 3 4 5 6)) + ⇒ '((1 2) (3 4) (5 6)) + (-partition-all 2 '(1 2 3 4 5 6 7)) + ⇒ '((1 2) (3 4) (5 6) (7)) + (-partition-all 3 '(1 2 3 4 5 6 7)) + ⇒ '((1 2 3) (4 5 6) (7)) + + -- Function: -partition-in-steps (n step list) + Return a new list with the items in LIST grouped into N-sized + sublists at offsets STEP apart. If there are not enough items to + make the last group N-sized, those items are discarded. + + (-partition-in-steps 2 1 '(1 2 3 4)) + ⇒ '((1 2) (2 3) (3 4)) + (-partition-in-steps 3 2 '(1 2 3 4)) + ⇒ '((1 2 3)) + (-partition-in-steps 3 2 '(1 2 3 4 5)) + ⇒ '((1 2 3) (3 4 5)) + + -- Function: -partition-all-in-steps (n step list) + Return a new list with the items in LIST grouped into N-sized + sublists at offsets STEP apart. The last groups may contain less + than N items. + + (-partition-all-in-steps 2 1 '(1 2 3 4)) + ⇒ '((1 2) (2 3) (3 4) (4)) + (-partition-all-in-steps 3 2 '(1 2 3 4)) + ⇒ '((1 2 3) (3 4)) + (-partition-all-in-steps 3 2 '(1 2 3 4 5)) + ⇒ '((1 2 3) (3 4 5) (5)) + + -- Function: -partition-by (fn list) + Apply FN to each item in LIST, splitting it each time FN returns a + new value. + + (-partition-by 'even? '()) + ⇒ '() + (-partition-by 'even? '(1 1 2 2 2 3 4 6 8)) + ⇒ '((1 1) (2 2 2) (3) (4 6 8)) + (--partition-by (< it 3) '(1 2 3 4 3 2 1)) + ⇒ '((1 2) (3 4 3) (2 1)) + + -- Function: -partition-by-header (fn list) + Apply FN to the first item in LIST. That is the header value. + Apply FN to each item in LIST, splitting it each time FN returns + the header value, but only after seeing at least one other value + (the body). + + (--partition-by-header (= it 1) '(1 2 3 1 2 1 2 3 4)) + ⇒ '((1 2 3) (1 2) (1 2 3 4)) + (--partition-by-header (> it 0) '(1 2 0 1 0 1 2 3 0)) + ⇒ '((1 2 0) (1 0) (1 2 3 0)) + (-partition-by-header 'even? '(2 1 1 1 4 1 3 5 6 6 1)) + ⇒ '((2 1 1 1) (4 1 3 5) (6 6 1)) + + -- Function: -partition-after-pred (pred list) + Partition directly after each time PRED is true on an element of + LIST. + + (-partition-after-pred (function oddp) '()) + ⇒ '() + (-partition-after-pred (function oddp) '(1)) + ⇒ '((1)) + (-partition-after-pred (function oddp) '(0 1)) + ⇒ '((0 1)) + + -- Function: -partition-before-pred (pred list) + Partition directly before each time PRED is true on an element of + LIST. + + (-partition-before-pred (function oddp) '()) + ⇒ '() + (-partition-before-pred (function oddp) '(1)) + ⇒ '((1)) + (-partition-before-pred (function oddp) '(0 1)) + ⇒ '((0) (1)) + + -- Function: -partition-before-item (item list) + Partition directly before each time ITEM appears in LIST. + + (-partition-before-item 3 '()) + ⇒ '() + (-partition-before-item 3 '(1)) + ⇒ '((1)) + (-partition-before-item 3 '(3)) + ⇒ '((3)) + + -- Function: -partition-after-item (item list) + Partition directly after each time ITEM appears in LIST. + + (-partition-after-item 3 '()) + ⇒ '() + (-partition-after-item 3 '(1)) + ⇒ '((1)) + (-partition-after-item 3 '(3)) + ⇒ '((3)) + + -- Function: -group-by (fn list) + Separate LIST into an alist whose keys are FN applied to the + elements of LIST. Keys are compared by ‘equal’. + + (-group-by 'even? '()) + ⇒ '() + (-group-by 'even? '(1 1 2 2 2 3 4 6 8)) + ⇒ '((nil 1 1 3) (t 2 2 2 4 6 8)) + (--group-by (car (split-string it "/")) '("a/b" "c/d" "a/e")) + ⇒ '(("a" "a/b" "a/e") ("c" "c/d")) + + +File: dash.info, Node: Indexing, Next: Set operations, Prev: Partitioning, Up: Functions + +2.8 Indexing +============ + +Return indices of elements based on predicates, sort elements by indices +etc. + + -- Function: -elem-index (elem list) + Return the index of the first element in the given LIST which is + equal to the query element ELEM, or nil if there is no such + element. + + (-elem-index 2 '(6 7 8 2 3 4)) + ⇒ 3 + (-elem-index "bar" '("foo" "bar" "baz")) + ⇒ 1 + (-elem-index '(1 2) '((3) (5 6) (1 2) nil)) + ⇒ 2 + + -- Function: -elem-indices (elem list) + Return the indices of all elements in LIST equal to the query + element ELEM, in ascending order. + + (-elem-indices 2 '(6 7 8 2 3 4 2 1)) + ⇒ '(3 6) + (-elem-indices "bar" '("foo" "bar" "baz")) + ⇒ '(1) + (-elem-indices '(1 2) '((3) (1 2) (5 6) (1 2) nil)) + ⇒ '(1 3) + + -- Function: -find-index (pred list) + Take a predicate PRED and a LIST and return the index of the first + element in the list satisfying the predicate, or nil if there is no + such element. + + See also ‘-first’ (*note -first::). + + (-find-index 'even? '(2 4 1 6 3 3 5 8)) + ⇒ 0 + (--find-index (< 5 it) '(2 4 1 6 3 3 5 8)) + ⇒ 3 + (-find-index (-partial 'string-lessp "baz") '("bar" "foo" "baz")) + ⇒ 1 + + -- Function: -find-last-index (pred list) + Take a predicate PRED and a LIST and return the index of the last + element in the list satisfying the predicate, or nil if there is no + such element. + + See also ‘-last’ (*note -last::). + + (-find-last-index 'even? '(2 4 1 6 3 3 5 8)) + ⇒ 7 + (--find-last-index (< 5 it) '(2 7 1 6 3 8 5 2)) + ⇒ 5 + (-find-last-index (-partial 'string-lessp "baz") '("q" "foo" "baz")) + ⇒ 1 + + -- Function: -find-indices (pred list) + Return the indices of all elements in LIST satisfying the predicate + PRED, in ascending order. + + (-find-indices 'even? '(2 4 1 6 3 3 5 8)) + ⇒ '(0 1 3 7) + (--find-indices (< 5 it) '(2 4 1 6 3 3 5 8)) + ⇒ '(3 7) + (-find-indices (-partial 'string-lessp "baz") '("bar" "foo" "baz")) + ⇒ '(1) + + -- Function: -grade-up (comparator list) + Grade elements of LIST using COMPARATOR relation, yielding a + permutation vector such that applying this permutation to LIST + sorts it in ascending order. + + (-grade-up '< '(3 1 4 2 1 3 3)) + ⇒ '(1 4 3 0 5 6 2) + (let ((l '(3 1 4 2 1 3 3))) (-select-by-indices (-grade-up '< l) l)) + ⇒ '(1 1 2 3 3 3 4) + + -- Function: -grade-down (comparator list) + Grade elements of LIST using COMPARATOR relation, yielding a + permutation vector such that applying this permutation to LIST + sorts it in descending order. + + (-grade-down '< '(3 1 4 2 1 3 3)) + ⇒ '(2 0 5 6 3 1 4) + (let ((l '(3 1 4 2 1 3 3))) (-select-by-indices (-grade-down '< l) l)) + ⇒ '(4 3 3 3 2 1 1) + + +File: dash.info, Node: Set operations, Next: Other list operations, Prev: Indexing, Up: Functions + +2.9 Set operations +================== + +Operations pretending lists are sets. + + -- Function: -union (list list2) + Return a new list containing the elements of LIST and elements of + LIST2 that are not in LIST. The test for equality is done with + ‘equal’, or with ‘-compare-fn’ if that’s non-nil. + + (-union '(1 2 3) '(3 4 5)) + ⇒ '(1 2 3 4 5) + (-union '(1 2 3 4) '()) + ⇒ '(1 2 3 4) + (-union '(1 1 2 2) '(3 2 1)) + ⇒ '(1 1 2 2 3) + + -- Function: -difference (list list2) + Return a new list with only the members of LIST that are not in + LIST2. The test for equality is done with ‘equal’, or with + ‘-compare-fn’ if that’s non-nil. + + (-difference '() '()) + ⇒ '() + (-difference '(1 2 3) '(4 5 6)) + ⇒ '(1 2 3) + (-difference '(1 2 3 4) '(3 4 5 6)) + ⇒ '(1 2) + + -- Function: -intersection (list list2) + Return a new list containing only the elements that are members of + both LIST and LIST2. The test for equality is done with ‘equal’, + or with ‘-compare-fn’ if that’s non-nil. + + (-intersection '() '()) + ⇒ '() + (-intersection '(1 2 3) '(4 5 6)) + ⇒ '() + (-intersection '(1 2 3 4) '(3 4 5 6)) + ⇒ '(3 4) + + -- Function: -powerset (list) + Return the power set of LIST. + + (-powerset '()) + ⇒ '(nil) + (-powerset '(x y z)) + ⇒ '((x y z) (x y) (x z) (x) (y z) (y) (z) nil) + + -- Function: -permutations (list) + Return the permutations of LIST. + + (-permutations '()) + ⇒ '(nil) + (-permutations '(1 2)) + ⇒ '((1 2) (2 1)) + (-permutations '(a b c)) + ⇒ '((a b c) (a c b) (b a c) (b c a) (c a b) (c b a)) + + -- Function: -distinct (list) + Return a new list with all duplicates removed. The test for + equality is done with ‘equal’, or with ‘-compare-fn’ if that’s + non-nil. + + Alias: ‘-uniq’ + + (-distinct '()) + ⇒ '() + (-distinct '(1 2 2 4)) + ⇒ '(1 2 4) + + +File: dash.info, Node: Other list operations, Next: Tree operations, Prev: Set operations, Up: Functions + +2.10 Other list operations +========================== + +Other list functions not fit to be classified elsewhere. + + -- Function: -rotate (n list) + Rotate LIST N places to the right. With N negative, rotate to the + left. The time complexity is O(n). + + (-rotate 3 '(1 2 3 4 5 6 7)) + ⇒ '(5 6 7 1 2 3 4) + (-rotate -3 '(1 2 3 4 5 6 7)) + ⇒ '(4 5 6 7 1 2 3) + (-rotate 16 '(1 2 3 4 5 6 7)) + ⇒ '(6 7 1 2 3 4 5) + + -- Function: -repeat (n x) + Return a list with X repeated N times. Return nil if N is less + than 1. + + (-repeat 3 :a) + ⇒ '(:a :a :a) + (-repeat 1 :a) + ⇒ '(:a) + (-repeat 0 :a) + ⇒ nil + + -- Function: -cons* (&rest args) + Make a new list from the elements of ARGS. + + The last 2 members of ARGS are used as the final cons of the result + so if the final member of ARGS is not a list the result is a dotted + list. + + (-cons* 1 2) + ⇒ '(1 . 2) + (-cons* 1 2 3) + ⇒ '(1 2 . 3) + (-cons* 1) + ⇒ 1 + + -- Function: -snoc (list elem &rest elements) + Append ELEM to the end of the list. + + This is like ‘cons’, but operates on the end of list. + + If ELEMENTS is non nil, append these to the list as well. + + (-snoc '(1 2 3) 4) + ⇒ '(1 2 3 4) + (-snoc '(1 2 3) 4 5 6) + ⇒ '(1 2 3 4 5 6) + (-snoc '(1 2 3) '(4 5 6)) + ⇒ '(1 2 3 (4 5 6)) + + -- Function: -interpose (sep list) + Return a new list of all elements in LIST separated by SEP. + + (-interpose "-" '()) + ⇒ '() + (-interpose "-" '("a")) + ⇒ '("a") + (-interpose "-" '("a" "b" "c")) + ⇒ '("a" "-" "b" "-" "c") + + -- Function: -interleave (&rest lists) + Return a new list of the first item in each list, then the second + etc. + + (-interleave '(1 2) '("a" "b")) + ⇒ '(1 "a" 2 "b") + (-interleave '(1 2) '("a" "b") '("A" "B")) + ⇒ '(1 "a" "A" 2 "b" "B") + (-interleave '(1 2 3) '("a" "b")) + ⇒ '(1 "a" 2 "b") + + -- Function: -zip-with (fn list1 list2) + Zip the two lists LIST1 and LIST2 using a function FN. This + function is applied pairwise taking as first argument element of + LIST1 and as second argument element of LIST2 at corresponding + position. + + The anaphoric form ‘--zip-with’ binds the elements from LIST1 as + symbol ‘it’, and the elements from LIST2 as symbol ‘other’. + + (-zip-with '+ '(1 2 3) '(4 5 6)) + ⇒ '(5 7 9) + (-zip-with 'cons '(1 2 3) '(4 5 6)) + ⇒ '((1 . 4) (2 . 5) (3 . 6)) + (--zip-with (concat it " and " other) '("Batman" "Jekyll") '("Robin" "Hyde")) + ⇒ '("Batman and Robin" "Jekyll and Hyde") + + -- Function: -zip (&rest lists) + Zip LISTS together. Group the head of each list, followed by the + second elements of each list, and so on. The lengths of the + returned groupings are equal to the length of the shortest input + list. + + If two lists are provided as arguments, return the groupings as a + list of cons cells. Otherwise, return the groupings as a list of + lists. + + Please note! This distinction is being removed in an upcoming 3.0 + release of Dash. If you rely on this behavior, use -zip-pair + instead. + + (-zip '(1 2 3) '(4 5 6)) + ⇒ '((1 . 4) (2 . 5) (3 . 6)) + (-zip '(1 2 3) '(4 5 6 7)) + ⇒ '((1 . 4) (2 . 5) (3 . 6)) + (-zip '(1 2 3 4) '(4 5 6)) + ⇒ '((1 . 4) (2 . 5) (3 . 6)) + + -- Function: -zip-fill (fill-value &rest lists) + Zip LISTS, with FILL-VALUE padded onto the shorter lists. The + lengths of the returned groupings are equal to the length of the + longest input list. + + (-zip-fill 0 '(1 2 3 4 5) '(6 7 8 9)) + ⇒ '((1 . 6) (2 . 7) (3 . 8) (4 . 9) (5 . 0)) + + -- Function: -unzip (lists) + Unzip LISTS. + + This works just like ‘-zip’ (*note -zip::) but takes a list of + lists instead of a variable number of arguments, such that + + (-unzip (-zip L1 L2 L3 ...)) + + is identity (given that the lists are the same length). + + See also: ‘-zip’ (*note -zip::) + + (-unzip (-zip '(1 2 3) '(a b c) '("e" "f" "g"))) + ⇒ '((1 2 3) (a b c) ("e" "f" "g")) + (-unzip '((1 2) (3 4) (5 6) (7 8) (9 10))) + ⇒ '((1 3 5 7 9) (2 4 6 8 10)) + + -- Function: -cycle (list) + Return an infinite copy of LIST that will cycle through the + elements and repeat from the beginning. + + (-take 5 (-cycle '(1 2 3))) + ⇒ '(1 2 3 1 2) + (-take 7 (-cycle '(1 "and" 3))) + ⇒ '(1 "and" 3 1 "and" 3 1) + (-zip (-cycle '(1 2 3)) '(1 2)) + ⇒ '((1 . 1) (2 . 2)) + + -- Function: -pad (fill-value &rest lists) + Appends FILL-VALUE to the end of each list in LISTS such that they + will all have the same length. + + (-pad 0 '()) + ⇒ '(nil) + (-pad 0 '(1)) + ⇒ '((1)) + (-pad 0 '(1 2 3) '(4 5)) + ⇒ '((1 2 3) (4 5 0)) + + -- Function: -table (fn &rest lists) + Compute outer product of LISTS using function FN. + + The function FN should have the same arity as the number of + supplied lists. + + The outer product is computed by applying fn to all possible + combinations created by taking one element from each list in order. + The dimension of the result is (length lists). + + See also: ‘-table-flat’ (*note -table-flat::) + + (-table '* '(1 2 3) '(1 2 3)) + ⇒ '((1 2 3) (2 4 6) (3 6 9)) + (-table (lambda (a b) (-sum (-zip-with '* a b))) '((1 2) (3 4)) '((1 3) (2 4))) + ⇒ '((7 15) (10 22)) + (apply '-table 'list (-repeat 3 '(1 2))) + ⇒ '((((1 1 1) (2 1 1)) ((1 2 1) (2 2 1))) (((1 1 2) (2 1 2)) ((1 2 2) (2 2 2)))) + + -- Function: -table-flat (fn &rest lists) + Compute flat outer product of LISTS using function FN. + + The function FN should have the same arity as the number of + supplied lists. + + The outer product is computed by applying fn to all possible + combinations created by taking one element from each list in order. + The results are flattened, ignoring the tensor structure of the + result. This is equivalent to calling: + + (-flatten-n (1- (length lists)) (apply ’-table fn lists)) + + but the implementation here is much more efficient. + + See also: ‘-flatten-n’ (*note -flatten-n::), ‘-table’ (*note + -table::) + + (-table-flat 'list '(1 2 3) '(a b c)) + ⇒ '((1 a) (2 a) (3 a) (1 b) (2 b) (3 b) (1 c) (2 c) (3 c)) + (-table-flat '* '(1 2 3) '(1 2 3)) + ⇒ '(1 2 3 2 4 6 3 6 9) + (apply '-table-flat 'list (-repeat 3 '(1 2))) + ⇒ '((1 1 1) (2 1 1) (1 2 1) (2 2 1) (1 1 2) (2 1 2) (1 2 2) (2 2 2)) + + -- Function: -first (pred list) + Return the first x in LIST where (PRED x) is non-nil, else nil. + + To get the first item in the list no questions asked, use ‘car’. + + Alias: ‘-find’ + + (-first 'even? '(1 2 3)) + ⇒ 2 + (-first 'even? '(1 3 5)) + ⇒ nil + (-first 'null '(1 3 5)) + ⇒ nil + + -- Function: -some (pred list) + Return (PRED x) for the first LIST item where (PRED x) is non-nil, + else nil. + + Alias: ‘-any’ + + (-some 'even? '(1 2 3)) + ⇒ t + (-some 'null '(1 2 3)) + ⇒ nil + (-some 'null '(1 2 nil)) + ⇒ t + + -- Function: -last (pred list) + Return the last x in LIST where (PRED x) is non-nil, else nil. + + (-last 'even? '(1 2 3 4 5 6 3 3 3)) + ⇒ 6 + (-last 'even? '(1 3 7 5 9)) + ⇒ nil + (--last (> (length it) 3) '("a" "looong" "word" "and" "short" "one")) + ⇒ "short" + + -- Function: -first-item (list) + Return the first item of LIST, or nil on an empty list. + + See also: ‘-second-item’ (*note -second-item::), ‘-last-item’ + (*note -last-item::). + + (fn LIST) + + (-first-item '(1 2 3)) + ⇒ 1 + (-first-item nil) + ⇒ nil + (let ((list (list 1 2 3))) (setf (-first-item list) 5) list) + ⇒ '(5 2 3) + + -- Function: -second-item (arg1) + Return the second item of LIST, or nil if LIST is too short. + + See also: ‘-third-item’ (*note -third-item::). + + (fn LIST) + + (-second-item '(1 2 3)) + ⇒ 2 + (-second-item nil) + ⇒ nil + + -- Function: -third-item (arg1) + Return the third item of LIST, or nil if LIST is too short. + + See also: ‘-fourth-item’ (*note -fourth-item::). + + (fn LIST) + + (-third-item '(1 2 3)) + ⇒ 3 + (-third-item nil) + ⇒ nil + + -- Function: -fourth-item (list) + Return the fourth item of LIST, or nil if LIST is too short. + + See also: ‘-fifth-item’ (*note -fifth-item::). + + (-fourth-item '(1 2 3 4)) + ⇒ 4 + (-fourth-item nil) + ⇒ nil + + -- Function: -fifth-item (list) + Return the fifth item of LIST, or nil if LIST is too short. + + See also: ‘-last-item’ (*note -last-item::). + + (-fifth-item '(1 2 3 4 5)) + ⇒ 5 + (-fifth-item nil) + ⇒ nil + + -- Function: -last-item (list) + Return the last item of LIST, or nil on an empty list. + + (-last-item '(1 2 3)) + ⇒ 3 + (-last-item nil) + ⇒ nil + (let ((list (list 1 2 3))) (setf (-last-item list) 5) list) + ⇒ '(1 2 5) + + -- Function: -butlast (list) + Return a list of all items in list except for the last. + + (-butlast '(1 2 3)) + ⇒ '(1 2) + (-butlast '(1 2)) + ⇒ '(1) + (-butlast '(1)) + ⇒ nil + + -- Function: -sort (comparator list) + Sort LIST, stably, comparing elements using COMPARATOR. Return the + sorted list. LIST is NOT modified by side effects. COMPARATOR is + called with two elements of LIST, and should return non-nil if the + first element should sort before the second. + + (-sort '< '(3 1 2)) + ⇒ '(1 2 3) + (-sort '> '(3 1 2)) + ⇒ '(3 2 1) + (--sort (< it other) '(3 1 2)) + ⇒ '(1 2 3) + + -- Function: -list (&rest args) + Return a list with ARGS. + + If first item of ARGS is already a list, simply return ARGS. If + not, return a list with ARGS as elements. + + (-list 1) + ⇒ '(1) + (-list 1 2 3) + ⇒ '(1 2 3) + (-list '(1 2 3)) + ⇒ '(1 2 3) + + -- Function: -fix (fn list) + Compute the (least) fixpoint of FN with initial input LIST. + + FN is called at least once, results are compared with ‘equal’. + + (-fix (lambda (l) (-non-nil (--mapcat (-split-at (/ (length it) 2) it) l))) '((1 2 3 4 5 6))) + ⇒ '((1) (2) (3) (4) (5) (6)) + (let ((data '(("starwars" "scifi") ("jedi" "starwars" "warrior")))) (--fix (-uniq (--mapcat (cons it (cdr (assoc it data))) it)) '("jedi" "book"))) + ⇒ '("jedi" "starwars" "warrior" "scifi" "book") + + +File: dash.info, Node: Tree operations, Next: Threading macros, Prev: Other list operations, Up: Functions + +2.11 Tree operations +==================== + +Functions pretending lists are trees. + + -- Function: -tree-seq (branch children tree) + Return a sequence of the nodes in TREE, in depth-first search + order. + + BRANCH is a predicate of one argument that returns non-nil if the + passed argument is a branch, that is, a node that can have + children. + + CHILDREN is a function of one argument that returns the children of + the passed branch node. + + Non-branch nodes are simply copied. + + (-tree-seq 'listp 'identity '(1 (2 3) 4 (5 (6 7)))) + ⇒ '((1 (2 3) 4 (5 (6 7))) 1 (2 3) 2 3 4 (5 (6 7)) 5 (6 7) 6 7) + (-tree-seq 'listp 'reverse '(1 (2 3) 4 (5 (6 7)))) + ⇒ '((1 (2 3) 4 (5 (6 7))) (5 (6 7)) (6 7) 7 6 5 4 (2 3) 3 2 1) + (--tree-seq (vectorp it) (append it nil) [1 [2 3] 4 [5 [6 7]]]) + ⇒ '([1 [2 3] 4 [5 [6 7]]] 1 [2 3] 2 3 4 [5 [6 7]] 5 [6 7] 6 7) + + -- Function: -tree-map (fn tree) + Apply FN to each element of TREE while preserving the tree + structure. + + (-tree-map '1+ '(1 (2 3) (4 (5 6) 7))) + ⇒ '(2 (3 4) (5 (6 7) 8)) + (-tree-map '(lambda (x) (cons x (expt 2 x))) '(1 (2 3) 4)) + ⇒ '((1 . 2) ((2 . 4) (3 . 8)) (4 . 16)) + (--tree-map (length it) '("" ("

" "text" "

") "")) + ⇒ '(6 (3 4 4) 7) + + -- Function: -tree-map-nodes (pred fun tree) + Call FUN on each node of TREE that satisfies PRED. + + If PRED returns nil, continue descending down this node. If PRED + returns non-nil, apply FUN to this node and do not descend further. + + (-tree-map-nodes 'vectorp (lambda (x) (-sum (append x nil))) '(1 [2 3] 4 (5 [6 7] 8))) + ⇒ '(1 5 4 (5 13 8)) + (-tree-map-nodes 'keywordp (lambda (x) (symbol-name x)) '(1 :foo 4 ((5 6 :bar) :baz 8))) + ⇒ '(1 ":foo" 4 ((5 6 ":bar") ":baz" 8)) + (--tree-map-nodes (eq (car-safe it) 'add-mode) (-concat it (list :mode 'emacs-lisp-mode)) '(with-mode emacs-lisp-mode (foo bar) (add-mode a b) (baz (add-mode c d)))) + ⇒ '(with-mode emacs-lisp-mode (foo bar) (add-mode a b :mode emacs-lisp-mode) (baz (add-mode c d :mode emacs-lisp-mode))) + + -- Function: -tree-reduce (fn tree) + Use FN to reduce elements of list TREE. If elements of TREE are + lists themselves, apply the reduction recursively. + + FN is first applied to first element of the list and second + element, then on this result and third element from the list etc. + + See ‘-reduce-r’ (*note -reduce-r::) for how exactly are lists of + zero or one element handled. + + (-tree-reduce '+ '(1 (2 3) (4 5))) + ⇒ 15 + (-tree-reduce 'concat '("strings" (" on" " various") ((" levels")))) + ⇒ "strings on various levels" + (--tree-reduce (cond ((stringp it) (concat it " " acc)) (t (let ((sn (symbol-name it))) (concat "<" sn ">" acc "")))) '(body (p "some words") (div "more" (b "bold") "words"))) + ⇒ "

some words

more bold words
" + + -- Function: -tree-reduce-from (fn init-value tree) + Use FN to reduce elements of list TREE. If elements of TREE are + lists themselves, apply the reduction recursively. + + FN is first applied to INIT-VALUE and first element of the list, + then on this result and second element from the list etc. + + The initial value is ignored on cons pairs as they always contain + two elements. + + (-tree-reduce-from '+ 1 '(1 (1 1) ((1)))) + ⇒ 8 + (--tree-reduce-from (-concat acc (list it)) nil '(1 (2 3 (4 5)) (6 7))) + ⇒ '((7 6) ((5 4) 3 2) 1) + + -- Function: -tree-mapreduce (fn folder tree) + Apply FN to each element of TREE, and make a list of the results. + If elements of TREE are lists themselves, apply FN recursively to + elements of these nested lists. + + Then reduce the resulting lists using FOLDER and initial value + INIT-VALUE. See ‘-reduce-r-from’ (*note -reduce-r-from::). + + This is the same as calling ‘-tree-reduce’ (*note -tree-reduce::) + after ‘-tree-map’ (*note -tree-map::) but is twice as fast as it + only traverse the structure once. + + (-tree-mapreduce 'list 'append '(1 (2 (3 4) (5 6)) (7 (8 9)))) + ⇒ '(1 2 3 4 5 6 7 8 9) + (--tree-mapreduce 1 (+ it acc) '(1 (2 (4 9) (2 1)) (7 (4 3)))) + ⇒ 9 + (--tree-mapreduce 0 (max acc (1+ it)) '(1 (2 (4 9) (2 1)) (7 (4 3)))) + ⇒ 3 + + -- Function: -tree-mapreduce-from (fn folder init-value tree) + Apply FN to each element of TREE, and make a list of the results. + If elements of TREE are lists themselves, apply FN recursively to + elements of these nested lists. + + Then reduce the resulting lists using FOLDER and initial value + INIT-VALUE. See ‘-reduce-r-from’ (*note -reduce-r-from::). + + This is the same as calling ‘-tree-reduce-from’ (*note + -tree-reduce-from::) after ‘-tree-map’ (*note -tree-map::) but is + twice as fast as it only traverse the structure once. + + (-tree-mapreduce-from 'identity '* 1 '(1 (2 (3 4) (5 6)) (7 (8 9)))) + ⇒ 362880 + (--tree-mapreduce-from (+ it it) (cons it acc) nil '(1 (2 (4 9) (2 1)) (7 (4 3)))) + ⇒ '(2 (4 (8 18) (4 2)) (14 (8 6))) + (concat "{" (--tree-mapreduce-from (cond ((-cons-pair? it) (concat (symbol-name (car it)) " -> " (symbol-name (cdr it)))) (t (concat (symbol-name it) " : {"))) (concat it (unless (or (equal acc "}") (equal (substring it (1- (length it))) "{")) ", ") acc) "}" '((elips-mode (foo (bar . booze)) (baz . qux)) (c-mode (foo . bla) (bum . bam))))) + ⇒ "{elips-mode : {foo : {bar -> booze{, baz -> qux{, c-mode : {foo -> bla, bum -> bam}}" + + -- Function: -clone (list) + Create a deep copy of LIST. The new list has the same elements and + structure but all cons are replaced with new ones. This is useful + when you need to clone a structure such as plist or alist. + + (let* ((a '(1 2 3)) (b (-clone a))) (nreverse a) b) + ⇒ '(1 2 3) + + +File: dash.info, Node: Threading macros, Next: Binding, Prev: Tree operations, Up: Functions + +2.12 Threading macros +===================== + + -- Macro: -> (x &optional form &rest more) + Thread the expr through the forms. Insert X as the second item in + the first form, making a list of it if it is not a list already. + If there are more forms, insert the first form as the second item + in second form, etc. + + (-> '(2 3 5)) + ⇒ '(2 3 5) + (-> '(2 3 5) (append '(8 13))) + ⇒ '(2 3 5 8 13) + (-> '(2 3 5) (append '(8 13)) (-slice 1 -1)) + ⇒ '(3 5 8) + + -- Macro: ->> (x &optional form &rest more) + Thread the expr through the forms. Insert X as the last item in + the first form, making a list of it if it is not a list already. + If there are more forms, insert the first form as the last item in + second form, etc. + + (->> '(1 2 3) (-map 'square)) + ⇒ '(1 4 9) + (->> '(1 2 3) (-map 'square) (-remove 'even?)) + ⇒ '(1 9) + (->> '(1 2 3) (-map 'square) (-reduce '+)) + ⇒ 14 + + -- Macro: --> (x &rest forms) + Starting with the value of X, thread each expression through FORMS. + + Insert X at the position signified by the symbol ‘it’ in the first + form. If there are more forms, insert the first form at the + position signified by ‘it’ in in second form, etc. + + (--> "def" (concat "abc" it "ghi")) + ⇒ "abcdefghi" + (--> "def" (concat "abc" it "ghi") (upcase it)) + ⇒ "ABCDEFGHI" + (--> "def" (concat "abc" it "ghi") upcase) + ⇒ "ABCDEFGHI" + + -- Macro: -as-> (value variable &rest forms) + Starting with VALUE, thread VARIABLE through FORMS. + + In the first form, bind VARIABLE to VALUE. In the second form, + bind VARIABLE to the result of the first form, and so forth. + + (-as-> 3 my-var (1+ my-var) (list my-var) (mapcar (lambda (ele) (* 2 ele)) my-var)) + ⇒ '(8) + (-as-> 3 my-var 1+) + ⇒ 4 + (-as-> 3 my-var) + ⇒ 3 + + -- Macro: -some-> (x &optional form &rest more) + 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. + + (-some-> '(2 3 5)) + ⇒ '(2 3 5) + (-some-> 5 square) + ⇒ 25 + (-some-> 5 even? square) + ⇒ nil + + -- Macro: -some->> (x &optional form &rest more) + 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. + + (-some->> '(1 2 3) (-map 'square)) + ⇒ '(1 4 9) + (-some->> '(1 3 5) (-last 'even?) (+ 100)) + ⇒ nil + (-some->> '(2 4 6) (-last 'even?) (+ 100)) + ⇒ 106 + + -- Macro: -some--> (x &optional form &rest more) + When expr in non-nil, thread it through the first form (via ‘-->’ + (*note -->::)), and when that result is non-nil, through the next + form, etc. + + (-some--> "def" (concat "abc" it "ghi")) + ⇒ "abcdefghi" + (-some--> nil (concat "abc" it "ghi")) + ⇒ nil + (-some--> '(1 3 5) (-filter 'even? it) (append it it) (-map 'square it)) + ⇒ nil + + +File: dash.info, Node: Binding, Next: Side-effects, Prev: Threading macros, Up: Functions + +2.13 Binding +============ + +Convenient versions of ‘let‘ and ‘let*‘ constructs combined with flow +control. + + -- Macro: -when-let (var-val &rest body) + If VAL evaluates to non-nil, bind it to VAR and execute body. + + Note: binding is done according to ‘-let’ (*note -let::). + + (fn (VAR VAL) &rest BODY) + + (-when-let (match-index (string-match "d" "abcd")) (+ match-index 2)) + ⇒ 5 + (-when-let ((&plist :foo foo) (list :foo "foo")) foo) + ⇒ "foo" + (-when-let ((&plist :foo foo) (list :bar "bar")) foo) + ⇒ nil + + -- Macro: -when-let* (vars-vals &rest body) + If all VALS evaluate to true, bind them to their corresponding VARS + and execute body. VARS-VALS should be a list of (VAR VAL) pairs. + + Note: binding is done according to ‘-let*’ (*note -let*::). VALS + are evaluated sequentially, and evaluation stops after the first + nil VAL is encountered. + + (-when-let* ((x 5) (y 3) (z (+ y 4))) (+ x y z)) + ⇒ 15 + (-when-let* ((x 5) (y nil) (z 7)) (+ x y z)) + ⇒ nil + + -- Macro: -if-let (var-val then &rest else) + If VAL evaluates to non-nil, bind it to VAR and do THEN, otherwise + do ELSE. + + Note: binding is done according to ‘-let’ (*note -let::). + + (fn (VAR VAL) THEN &rest ELSE) + + (-if-let (match-index (string-match "d" "abc")) (+ match-index 3) 7) + ⇒ 7 + (--if-let (even? 4) it nil) + ⇒ t + + -- Macro: -if-let* (vars-vals then &rest else) + If all VALS evaluate to true, bind them to their corresponding VARS + and do THEN, otherwise do ELSE. VARS-VALS should be a list of (VAR + VAL) pairs. + + Note: binding is done according to ‘-let*’ (*note -let*::). VALS + are evaluated sequentially, and evaluation stops after the first + nil VAL is encountered. + + (-if-let* ((x 5) (y 3) (z 7)) (+ x y z) "foo") + ⇒ 15 + (-if-let* ((x 5) (y nil) (z 7)) (+ x y z) "foo") + ⇒ "foo" + (-if-let* (((_ _ x) '(nil nil 7))) x) + ⇒ 7 + + -- Macro: -let (varlist &rest body) + Bind variables according to VARLIST then eval BODY. + + VARLIST is a list of lists of the form (PATTERN SOURCE). Each + PATTERN is matched against the SOURCE "structurally". SOURCE is + only evaluated once for each PATTERN. Each PATTERN is matched + recursively, and can therefore contain sub-patterns which are + matched against corresponding sub-expressions of SOURCE. + + All the SOURCEs are evalled before any symbols are bound (i.e. "in + parallel"). + + If VARLIST only contains one (PATTERN SOURCE) element, you can + optionally specify it using a vector and discarding the outer-most + parens. Thus + + (-let ((PATTERN SOURCE)) ..) + + becomes + + (-let [PATTERN SOURCE] ..). + + ‘-let’ (*note -let::) uses a convention of not binding places + (symbols) starting with _ whenever it’s possible. You can use this + to skip over entries you don’t care about. However, this is not + *always* possible (as a result of implementation) and these symbols + might get bound to undefined values. + + Following is the overview of supported patterns. Remember that + patterns can be matched recursively, so every a, b, aK in the + following can be a matching construct and not necessarily a + symbol/variable. + + Symbol: + + a - bind the SOURCE to A. This is just like regular ‘let’. + + Conses and lists: + + (a) - bind ‘car’ of cons/list to A + + (a . b) - bind car of cons to A and ‘cdr’ to B + + (a b) - bind car of list to A and ‘cadr’ to B + + (a1 a2 a3 ...) - bind 0th car of list to A1, 1st to A2, 2nd to A3 + ... + + (a1 a2 a3 ... aN . rest) - as above, but bind the Nth cdr to + REST. + + Vectors: + + [a] - bind 0th element of a non-list sequence to A (works with + vectors, strings, bit arrays...) + + [a1 a2 a3 ...] - bind 0th element of non-list sequence to A0, 1st + to A1, 2nd to A2, ... If the PATTERN is shorter than SOURCE, the + values at places not in PATTERN are ignored. If the PATTERN is + longer than SOURCE, an ‘error’ is thrown. + + [a1 a2 a3 ... &rest rest] - as above, but bind the rest of the + sequence to REST. This is conceptually the same as improper list + matching (a1 a2 ... aN . rest) + + Key/value stores: + + (&plist key0 a0 ... keyN aN) - bind value mapped by keyK in the + SOURCE plist to aK. If the value is not found, aK is nil. Uses + ‘plist-get’ to fetch values. + + (&alist key0 a0 ... keyN aN) - bind value mapped by keyK in the + SOURCE alist to aK. If the value is not found, aK is nil. Uses + ‘assoc’ to fetch values. + + (&hash key0 a0 ... keyN aN) - bind value mapped by keyK in the + SOURCE hash table to aK. If the value is not found, aK is nil. + Uses ‘gethash’ to fetch values. + + Further, special keyword &keys supports "inline" matching of + plist-like key-value pairs, similarly to &keys keyword of + ‘cl-defun’. + + (a1 a2 ... aN &keys key1 b1 ... keyN bK) + + This binds N values from the list to a1 ... aN, then interprets + the cdr as a plist (see key/value matching above). + + A shorthand notation for kv-destructuring exists which allows the + patterns be optionally left out and derived from the key name in + the following fashion: + + - a key :foo is converted into ‘foo’ pattern, - a key ’bar is + converted into ‘bar’ pattern, - a key "baz" is converted into ‘baz’ + pattern. + + That is, the entire value under the key is bound to the derived + variable without any further destructuring. + + This is possible only when the form following the key is not a + valid pattern (i.e. not a symbol, a cons cell or a vector). + Otherwise the matching proceeds as usual and in case of an invalid + spec fails with an error. + + Thus the patterns are normalized as follows: + + ;; derive all the missing patterns (&plist :foo ’bar "baz") => + (&plist :foo foo ’bar bar "baz" baz) + + ;; we can specify some but not others (&plist :foo ’bar + explicit-bar) => (&plist :foo foo ’bar explicit-bar) + + ;; nothing happens, we store :foo in x (&plist :foo x) => (&plist + :foo x) + + ;; nothing happens, we match recursively (&plist :foo (a b c)) => + (&plist :foo (a b c)) + + You can name the source using the syntax SYMBOL &as PATTERN. This + syntax works with lists (proper or improper), vectors and all types + of maps. + + (list &as a b c) (list 1 2 3) + + binds A to 1, B to 2, C to 3 and LIST to (1 2 3). + + Similarly: + + (bounds &as beg . end) (cons 1 2) + + binds BEG to 1, END to 2 and BOUNDS to (1 . 2). + + (items &as first . rest) (list 1 2 3) + + binds FIRST to 1, REST to (2 3) and ITEMS to (1 2 3) + + [vect &as _ b c] [1 2 3] + + binds B to 2, C to 3 and VECT to [1 2 3] (_ avoids binding as + usual). + + (plist &as &plist :b b) (list :a 1 :b 2 :c 3) + + binds B to 2 and PLIST to (:a 1 :b 2 :c 3). Same for &alist and + &hash. + + This is especially useful when we want to capture the result of a + computation and destructure at the same time. Consider the form + (function-returning-complex-structure) returning a list of two + vectors with two items each. We want to capture this entire result + and pass it to another computation, but at the same time we want to + get the second item from each vector. We can achieve it with + pattern + + (result &as [_ a] [_ b]) (function-returning-complex-structure) + + Note: Clojure programmers may know this feature as the ":as + binding". The difference is that we put the &as at the front + because we need to support improper list binding. + + (-let (([a (b c) d] [1 (2 3) 4])) (list a b c d)) + ⇒ '(1 2 3 4) + (-let [(a b c . d) (list 1 2 3 4 5 6)] (list a b c d)) + ⇒ '(1 2 3 (4 5 6)) + (-let [(&plist :foo foo :bar bar) (list :baz 3 :foo 1 :qux 4 :bar 2)] (list foo bar)) + ⇒ '(1 2) + + -- Macro: -let* (varlist &rest body) + Bind variables according to VARLIST then eval BODY. + + VARLIST is a list of lists of the form (PATTERN SOURCE). Each + PATTERN is matched against the SOURCE structurally. SOURCE is only + evaluated once for each PATTERN. + + Each SOURCE can refer to the symbols already bound by this VARLIST. + This is useful if you want to destructure SOURCE recursively but + also want to name the intermediate structures. + + See ‘-let’ (*note -let::) for the list of all possible patterns. + + (-let* (((a . b) (cons 1 2)) ((c . d) (cons 3 4))) (list a b c d)) + ⇒ '(1 2 3 4) + (-let* (((a . b) (cons 1 (cons 2 3))) ((c . d) b)) (list a b c d)) + ⇒ '(1 (2 . 3) 2 3) + (-let* (((&alist "foo" foo "bar" bar) (list (cons "foo" 1) (cons "bar" (list 'a 'b 'c)))) ((a b c) bar)) (list foo a b c bar)) + ⇒ '(1 a b c (a b c)) + + -- Macro: -lambda (match-form &rest body) + Return a lambda which destructures its input as MATCH-FORM and + executes BODY. + + Note that you have to enclose the MATCH-FORM in a pair of parens, + such that: + + (-lambda (x) body) (-lambda (x y ...) body) + + has the usual semantics of ‘lambda’. Furthermore, these get + translated into normal lambda, so there is no performance penalty. + + See ‘-let’ (*note -let::) for the description of destructuring + mechanism. + + (-map (-lambda ((x y)) (+ x y)) '((1 2) (3 4) (5 6))) + ⇒ '(3 7 11) + (-map (-lambda ([x y]) (+ x y)) '([1 2] [3 4] [5 6])) + ⇒ '(3 7 11) + (funcall (-lambda ((_ . a) (_ . b)) (-concat a b)) '(1 2 3) '(4 5 6)) + ⇒ '(2 3 5 6) + + -- Macro: -setq (&rest forms) + Bind each MATCH-FORM to the value of its VAL. + + MATCH-FORM destructuring is done according to the rules of ‘-let’ + (*note -let::). + + This macro allows you to bind multiple variables by destructuring + the value, so for example: + + (-setq (a b) x (&plist :c c) plist) + + expands roughly speaking to the following code + + (setq a (car x) b (cadr x) c (plist-get plist :c)) + + Care is taken to only evaluate each VAL once so that in case of + multiple assignments it does not cause unexpected side effects. + + (fn [MATCH-FORM VAL]...) + + (progn (-setq a 1) a) + ⇒ 1 + (progn (-setq (a b) (list 1 2)) (list a b)) + ⇒ '(1 2) + (progn (-setq (&plist :c c) (list :c "c")) c) + ⇒ "c" + + +File: dash.info, Node: Side-effects, Next: Destructive operations, Prev: Binding, Up: Functions + +2.14 Side-effects +================= + +Functions iterating over lists for side-effect only. + + -- Function: -each (list fn) + Call FN with every item in LIST. Return nil, used for side-effects + only. + + (let (s) (-each '(1 2 3) (lambda (item) (setq s (cons item s))))) + ⇒ nil + (let (s) (-each '(1 2 3) (lambda (item) (setq s (cons item s)))) s) + ⇒ '(3 2 1) + (let (s) (--each '(1 2 3) (setq s (cons it s))) s) + ⇒ '(3 2 1) + + -- Function: -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. + + (let (s) (-each-while '(2 4 5 6) 'even? (lambda (item) (!cons item s))) s) + ⇒ '(4 2) + (let (s) (--each-while '(1 2 3 4) (< it 3) (!cons it s)) s) + ⇒ '(2 1) + + -- Function: -each-indexed (list fn) + Call (FN index item) for each item in LIST. + + In the anaphoric form ‘--each-indexed’, the index is exposed as + symbol ‘it-index’. + + See also: ‘-map-indexed’ (*note -map-indexed::). + + (let (s) (-each-indexed '(a b c) (lambda (index item) (setq s (cons (list item index) s)))) s) + ⇒ '((c 2) (b 1) (a 0)) + (let (s) (--each-indexed '(a b c) (setq s (cons (list it it-index) s))) s) + ⇒ '((c 2) (b 1) (a 0)) + + -- Function: -each-r (list fn) + Call FN with every item in LIST in reversed order. Return nil, + used for side-effects only. + + (let (s) (-each-r '(1 2 3) (lambda (item) (setq s (cons item s))))) + ⇒ nil + (let (s) (-each-r '(1 2 3) (lambda (item) (setq s (cons item s)))) s) + ⇒ '(1 2 3) + (let (s) (--each-r '(1 2 3) (setq s (cons it s))) s) + ⇒ '(1 2 3) + + -- Function: -each-r-while (list pred fn) + Call FN with every item in reversed LIST while (PRED item) is + non-nil. Return nil, used for side-effects only. + + (let (s) (-each-r-while '(2 4 5 6) 'even? (lambda (item) (!cons item s))) s) + ⇒ '(6) + (let (s) (--each-r-while '(1 2 3 4) (>= it 3) (!cons it s)) s) + ⇒ '(3 4) + + -- Function: -dotimes (num fn) + Repeatedly calls FN (presumably for side-effects) passing in + integers from 0 through NUM-1. + + (let (s) (-dotimes 3 (lambda (n) (!cons n s))) s) + ⇒ '(2 1 0) + (let (s) (--dotimes 5 (!cons it s)) s) + ⇒ '(4 3 2 1 0) + + -- Macro: -doto (eval-initial-value &rest forms) + Eval a form, then insert that form as the 2nd argument to other + forms. The EVAL-INITIAL-VALUE form is evaluated once. Its result + is passed to FORMS, which are then evaluated sequentially. Returns + the target form. + + (-doto '(1 2 3) (!cdr) (!cdr)) + ⇒ '(3) + (-doto '(1 . 2) (setcar 3) (setcdr 4)) + ⇒ '(3 . 4) + + -- Macro: --doto (eval-initial-value &rest forms) + Anaphoric form of ‘-doto’ (*note -doto::). Note: ‘it’ is not + required in each form. + + (gethash "key" (--doto (make-hash-table :test 'equal) (puthash "key" "value" it))) + ⇒ "value" + + +File: dash.info, Node: Destructive operations, Next: Function combinators, Prev: Side-effects, Up: Functions + +2.15 Destructive operations +=========================== + + -- Macro: !cons (car cdr) + Destructive: Set CDR to the cons of CAR and CDR. + + (let (l) (!cons 5 l) l) + ⇒ '(5) + (let ((l '(3))) (!cons 5 l) l) + ⇒ '(5 3) + + -- Macro: !cdr (list) + Destructive: Set LIST to the cdr of LIST. + + (let ((l '(3))) (!cdr l) l) + ⇒ '() + (let ((l '(3 5))) (!cdr l) l) + ⇒ '(5) + + +File: dash.info, Node: Function combinators, Prev: Destructive operations, Up: Functions + +2.16 Function combinators +========================= + +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 + called, the returned function calls FN with ARGS first and then + additional args. + + (funcall (-partial '- 5) 3) + ⇒ 2 + (funcall (-partial '+ 5 2) 3) + ⇒ 10 + + -- Function: -rpartial (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 + called, the returned function calls FN with the additional args + first and then ARGS. + + (funcall (-rpartial '- 5) 8) + ⇒ 3 + (funcall (-rpartial '- 5 2) 10) + ⇒ 3 + + -- Function: -juxt (&rest fns) + Takes a list of functions and returns a fn that is the + juxtaposition of those fns. The returned fn takes a variable + number of args, and returns a list containing the result of + applying each fn to the args (left-to-right). + + (funcall (-juxt '+ '-) 3 5) + ⇒ '(8 -2) + (-map (-juxt 'identity 'square) '(1 2 3)) + ⇒ '((1 1) (2 4) (3 9)) + + -- Function: -compose (&rest fns) + Takes a list of functions and returns a fn that is the composition + of those fns. The returned fn takes a variable number of + arguments, and returns the result of applying each fn to the result + of applying the previous fn to the arguments (right-to-left). + + (funcall (-compose 'square '+) 2 3) + ⇒ (square (+ 2 3)) + (funcall (-compose 'identity 'square) 3) + ⇒ (square 3) + (funcall (-compose 'square 'identity) 3) + ⇒ (square 3) + + -- Function: -applify (fn) + Changes an n-arity function FN to a 1-arity function that expects a + list with n items as arguments + + (-map (-applify '+) '((1 1 1) (1 2 3) (5 5 5))) + ⇒ '(3 6 15) + (-map (-applify (lambda (a b c) (\` ((\, a) ((\, b) ((\, c))))))) '((1 1 1) (1 2 3) (5 5 5))) + ⇒ '((1 (1 (1))) (1 (2 (3))) (5 (5 (5)))) + (funcall (-applify '<) '(3 6)) + ⇒ t + + -- Function: -on (operator transformer) + Return a function of two arguments that first applies TRANSFORMER + to each of them and then applies OPERATOR on the results (in the + same order). + + In types: (b -> b -> c) -> (a -> b) -> a -> a -> c + + (-sort (-on '< 'length) '((1 2 3) (1) (1 2))) + ⇒ '((1) (1 2) (1 2 3)) + (-min-by (-on '> 'length) '((1 2 3) (4) (1 2))) + ⇒ '(4) + (-min-by (-on 'string-lessp 'number-to-string) '(2 100 22)) + ⇒ 22 + + -- Function: -flip (func) + Swap the order of arguments for binary function FUNC. + + In types: (a -> b -> c) -> b -> a -> c + + (funcall (-flip '<) 2 1) + ⇒ t + (funcall (-flip '-) 3 8) + ⇒ 5 + (-sort (-flip '<) '(4 3 6 1)) + ⇒ '(6 4 3 1) + + -- Function: -const (c) + Return a function that returns C ignoring any additional arguments. + + In types: a -> b -> a + + (funcall (-const 2) 1 3 "foo") + ⇒ 2 + (-map (-const 1) '("a" "b" "c" "d")) + ⇒ '(1 1 1 1) + (-sum (-map (-const 1) '("a" "b" "c" "d"))) + ⇒ 4 + + -- Macro: -cut (&rest params) + Take n-ary function and n arguments and specialize some of them. + Arguments denoted by <> will be left unspecialized. + + See SRFI-26 for detailed description. + + (funcall (-cut list 1 <> 3 <> 5) 2 4) + ⇒ '(1 2 3 4 5) + (-map (-cut funcall <> 5) '(1+ 1- (lambda (x) (/ 1.0 x)))) + ⇒ '(6 4 0.2) + (-map (-cut <> 1 2 3) (list 'list 'vector 'string)) + ⇒ '((1 2 3) [1 2 3] "") + + -- Function: -not (pred) + Take a unary predicate PRED and return a unary predicate that + returns t if PRED returns nil and nil if PRED returns non-nil. + + (funcall (-not 'even?) 5) + ⇒ t + (-filter (-not (-partial '< 4)) '(1 2 3 4 5 6 7 8)) + ⇒ '(1 2 3 4) + + -- Function: -orfn (&rest preds) + Take list of unary predicates PREDS and return a unary predicate + with argument x that returns non-nil if at least one of the PREDS + returns non-nil on x. + + In types: [a -> Bool] -> a -> Bool + + (-filter (-orfn 'even? (-partial (-flip '<) 5)) '(1 2 3 4 5 6 7 8 9 10)) + ⇒ '(1 2 3 4 6 8 10) + (funcall (-orfn 'stringp 'even?) "foo") + ⇒ t + + -- Function: -andfn (&rest preds) + Take list of unary predicates PREDS and return a unary predicate + with argument x that returns non-nil if all of the PREDS returns + non-nil on x. + + In types: [a -> Bool] -> a -> Bool + + (funcall (-andfn (-cut < <> 10) 'even?) 6) + ⇒ t + (funcall (-andfn (-cut < <> 10) 'even?) 12) + ⇒ nil + (-filter (-andfn (-not 'even?) (-cut >= 5 <>)) '(1 2 3 4 5 6 7 8 9 10)) + ⇒ '(1 3 5) + + -- Function: -iteratefn (fn n) + Return a function FN composed N times with itself. + + FN is a unary function. If you need to use a function of higher + arity, use ‘-applify’ (*note -applify::) first to turn it into a + unary function. + + With n = 0, this acts as identity function. + + In types: (a -> a) -> Int -> a -> a. + + This function satisfies the following law: + + (funcall (-iteratefn fn n) init) = (-last-item (-iterate fn init + (1+ n))). + + (funcall (-iteratefn (lambda (x) (* x x)) 3) 2) + ⇒ 256 + (funcall (-iteratefn '1+ 3) 1) + ⇒ 4 + (funcall (-iteratefn 'cdr 3) '(1 2 3 4 5)) + ⇒ '(4 5) + + -- Function: -fixfn (fn &optional equal-test halt-test) + Return a function that computes the (least) fixpoint of FN. + + FN must be a unary function. The returned lambda takes a single + argument, X, the initial value for the fixpoint iteration. The + iteration halts when either of the following conditions is + satisified: + + 1. Iteration converges to the fixpoint, with equality being tested + using EQUAL-TEST. If EQUAL-TEST is not specified, ‘equal’ is used. + For functions over the floating point numbers, it may be necessary + to provide an appropriate appoximate comparsion test. + + 2. HALT-TEST returns a non-nil value. HALT-TEST defaults to a + simple counter that returns t after ‘-fixfn-max-iterations’, to + guard against infinite iteration. Otherwise, HALT-TEST must be a + function that accepts a single argument, the current value of X, + and returns non-nil as long as iteration should continue. In this + way, a more sophisticated convergence test may be supplied by the + caller. + + The return value of the lambda is either the fixpoint or, if + iteration halted before converging, a cons with car ‘halted’ and + cdr the final output from HALT-TEST. + + In types: (a -> a) -> a -> a. + + (funcall (-fixfn 'cos 'approx-equal) 0.7) + ⇒ 0.7390851332151607 + (funcall (-fixfn (lambda (x) (expt (+ x 10) 0.25))) 2.0) + ⇒ 1.8555845286409378 + (funcall (-fixfn 'sin 'approx-equal) 0.1) + ⇒ '(halted . t) + + -- Function: -prodfn (&rest fns) + Take a list of n functions and return a function that takes a list + of length n, applying i-th function to i-th element of the input + list. Returns a list of length n. + + In types (for n=2): ((a -> b), (c -> d)) -> (a, c) -> (b, d) + + This function satisfies the following laws: + + (-compose (-prodfn f g ...) (-prodfn f’ g’ ...)) = (-prodfn + (-compose f f’) (-compose g g’) ...) (-prodfn f g ...) = (-juxt + (-compose f (-partial ’nth 0)) (-compose g (-partial ’nth 1)) ...) + (-compose (-prodfn f g ...) (-juxt f’ g’ ...)) = (-juxt (-compose + f f’) (-compose g g’) ...) (-compose (-partial ’nth n) (-prod f1 + f2 ...)) = (-compose fn (-partial ’nth n)) + + (funcall (-prodfn '1+ '1- 'number-to-string) '(1 2 3)) + ⇒ '(2 1 "3") + (-map (-prodfn '1+ '1-) '((1 2) (3 4) (5 6) (7 8))) + ⇒ '((2 1) (4 3) (6 5) (8 7)) + (apply '+ (funcall (-prodfn 'length 'string-to-number) '((1 2 3) "15"))) + ⇒ 18 + + +File: dash.info, Node: Development, Next: Index, Prev: Functions, Up: Top + +3 Development +************* + +The dash repository is hosted on GitHub: + + +* Menu: + +* Contribute:: How to contribute +* Changes:: List of significant changes by version +* Contributors:: List of contributors + + +File: dash.info, Node: Contribute, Next: Changes, Up: Development + +3.1 Contribute +============== + +Yes, please do. Pure functions in the list manipulation realm only, +please. There’s a suite of tests in dev/examples.el, so remember to add +tests for your function, or it might get broken later. + + Run the tests with ‘./run-tests.sh’. Create the docs with +‘./create-docs.sh’. I highly recommend that you install these as a +pre-commit hook, so that the tests are always running and the docs are +always in sync: + +cp pre-commit.sh .git/hooks/pre-commit + + Oh, and don’t edit ‘README.md’ directly, it is auto-generated. +Change ‘readme-template.md’ or ‘examples-to-docs.el’ instead. The same +goes for the info manual. + + +File: dash.info, Node: Changes, Next: Contributors, Prev: Contribute, Up: Development + +3.2 Changes +=========== + +Changes in 2.10: + + • Add ‘-let’ destructuring to ‘-if-let’ and ‘-when-let’ (Fredrik + Bergroth) + +Changes in 2.9: + + • Add ‘-let’, ‘-let*’ and ‘-lambda’ with destructuring + • Add ‘-tree-seq’ and ‘-tree-map-nodes’ + • Add ‘-non-nil’ + • Add ‘-fix’ + • Add ‘-fixfn’ (dash-functional 1.2) + • Add ‘-copy’ (Wilfred Hughes) + +Changes in 2.8: + + • Add ‘-butlast’ + +Changes in 2.7: + + • ‘-zip’ now supports more than two lists (Steve Lamb) + • Add ‘-cycle’, ‘-pad’, ‘-annotate’, ‘-zip-fill’ (Steve Lamb) + • Add ‘-table’, ‘-table-flat’ (finite cartesian product) + • Add ‘-flatten-n’ + • ‘-slice’ now supports "step" argument + • Add functional combinators ‘-iteratefn’, ‘-prodfn’ + • Add ‘-replace’, ‘-splice’, ‘-splice-list’ which generalize + ‘-replace-at’ and ‘-insert-at’ + • Add ‘-compose’, ‘-iteratefn’ and ‘-prodfn’ (dash-functional 1.1) + +Changes in 2.6: + + • Add ‘-is-prefix-p’, ‘-is-suffix-p’, ‘-is-infix-p’ (Matus Goljer) + • Add ‘-iterate’, ‘-unfold’ (Matus Goljer) + • Add ‘-split-on’, ‘-split-when’ (Matus Goljer) + • Add ‘-find-last-index’ (Matus Goljer) + • Add ‘-list’ (Johan Andersson) + +Changes in 2.5: + + • Add ‘-same-items?’ (Johan Andersson) + • A few bugfixes + +Changes in 2.4: + + • Add ‘-snoc’ (Matus Goljer) + • Add ‘-replace-at’, ‘-update-at’, ‘-remove-at’, and + ‘-remove-at-indices’ (Matus Goljer) + +Changes in 2.3: + + • Add tree operations (Matus Goljer) + • Make font-lock optional + +Changes in 2.2: + + • Add ‘-compose’ (Christina Whyte) + +Changes in 2.1: + + • Add indexing operations (Matus Goljer) + +Changes in 2.0: + + • Split out ‘dash-functional.el’ (Matus Goljer) + • Add ‘-andfn’, ‘-orfn’, ‘-not’, ‘-cut’, ‘-const’, ‘-flip’ and ‘-on’. + (Matus Goljer) + • Fix ‘-min’, ‘-max’, ‘-min-by’ and ‘-max-by’ (Matus Goljer) + +Changes in 1.8: + + • Add ‘-first-item’ and ‘-last-item’ (Wilfred Hughes) + +Changes in 1.7: + + • Add ‘-rotate’ (Matus Goljer) + +Changes in 1.6: + + • Add ‘-min’, ‘-max’, ‘-min-by’ and ‘-max-by’ (Johan Andersson) + +Changes in 1.5: + + • Add ‘-sum’ and ‘-product’ (Johan Andersson) + +Changes in 1.4: + + • Add ‘-sort’ + • Add ‘-reduce-r’ (Matus Goljer) + • Add ‘-reduce-r-from’ (Matus Goljer) + +Changes in 1.3: + + • Add ‘-partition-in-steps’ + • Add ‘-partition-all-in-steps’ + +Changes in 1.2: + + • Add ‘-last’ (Matus Goljer) + • Add ‘-insert-at’ (Emanuel Evans) + • Add ‘-when-let’ and ‘-if-let’ (Emanuel Evans) + • Add ‘-when-let*’ and ‘-if-let*’ (Emanuel Evans) + • Some bugfixes + + +File: dash.info, Node: Contributors, Prev: Changes, Up: Development + +3.3 Contributors +================ + + • Matus Goljer (https://github.com/Fuco1) contributed lots of + features and functions. + • Takafumi Arakaki (https://github.com/tkf) contributed ‘-group-by’. + • tali713 (https://github.com/tali713) is the author of ‘-applify’. + • Víctor M. Valenzuela (https://github.com/vemv) contributed + ‘-repeat’. + • Nic Ferrier (https://github.com/nicferrier) contributed ‘-cons*’. + • Wilfred Hughes (https://github.com/Wilfred) contributed ‘-slice’, + ‘-first-item’ and ‘-last-item’. + • Emanuel Evans (https://github.com/shosti) contributed ‘-if-let’, + ‘-when-let’ and ‘-insert-at’. + • Johan Andersson (https://github.com/rejeep) contributed ‘-sum’, + ‘-product’ and ‘-same-items?’ + • Christina Whyte (https://github.com/kurisuwhyte) contributed + ‘-compose’ + • Steve Lamb (https://github.com/steventlamb) contributed ‘-cycle’, + ‘-pad’, ‘-annotate’, ‘-zip-fill’ and an n-ary version of ‘-zip’. + • Fredrik Bergroth (https://github.com/fbergroth) made the ‘-if-let’ + family use ‘-let’ destructuring and improved script for generating + documentation. + • Mark Oteiza (https://github.com/holomorph) contributed the script + to create an info manual. + • Vasilij Schneidermann (https://github.com/wasamasa) contributed + ‘-some’. + • William West (https://github.com/occidens) made ‘-fixfn’ more + robust at handling floats. + + Thanks! + + +File: dash.info, Node: Index, Prev: Development, Up: Top + +Index +***** + +[index] +* Menu: + +* !cdr: Destructive operations. + (line 14) +* !cons: Destructive operations. + (line 6) +* -->: Threading macros. (line 32) +* --doto: Side-effects. (line 81) +* ->: Threading macros. (line 6) +* ->>: Threading macros. (line 19) +* -all?: Predicates. (line 18) +* -andfn: Function combinators. + (line 138) +* -annotate: Maps. (line 79) +* -any?: Predicates. (line 6) +* -applify: Function combinators. + (line 55) +* -as->: Threading macros. (line 46) +* -butlast: Other list operations. + (line 313) +* -clone: Tree operations. (line 122) +* -common-prefix: Reductions. (line 223) +* -common-suffix: Reductions. (line 233) +* -compose: Function combinators. + (line 42) +* -concat: List to list. (line 22) +* -cons*: Other list operations. + (line 30) +* -const: Function combinators. + (line 92) +* -contains?: Predicates. (line 57) +* -copy: Maps. (line 134) +* -count: Reductions. (line 151) +* -cut: Function combinators. + (line 104) +* -cycle: Other list operations. + (line 141) +* -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) +* -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-while: Side-effects. (line 19) +* -elem-index: Indexing. (line 9) +* -elem-indices: Indexing. (line 21) +* -fifth-item: Other list operations. + (line 293) +* -filter: Sublist selection. (line 8) +* -find-index: Indexing. (line 32) +* -find-indices: Indexing. (line 60) +* -find-last-index: Indexing. (line 46) +* -first: Other list operations. + (line 207) +* -first-item: Other list operations. + (line 244) +* -fix: Other list operations. + (line 349) +* -fixfn: Function combinators. + (line 175) +* -flatten: List to list. (line 33) +* -flatten-n: List to list. (line 55) +* -flip: Function combinators. + (line 80) +* -fourth-item: Other list operations. + (line 283) +* -grade-down: Indexing. (line 81) +* -grade-up: Indexing. (line 71) +* -group-by: Partitioning. (line 187) +* -if-let: Binding. (line 36) +* -if-let*: Binding. (line 49) +* -inits: Reductions. (line 203) +* -insert-at: List to list. (line 109) +* -interleave: Other list operations. + (line 68) +* -interpose: Other list operations. + (line 58) +* -intersection: Set operations. (line 32) +* -is-infix?: Predicates. (line 110) +* -is-prefix?: Predicates. (line 86) +* -is-suffix?: Predicates. (line 98) +* -iterate: Unfolding. (line 9) +* -iteratefn: Function combinators. + (line 152) +* -juxt: Function combinators. + (line 31) +* -keep: List to list. (line 8) +* -lambda: Binding. (line 252) +* -last: Other list operations. + (line 234) +* -last-item: Other list operations. + (line 303) +* -let: Binding. (line 65) +* -let*: Binding. (line 232) +* -list: Other list operations. + (line 336) +* -map: Maps. (line 10) +* -map-first: Maps. (line 37) +* -map-indexed: Maps. (line 65) +* -map-last: Maps. (line 51) +* -map-when: Maps. (line 21) +* -mapcat: Maps. (line 123) +* -max: Reductions. (line 267) +* -max-by: Reductions. (line 277) +* -min: Reductions. (line 243) +* -min-by: Reductions. (line 253) +* -non-nil: Sublist selection. (line 79) +* -none?: Predicates. (line 30) +* -not: Function combinators. + (line 117) +* -on: Function combinators. + (line 66) +* -only-some?: Predicates. (line 42) +* -orfn: Function combinators. + (line 126) +* -pad: Other list operations. + (line 152) +* -partial: Function combinators. + (line 9) +* -partition: Partitioning. (line 74) +* -partition-after-item: Partitioning. (line 177) +* -partition-after-pred: Partitioning. (line 145) +* -partition-all: Partitioning. (line 86) +* -partition-all-in-steps: Partitioning. (line 109) +* -partition-before-item: Partitioning. (line 167) +* -partition-before-pred: Partitioning. (line 156) +* -partition-by: Partitioning. (line 121) +* -partition-by-header: Partitioning. (line 132) +* -partition-in-steps: Partitioning. (line 97) +* -permutations: Set operations. (line 52) +* -powerset: Set operations. (line 44) +* -prodfn: Function combinators. + (line 209) +* -product: Reductions. (line 181) +* -reduce: Reductions. (line 46) +* -reduce-from: Reductions. (line 8) +* -reduce-r: Reductions. (line 65) +* -reduce-r-from: Reductions. (line 27) +* -reductions: Reductions. (line 119) +* -reductions-from: Reductions. (line 87) +* -reductions-r: Reductions. (line 135) +* -reductions-r-from: Reductions. (line 103) +* -remove: Sublist selection. (line 23) +* -remove-at: List to list. (line 145) +* -remove-at-indices: List to list. (line 158) +* -remove-first: Sublist selection. (line 37) +* -remove-item: Sublist selection. (line 67) +* -remove-last: Sublist selection. (line 52) +* -repeat: Other list operations. + (line 19) +* -replace: List to list. (line 67) +* -replace-at: List to list. (line 120) +* -replace-first: List to list. (line 81) +* -replace-last: List to list. (line 95) +* -rotate: Other list operations. + (line 8) +* -rpartial: Function combinators. + (line 20) +* -running-product: Reductions. (line 191) +* -running-sum: Reductions. (line 169) +* -same-items?: Predicates. (line 72) +* -second-item: Other list operations. + (line 259) +* -select-by-indices: Sublist selection. (line 168) +* -select-column: Sublist selection. (line 198) +* -select-columns: Sublist selection. (line 179) +* -separate: Partitioning. (line 63) +* -setq: Binding. (line 274) +* -slice: Sublist selection. (line 85) +* -snoc: Other list operations. + (line 44) +* -some: Other list operations. + (line 221) +* -some-->: Threading macros. (line 83) +* -some->: Threading macros. (line 59) +* -some->>: Threading macros. (line 71) +* -sort: Other list operations. + (line 323) +* -splice: Maps. (line 90) +* -splice-list: Maps. (line 110) +* -split-at: Partitioning. (line 8) +* -split-on: Partitioning. (line 28) +* -split-when: Partitioning. (line 46) +* -split-with: Partitioning. (line 17) +* -sum: Reductions. (line 159) +* -table: Other list operations. + (line 163) +* -table-flat: Other list operations. + (line 182) +* -tails: Reductions. (line 213) +* -take: Sublist selection. (line 101) +* -take-last: Sublist selection. (line 112) +* -take-while: Sublist selection. (line 146) +* -third-item: Other list operations. + (line 271) +* -tree-map: Tree operations. (line 28) +* -tree-map-nodes: Tree operations. (line 39) +* -tree-mapreduce: Tree operations. (line 84) +* -tree-mapreduce-from: Tree operations. (line 103) +* -tree-reduce: Tree operations. (line 52) +* -tree-reduce-from: Tree operations. (line 69) +* -tree-seq: Tree operations. (line 8) +* -unfold: Unfolding. (line 25) +* -union: Set operations. (line 8) +* -unzip: Other list operations. + (line 124) +* -update-at: List to list. (line 132) +* -when-let: Binding. (line 9) +* -when-let*: Binding. (line 23) +* -zip: Other list operations. + (line 95) +* -zip-fill: Other list operations. + (line 116) +* -zip-with: Other list operations. + (line 79) + + + +Tag Table: +Node: Top946 +Node: Installation2425 +Node: Using in a package3001 +Node: Syntax highlighting of dash functions3365 +Node: Functions3748 +Node: Maps4959 +Ref: -map5254 +Ref: -map-when5595 +Ref: -map-first6173 +Ref: -map-last6651 +Ref: -map-indexed7124 +Ref: -annotate7604 +Ref: -splice8094 +Ref: -splice-list8875 +Ref: -mapcat9337 +Ref: -copy9713 +Node: Sublist selection9917 +Ref: -filter10110 +Ref: -remove10562 +Ref: -remove-first10968 +Ref: -remove-last11495 +Ref: -remove-item12016 +Ref: -non-nil12410 +Ref: -slice12569 +Ref: -take13101 +Ref: -take-last13409 +Ref: -drop13732 +Ref: -drop-last14005 +Ref: -take-while14265 +Ref: -drop-while14615 +Ref: -select-by-indices14971 +Ref: -select-columns15485 +Ref: -select-column16191 +Node: List to list16655 +Ref: -keep16847 +Ref: -concat17350 +Ref: -flatten17647 +Ref: -flatten-n18406 +Ref: -replace18793 +Ref: -replace-first19256 +Ref: -replace-last19752 +Ref: -insert-at20241 +Ref: -replace-at20568 +Ref: -update-at20958 +Ref: -remove-at21449 +Ref: -remove-at-indices21937 +Node: Reductions22519 +Ref: -reduce-from22688 +Ref: -reduce-r-from23454 +Ref: -reduce24221 +Ref: -reduce-r24950 +Ref: -reductions-from25821 +Ref: -reductions-r-from26536 +Ref: -reductions27261 +Ref: -reductions-r27886 +Ref: -count28521 +Ref: -sum28745 +Ref: -running-sum28934 +Ref: -product29227 +Ref: -running-product29436 +Ref: -inits29749 +Ref: -tails29997 +Ref: -common-prefix30244 +Ref: -common-suffix30541 +Ref: -min30838 +Ref: -min-by31064 +Ref: -max31587 +Ref: -max-by31812 +Node: Unfolding32340 +Ref: -iterate32579 +Ref: -unfold33024 +Node: Predicates33832 +Ref: -any?33956 +Ref: -all?34276 +Ref: -none?34606 +Ref: -only-some?34908 +Ref: -contains?35393 +Ref: -same-items?35782 +Ref: -is-prefix?36167 +Ref: -is-suffix?36490 +Ref: -is-infix?36813 +Node: Partitioning37167 +Ref: -split-at37355 +Ref: -split-with37640 +Ref: -split-on38043 +Ref: -split-when38719 +Ref: -separate39359 +Ref: -partition39801 +Ref: -partition-all40253 +Ref: -partition-in-steps40681 +Ref: -partition-all-in-steps41178 +Ref: -partition-by41663 +Ref: -partition-by-header42045 +Ref: -partition-after-pred42649 +Ref: -partition-before-pred43020 +Ref: -partition-before-item43398 +Ref: -partition-after-item43709 +Ref: -group-by44015 +Node: Indexing44452 +Ref: -elem-index44654 +Ref: -elem-indices45049 +Ref: -find-index45432 +Ref: -find-last-index45921 +Ref: -find-indices46425 +Ref: -grade-up46833 +Ref: -grade-down47236 +Node: Set operations47646 +Ref: -union47829 +Ref: -difference48271 +Ref: -intersection48688 +Ref: -powerset49125 +Ref: -permutations49338 +Ref: -distinct49638 +Node: Other list operations49962 +Ref: -rotate50187 +Ref: -repeat50557 +Ref: -cons*50820 +Ref: -snoc51207 +Ref: -interpose51620 +Ref: -interleave51918 +Ref: -zip-with52287 +Ref: -zip53004 +Ref: -zip-fill53810 +Ref: -unzip54133 +Ref: -cycle54667 +Ref: -pad55040 +Ref: -table55363 +Ref: -table-flat56152 +Ref: -first57160 +Ref: -some57532 +Ref: -last57841 +Ref: -first-item58175 +Ref: -second-item58591 +Ref: -third-item58871 +Ref: -fourth-item59149 +Ref: -fifth-item59415 +Ref: -last-item59677 +Ref: -butlast59969 +Ref: -sort60216 +Ref: -list60705 +Ref: -fix61036 +Node: Tree operations61576 +Ref: -tree-seq61772 +Ref: -tree-map62630 +Ref: -tree-map-nodes63073 +Ref: -tree-reduce63923 +Ref: -tree-reduce-from64805 +Ref: -tree-mapreduce65406 +Ref: -tree-mapreduce-from66266 +Ref: -clone67552 +Node: Threading macros67880 +Ref: ->68025 +Ref: ->>68516 +Ref: -->69021 +Ref: -as->69577 +Ref: -some->70032 +Ref: -some->>70406 +Ref: -some-->70842 +Node: Binding71313 +Ref: -when-let71525 +Ref: -when-let*72010 +Ref: -if-let72533 +Ref: -if-let*72928 +Ref: -let73545 +Ref: -let*79635 +Ref: -lambda80575 +Ref: -setq81372 +Node: Side-effects82188 +Ref: -each82382 +Ref: -each-while82789 +Ref: -each-indexed83149 +Ref: -each-r83667 +Ref: -each-r-while84100 +Ref: -dotimes84475 +Ref: -doto84778 +Ref: --doto85206 +Node: Destructive operations85481 +Ref: !cons85654 +Ref: !cdr85860 +Node: Function combinators86055 +Ref: -partial86329 +Ref: -rpartial86725 +Ref: -juxt87128 +Ref: -compose87560 +Ref: -applify88113 +Ref: -on88560 +Ref: -flip89086 +Ref: -const89398 +Ref: -cut89737 +Ref: -not90223 +Ref: -orfn90533 +Ref: -andfn90967 +Ref: -iteratefn91462 +Ref: -fixfn92165 +Ref: -prodfn93728 +Node: Development94796 +Node: Contribute95145 +Node: Changes95893 +Node: Contributors98891 +Node: Index100510 + +End Tag Table + + +Local Variables: +coding: utf-8 +End: diff --git a/elpa/dash-2.16.0/dir b/elpa/dash-2.16.0/dir new file mode 100644 index 0000000..49b1700 --- /dev/null +++ b/elpa/dash-2.16.0/dir @@ -0,0 +1,18 @@ +This is the file .../info/dir, which contains the +topmost node of the Info hierarchy, called (dir)Top. +The first time you invoke Info you start off looking at this node. + +File: dir, Node: Top This is the top of the INFO tree + + This (the Directory node) gives a menu of major topics. + Typing "q" exits, "H" lists all Info commands, "d" returns here, + "h" gives a primer for first-timers, + "mEmacs" visits the Emacs manual, etc. + + In Emacs, you can click mouse button 2 on a menu item or cross reference + to select it. + +* Menu: + +Emacs +* Dash: (dash.info). A modern list library for GNU Emacs diff --git a/elpa/dash-20190920.1035/dash-pkg.el b/elpa/dash-20190920.1035/dash-pkg.el deleted file mode 100644 index bd4357b..0000000 --- a/elpa/dash-20190920.1035/dash-pkg.el +++ /dev/null @@ -1,2 +0,0 @@ -;;; -*- no-byte-compile: t -*- -(define-package "dash" "20190920.1035" "A modern list library for Emacs" 'nil :commit "a743ae3da1d5869434c6f262bbe45ef30d87cb9c" :keywords '("lists") :authors '(("Magnar Sveen" . "magnars@gmail.com")) :maintainer '("Magnar Sveen" . "magnars@gmail.com")) diff --git a/elpa/dash-functional-20180107.1618/dash-functional-autoloads.el b/elpa/dash-functional-20180107.1618/dash-functional-autoloads.el new file mode 100644 index 0000000..533fa32 --- /dev/null +++ b/elpa/dash-functional-20180107.1618/dash-functional-autoloads.el @@ -0,0 +1,16 @@ +;;; dash-functional-autoloads.el --- automatically extracted autoloads +;; +;;; Code: +(add-to-list 'load-path (directory-file-name (or (file-name-directory #$) (car load-path)))) + +;;;### (autoloads nil nil ("dash-functional.el") (23441 26596 442795 +;;;;;; 456000)) + +;;;*** + +;; Local Variables: +;; version-control: never +;; no-byte-compile: t +;; no-update-autoloads: t +;; End: +;;; dash-functional-autoloads.el ends here diff --git a/elpa/dash-functional-20180107.1618/dash-functional-pkg.el b/elpa/dash-functional-20180107.1618/dash-functional-pkg.el new file mode 100644 index 0000000..22896d0 --- /dev/null +++ b/elpa/dash-functional-20180107.1618/dash-functional-pkg.el @@ -0,0 +1,2 @@ +;;; -*- no-byte-compile: t -*- +(define-package "dash-functional" "20180107.1618" "Collection of useful combinators for Emacs Lisp" '((dash "2.0.0") (emacs "24")) :commit "85e8f62b7a8ae0b4da307ddf16e4f1c3559d0d3f" :keywords '("lisp" "functions" "combinators")) diff --git a/elpa/dash-functional-20180107.1618/dash-functional.el b/elpa/dash-functional-20180107.1618/dash-functional.el new file mode 100644 index 0000000..502e8c1 --- /dev/null +++ b/elpa/dash-functional-20180107.1618/dash-functional.el @@ -0,0 +1,219 @@ +;;; dash-functional.el --- Collection of useful combinators for Emacs Lisp -*- lexical-binding: t -*- + +;; Copyright (C) 2013-2014 Free Software Foundation, Inc. + +;; Authors: Matus Goljer +;; Magnar Sveen +;; Version: 1.2.0 +;; Package-Version: 20180107.1618 +;; Package-Requires: ((dash "2.0.0") (emacs "24")) +;; Keywords: lisp functions combinators + +;; 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. + +;; This program is distributed in the hope that it will be useful, +;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +;; 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 . + +;;; Commentary: + +;; Collection of useful combinators for Emacs Lisp +;; +;; See documentation on https://github.com/magnars/dash.el#functions + +;;; Code: + +(require 'dash) + +(defun -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 called, the returned function calls FN with ARGS first and +then additional args." + (apply 'apply-partially fn args)) + +(defun -rpartial (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 called, the returned function calls FN with the additional +args first and then ARGS." + (lambda (&rest args-before) (apply fn (append args-before args)))) + +(defun -juxt (&rest fns) + "Takes a list of functions and returns a fn that is the +juxtaposition of those fns. The returned fn takes a variable +number of args, and returns a list containing the result of +applying each fn to the args (left-to-right)." + (lambda (&rest args) (mapcar (lambda (x) (apply x args)) fns))) + +(defun -compose (&rest fns) + "Takes a list of functions and returns a fn that is the +composition of those fns. The returned fn takes a variable +number of arguments, and returns the result of applying +each fn to the result of applying the previous fn to +the arguments (right-to-left)." + (lambda (&rest args) + (car (-reduce-r-from (lambda (fn xs) (list (apply fn xs))) + args fns)))) + +(defun -applify (fn) + "Changes an n-arity function FN to a 1-arity function that +expects a list with n items as arguments" + (apply-partially 'apply fn)) + +(defun -on (operator transformer) + "Return a function of two arguments that first applies +TRANSFORMER to each of them and then applies OPERATOR on the +results (in the same order). + +In types: (b -> b -> c) -> (a -> b) -> a -> a -> c" + (lambda (x y) (funcall operator (funcall transformer x) (funcall transformer y)))) + +(defun -flip (func) + "Swap the order of arguments for binary function FUNC. + +In types: (a -> b -> c) -> b -> a -> c" + (lambda (x y) (funcall func y x))) + +(defun -const (c) + "Return a function that returns C ignoring any additional arguments. + +In types: a -> b -> a" + (lambda (&rest _) c)) + +(defmacro -cut (&rest params) + "Take n-ary function and n arguments and specialize some of them. +Arguments denoted by <> will be left unspecialized. + +See SRFI-26 for detailed description." + (let* ((i 0) + (args (mapcar (lambda (_) (setq i (1+ i)) (make-symbol (format "D%d" i))) + (-filter (-partial 'eq '<>) params)))) + `(lambda ,args + ,(let ((body (--map (if (eq it '<>) (pop args) it) params))) + (if (eq (car params) '<>) + (cons 'funcall body) + body))))) + +(defun -not (pred) + "Take a unary predicate PRED and return a unary predicate +that returns t if PRED returns nil and nil if PRED returns +non-nil." + (lambda (x) (not (funcall pred x)))) + +(defun -orfn (&rest preds) + "Take list of unary predicates PREDS and return a unary +predicate with argument x that returns non-nil if at least one of +the PREDS returns non-nil on x. + +In types: [a -> Bool] -> a -> Bool" + (lambda (x) (-any? (-cut funcall <> x) preds))) + +(defun -andfn (&rest preds) + "Take list of unary predicates PREDS and return a unary +predicate with argument x that returns non-nil if all of the +PREDS returns non-nil on x. + +In types: [a -> Bool] -> a -> Bool" + (lambda (x) (-all? (-cut funcall <> x) preds))) + +(defun -iteratefn (fn n) + "Return a function FN composed N times with itself. + +FN is a unary function. If you need to use a function of higher +arity, use `-applify' first to turn it into a unary function. + +With n = 0, this acts as identity function. + +In types: (a -> a) -> Int -> a -> a. + +This function satisfies the following law: + + (funcall (-iteratefn fn n) init) = (-last-item (-iterate fn init (1+ n)))." + (lambda (x) (--dotimes n (setq x (funcall fn x))) x)) + +(defun -counter (&optional beg end inc) + "Return a closure that counts from BEG to END, with increment INC. + +The closure will return the next value in the counting sequence +each time it is called, and nil after END is reached. BEG +defaults to 0, INC defaults to 1, and if END is nil, the counter +will increment indefinitely. + +The closure accepts any number of arguments, which are discarded." + (let ((inc (or inc 1)) + (n (or beg 0))) + (lambda (&rest _) + (when (or (not end) (< n end)) + (prog1 n + (setq n (+ n inc))))))) + +(defvar -fixfn-max-iterations 1000 + "The default maximum number of iterations performed by `-fixfn' + unless otherwise specified.") + +(defun -fixfn (fn &optional equal-test halt-test) + "Return a function that computes the (least) fixpoint of FN. + +FN must be a unary function. The returned lambda takes a single +argument, X, the initial value for the fixpoint iteration. The +iteration halts when either of the following conditions is satisified: + + 1. Iteration converges to the fixpoint, with equality being + tested using EQUAL-TEST. If EQUAL-TEST is not specified, + `equal' is used. For functions over the floating point + numbers, it may be necessary to provide an appropriate + appoximate comparsion test. + + 2. HALT-TEST returns a non-nil value. HALT-TEST defaults to a + simple counter that returns t after `-fixfn-max-iterations', + to guard against infinite iteration. Otherwise, HALT-TEST + must be a function that accepts a single argument, the + current value of X, and returns non-nil as long as iteration + should continue. In this way, a more sophisticated + convergence test may be supplied by the caller. + +The return value of the lambda is either the fixpoint or, if +iteration halted before converging, a cons with car `halted' and +cdr the final output from HALT-TEST. + +In types: (a -> a) -> a -> a." + (let ((eqfn (or equal-test 'equal)) + (haltfn (or halt-test + (-not + (-counter 0 -fixfn-max-iterations))))) + (lambda (x) + (let ((re (funcall fn x)) + (halt? (funcall haltfn x))) + (while (and (not halt?) (not (funcall eqfn x re))) + (setq x re + re (funcall fn re) + halt? (funcall haltfn re))) + (if halt? (cons 'halted halt?) + re))))) + +(defun -prodfn (&rest fns) + "Take a list of n functions and return a function that takes a +list of length n, applying i-th function to i-th element of the +input list. Returns a list of length n. + +In types (for n=2): ((a -> b), (c -> d)) -> (a, c) -> (b, d) + +This function satisfies the following laws: + + (-compose (-prodfn f g ...) (-prodfn f\\=' g\\=' ...)) = (-prodfn (-compose f f\\=') (-compose g g\\=') ...) + (-prodfn f g ...) = (-juxt (-compose f (-partial \\='nth 0)) (-compose g (-partial \\='nth 1)) ...) + (-compose (-prodfn f g ...) (-juxt f\\=' g\\=' ...)) = (-juxt (-compose f f\\=') (-compose g g\\=') ...) + (-compose (-partial \\='nth n) (-prod f1 f2 ...)) = (-compose fn (-partial \\='nth n))" + (lambda (x) (-zip-with 'funcall fns x))) + +(provide 'dash-functional) + +;;; dash-functional.el ends here diff --git a/elpa/dash-readme.txt b/elpa/dash-readme.txt new file mode 100644 index 0000000..b6baaa2 --- /dev/null +++ b/elpa/dash-readme.txt @@ -0,0 +1,8 @@ +A modern list api for Emacs. + +See documentation on https://github.com/magnars/dash.el#functions + +**Please note** The lexical binding in this file is not utilised at the +moment. We will take full advantage of lexical binding in an upcoming 3.0 +release of Dash. In the meantime, we've added the pragma to avoid a bug that +you can read more about in https://github.com/magnars/dash.el/issues/130. diff --git a/elpa/diminish-20170419.1736/diminish-autoloads.el b/elpa/diminish-0.45/diminish-autoloads.el similarity index 88% rename from elpa/diminish-20170419.1736/diminish-autoloads.el rename to elpa/diminish-0.45/diminish-autoloads.el index 96b43a1..8877f42 100644 --- a/elpa/diminish-20170419.1736/diminish-autoloads.el +++ b/elpa/diminish-0.45/diminish-autoloads.el @@ -1,10 +1,12 @@ ;;; diminish-autoloads.el --- automatically extracted autoloads ;; ;;; Code: -(add-to-list 'load-path (directory-file-name (or (file-name-directory #$) (car load-path)))) + +(add-to-list 'load-path (directory-file-name + (or (file-name-directory #$) (car load-path)))) + -;;;### (autoloads nil "diminish" "diminish.el" (23441 26592 586778 -;;;;;; 335000)) +;;;### (autoloads nil "diminish" "diminish.el" (0 0 0 0)) ;;; Generated autoloads from diminish.el (autoload 'diminish "diminish" "\ @@ -47,11 +49,14 @@ what diminished modes would be on the mode-line if they were still minor. \(fn)" t nil) +(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "diminish" '("diminish"))) + ;;;*** ;; Local Variables: ;; version-control: never ;; no-byte-compile: t ;; no-update-autoloads: t +;; coding: utf-8 ;; End: ;;; diminish-autoloads.el ends here diff --git a/elpa/diminish-0.45/diminish-pkg.el b/elpa/diminish-0.45/diminish-pkg.el new file mode 100644 index 0000000..1c11d6f --- /dev/null +++ b/elpa/diminish-0.45/diminish-pkg.el @@ -0,0 +1,2 @@ +;;; -*- no-byte-compile: t -*- +(define-package "diminish" "0.45" "Diminished modes are minor modes with no modeline display" 'nil :commit "0211de96b7cfba9c9dc8d2d392dbd4ccdb22bc65" :keywords '("extensions" "diminish" "minor" "codeprose") :authors '(("Will Mengarini" . "seldon@eskimo.com")) :maintainer '("Martin Yrjölä" . "martin.yrjola@gmail.com") :url "https://github.com/myrjola/diminish.el") diff --git a/elpa/diminish-20170419.1736/diminish.el b/elpa/diminish-0.45/diminish.el similarity index 97% rename from elpa/diminish-20170419.1736/diminish.el rename to elpa/diminish-0.45/diminish.el index 20ab4ec..1cb56f0 100644 --- a/elpa/diminish-20170419.1736/diminish.el +++ b/elpa/diminish-0.45/diminish.el @@ -5,11 +5,13 @@ ;; Author: Will Mengarini ;; Maintainer: Martin Yrjölä ;; URL: -;; Package-Version: 20170419.1736 +;; Package-Version: 0.45 ;; Created: Th 19 Feb 98 ;; Version: 0.45 ;; Keywords: extensions, diminish, minor, codeprose +;; This file is part of GNU Emacs. + ;; 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 2, or (at your option) @@ -20,10 +22,10 @@ ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ;; GNU General Public License for more details. -;; You should have received a copy of the GNU General Public License along with -;; this program; see the file LICENSE. If not, write to the write to the Free -;; Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA -;; 02110-1301, USA. +;; You should have received a copy of the GNU General Public License +;; along with GNU Emacs; see the file COPYING. If not, write to the +;; Free Software Foundation, Inc., 59 Temple Place - Suite 330, +;; Boston, MA 02111-1307, USA. ;;; Commentary: @@ -179,8 +181,7 @@ to TO-WHAT if it's > 1 char long & doesn't already begin with a space." (let ((minor (assq mode minor-mode-alist))) (when minor (progn (callf or to-what "") - (when (and (stringp to-what) - (> (length to-what) 1)) + (when (> (length to-what) 1) (or (= (string-to-char to-what) ?\ ) (callf2 concat " " to-what))) (or (assq mode diminished-mode-alist) diff --git a/elpa/diminish-20170419.1736/diminish-pkg.el b/elpa/diminish-20170419.1736/diminish-pkg.el deleted file mode 100644 index 8913efb..0000000 --- a/elpa/diminish-20170419.1736/diminish-pkg.el +++ /dev/null @@ -1,2 +0,0 @@ -;;; -*- no-byte-compile: t -*- -(define-package "diminish" "20170419.1736" "Diminished modes are minor modes with no modeline display" 'nil :commit "565a983a39d2e2cffab5df13b34f3b6116723208" :keywords '("extensions" "diminish" "minor" "codeprose") :authors '(("Will Mengarini" . "seldon@eskimo.com")) :maintainer '("Martin Yrjölä" . "martin.yrjola@gmail.com") :url "https://github.com/myrjola/diminish.el") diff --git a/elpa/diminish-readme.txt b/elpa/diminish-readme.txt new file mode 100644 index 0000000..3864811 --- /dev/null +++ b/elpa/diminish-readme.txt @@ -0,0 +1,70 @@ +Minor modes each put a word on the mode line to signify that they're +active. This can cause other displays, such as % of file that point is +at, to run off the right side of the screen. For some minor modes, such +as mouse-avoidance-mode, the display is a waste of space, since users +typically set the mode in their .emacs & never change it. For other +modes, such as my jiggle-mode, it's a waste because there's already a +visual indication of whether the mode is in effect. + +A diminished mode is a minor mode that has had its mode line +display diminished, usually to nothing, although diminishing to a +shorter word or a single letter is also supported. This package +implements diminished modes. + +You can use this package either interactively or from your .emacs file. +In either case, first you'll need to copy this file to a directory that +appears in your load-path. `load-path' is the name of a variable that +contains a list of directories Emacs searches for files to load. +To prepend another directory to load-path, put a line like +(add-to-list 'load-path "c:/My_Directory") in your .emacs file. + +To create diminished modes interactively, type + M-x load-library +to get a prompt like + Load library: +and respond `diminish' (unquoted). Then type + M-x diminish +to get a prompt like + Diminish what minor mode: +and respond with the name of some minor mode, like mouse-avoidance-mode. +You'll then get this prompt: + To what mode-line display: +Respond by just hitting if you want the name of the mode +completely removed from the mode line. If you prefer, you can abbreviate +the name. If your abbreviation is 2 characters or more, such as "Av", +it'll be displayed as a separate word on the mode line, just like minor +modes' names. If it's a single character, such as "V", it'll be scrunched +up against the previous word, so for example if the undiminished mode line +display had been "Abbrev Fill Avoid", it would become "Abbrev FillV". +Multiple single-letter diminished modes will all be scrunched together. +The display of undiminished modes will not be affected. + +To find out what the mode line would look like if all diminished modes +were still minor, type M-x diminished-modes. This displays in the echo +area the complete list of minor or diminished modes now active, but +displays them all as minor. They remain diminished on the mode line. + +To convert a diminished mode back to a minor mode, type M-x diminish-undo +to get a prompt like + Restore what diminished mode: +Respond with the name of some diminished mode. To convert all +diminished modes back to minor modes, respond to that prompt +with `diminished-modes' (unquoted, & note the hyphen). + +When you're responding to the prompts for mode names, you can use +completion to avoid extra typing; for example, m o u SPC SPC SPC +is usually enough to specify mouse-avoidance-mode. Mode names +typically end in "-mode", but for historical reasons +auto-fill-mode is named by "auto-fill-function". + +To create diminished modes noninteractively in your .emacs file, put +code like + (require 'diminish) + (diminish 'abbrev-mode "Abv") + (diminish 'jiggle-mode) + (diminish 'mouse-avoidance-mode "M") +near the end of your .emacs file. It should be near the end so that any +minor modes your .emacs loads will already have been loaded by the time +they're to be converted to diminished modes. + +To diminish a major mode, (setq mode-name "whatever") in the mode hook. diff --git a/elpa/exec-path-from-shell-20190426.2227/exec-path-from-shell-autoloads.el b/elpa/exec-path-from-shell-1.12/exec-path-from-shell-autoloads.el similarity index 100% rename from elpa/exec-path-from-shell-20190426.2227/exec-path-from-shell-autoloads.el rename to elpa/exec-path-from-shell-1.12/exec-path-from-shell-autoloads.el diff --git a/elpa/exec-path-from-shell-1.12/exec-path-from-shell-pkg.el b/elpa/exec-path-from-shell-1.12/exec-path-from-shell-pkg.el new file mode 100644 index 0000000..483c5a2 --- /dev/null +++ b/elpa/exec-path-from-shell-1.12/exec-path-from-shell-pkg.el @@ -0,0 +1,2 @@ +;;; -*- no-byte-compile: t -*- +(define-package "exec-path-from-shell" "1.12" "Get environment variables such as $PATH from the shell" 'nil :commit "76cd6e3fa8a7dac937af7e40507843dfae4f9184" :keywords '("unix" "environment") :authors '(("Steve Purcell" . "steve@sanityinc.com")) :maintainer '("Steve Purcell" . "steve@sanityinc.com") :url "https://github.com/purcell/exec-path-from-shell") diff --git a/elpa/exec-path-from-shell-20190426.2227/exec-path-from-shell.el b/elpa/exec-path-from-shell-1.12/exec-path-from-shell.el similarity index 98% rename from elpa/exec-path-from-shell-20190426.2227/exec-path-from-shell.el rename to elpa/exec-path-from-shell-1.12/exec-path-from-shell.el index 712a9a2..7c623a1 100644 --- a/elpa/exec-path-from-shell-20190426.2227/exec-path-from-shell.el +++ b/elpa/exec-path-from-shell-1.12/exec-path-from-shell.el @@ -5,7 +5,7 @@ ;; Author: Steve Purcell ;; Keywords: unix, environment ;; URL: https://github.com/purcell/exec-path-from-shell -;; Package-Version: 20190426.2227 +;; Package-Version: 1.12 ;; Package-X-Original-Version: 0 ;; This file is not part of GNU Emacs. @@ -181,8 +181,6 @@ shell-escaped, so they may contain $ etc." Execute the shell according to `exec-path-from-shell-arguments'. The result is a list of (NAME . VALUE) pairs." - (when (file-remote-p default-directory) - (error "You cannot run exec-path-from-shell from a remote buffer (Tramp, etc.)")) (let* ((random-default (md5 (format "%s%s%s" (emacs-pid) (random) (current-time)))) (dollar-names (mapcar (lambda (n) (format "${%s-%s}" n random-default)) names)) (values (split-string (exec-path-from-shell-printf diff --git a/elpa/exec-path-from-shell-20190426.2227/exec-path-from-shell-pkg.el b/elpa/exec-path-from-shell-20190426.2227/exec-path-from-shell-pkg.el deleted file mode 100644 index dc3a54b..0000000 --- a/elpa/exec-path-from-shell-20190426.2227/exec-path-from-shell-pkg.el +++ /dev/null @@ -1,2 +0,0 @@ -;;; -*- no-byte-compile: t -*- -(define-package "exec-path-from-shell" "20190426.2227" "Get environment variables such as $PATH from the shell" 'nil :commit "3cfedb8791397ed50ee66bc0a7cbee5b9d78245c" :keywords '("unix" "environment") :authors '(("Steve Purcell" . "steve@sanityinc.com")) :maintainer '("Steve Purcell" . "steve@sanityinc.com") :url "https://github.com/purcell/exec-path-from-shell") diff --git a/elpa/exec-path-from-shell-readme.txt b/elpa/exec-path-from-shell-readme.txt new file mode 100644 index 0000000..802f114 --- /dev/null +++ b/elpa/exec-path-from-shell-readme.txt @@ -0,0 +1,45 @@ +On OS X (and perhaps elsewhere) the $PATH environment variable and +`exec-path' used by a windowed Emacs instance will usually be the +system-wide default path, rather than that seen in a terminal +window. + +This library allows the user to set Emacs' `exec-path' and $PATH +from the shell path, so that `shell-command', `compile' and the +like work as expected. + +It also allows other environment variables to be retrieved from the +shell, so that Emacs will see the same values you get in a terminal. + +If you use a non-POSIX-standard shell like "tcsh" or "fish", your +shell will be asked to execute "sh" as a subshell in order to print +out the variables in a format which can be reliably parsed. "sh" +must be a POSIX-compliant shell in this case. + +Note that shell variables which have not been exported as +environment variables (e.g. using the "export" keyword) may not be +visible to `exec-path-from-shell'. + +Installation: + +ELPA packages are available on Marmalade and MELPA. Alternatively, +place this file on a directory in your `load-path', and explicitly +require it. + +Usage: + + (require 'exec-path-from-shell) ;; if not using the ELPA package + (exec-path-from-shell-initialize) + +Customize `exec-path-from-shell-variables' to modify the list of +variables imported. + +If you use your Emacs config on other platforms, you can instead +make initialization conditional as follows: + + (when (memq window-system '(mac ns)) + (exec-path-from-shell-initialize)) + +Alternatively, you can use `exec-path-from-shell-copy-envs' or +`exec-path-from-shell-copy-env' directly, e.g. + + (exec-path-from-shell-copy-env "PYTHONPATH") diff --git a/elpa/hydra-20191125.955/hydra-autoloads.el b/elpa/hydra-0.15.0/hydra-autoloads.el similarity index 100% rename from elpa/hydra-20191125.955/hydra-autoloads.el rename to elpa/hydra-0.15.0/hydra-autoloads.el diff --git a/elpa/hydra-20191125.955/hydra-examples.el b/elpa/hydra-0.15.0/hydra-examples.el similarity index 100% rename from elpa/hydra-20191125.955/hydra-examples.el rename to elpa/hydra-0.15.0/hydra-examples.el diff --git a/elpa/hydra-20191125.955/hydra-ox.el b/elpa/hydra-0.15.0/hydra-ox.el similarity index 100% rename from elpa/hydra-20191125.955/hydra-ox.el rename to elpa/hydra-0.15.0/hydra-ox.el diff --git a/elpa/hydra-20191125.955/hydra-pkg.el b/elpa/hydra-0.15.0/hydra-pkg.el similarity index 78% rename from elpa/hydra-20191125.955/hydra-pkg.el rename to elpa/hydra-0.15.0/hydra-pkg.el index a688756..dae2c6e 100644 --- a/elpa/hydra-20191125.955/hydra-pkg.el +++ b/elpa/hydra-0.15.0/hydra-pkg.el @@ -1,4 +1,4 @@ -(define-package "hydra" "20191125.955" "Make bindings that stick around." +(define-package "hydra" "0.15.0" "Make bindings that stick around." '((cl-lib "0.5") (lv "0")) :keywords diff --git a/elpa/hydra-20191125.955/hydra.el b/elpa/hydra-0.15.0/hydra.el similarity index 97% rename from elpa/hydra-20191125.955/hydra.el rename to elpa/hydra-0.15.0/hydra.el index 3508532..4137823 100644 --- a/elpa/hydra-20191125.955/hydra.el +++ b/elpa/hydra-0.15.0/hydra.el @@ -33,7 +33,7 @@ ;; heads can be called in succession with only a short extension. ;; The Hydra is vanquished once Hercules, any binding that isn't the ;; Hydra's head, arrives. Note that Hercules, besides vanquishing the -;; Hydra, will still serve his original purpose, calling his proper +;; Hydra, will still serve his orignal purpose, calling his proper ;; command. This makes the Hydra very seamless, it's like a minor ;; mode that disables itself automagically. ;; @@ -211,33 +211,15 @@ the body or the head." (declare-function posframe-hide "posframe") (declare-function posframe-poshandler-window-center "posframe") -(defvar hydra-posframe-show-params - '(:internal-border-width 1 - :internal-border-color "red" - :poshandler posframe-poshandler-window-center) - "List of parameters passed to `posframe-show'.") - -(defvar hydra--posframe-timer nil - "Timer for hiding posframe hint.") - (defun hydra-posframe-show (str) (require 'posframe) - (when hydra--posframe-timer - (cancel-timer hydra--posframe-timer)) - (setq hydra--posframe-timer nil) - (apply #'posframe-show - " *hydra-posframe*" - :string str - hydra-posframe-show-params)) + (posframe-show + " *hydra-posframe*" + :string str + :poshandler #'posframe-poshandler-window-center)) (defun hydra-posframe-hide () - (require 'posframe) - (unless hydra--posframe-timer - (setq hydra--posframe-timer - (run-with-idle-timer - 0 nil (lambda () - (setq hydra--posframe-timer nil) - (posframe-hide " *hydra-posframe*")))))) + (posframe-hide " *hydra-posframe*")) (defvar hydra-hint-display-alist (list (list 'lv #'lv-message #'lv-delete-window) @@ -253,6 +235,14 @@ the body or the head." (const posframe)) :group 'hydra) +(define-obsolete-variable-alias + 'hydra-lv 'hydra-hint-display-type "0.14.0" + "Use either `hydra-hint-display-type' or `hydra-set-property' :verbosity.") + +(defcustom hydra-lv t + "When non-nil, `lv-message' (not `message') will be used to display hints." + :type 'boolean) + (defcustom hydra-verbose nil "When non-nil, hydra will issue some non essential style warnings." :type 'boolean) @@ -325,19 +315,18 @@ Exitable only through a blue head.") (around hydra-around-find-function-search-for-symbol-advice (symbol type library) activate) "Navigate to hydras with `find-function-search-for-symbol'." - (prog1 ad-do-it - (when (symbolp symbol) - ;; The original function returns (cons (current-buffer) (point)) - ;; if it found the point. - (unless (cdr ad-return-value) - (with-current-buffer (find-file-noselect library) - (let ((sn (symbol-name symbol))) - (when (and (null type) - (string-match "\\`\\(hydra-[a-z-A-Z0-9]+\\)/\\(.*\\)\\'" sn) - (re-search-forward (concat "(defhydra " (match-string 1 sn)) - nil t)) - (goto-char (match-beginning 0))) - (cons (current-buffer) (point))))))))) + ad-do-it + ;; The orignial function returns (cons (current-buffer) (point)) + ;; if it found the point. + (unless (cdr ad-return-value) + (with-current-buffer (find-file-noselect library) + (let ((sn (symbol-name symbol))) + (when (and (null type) + (string-match "\\`\\(hydra-[a-z-A-Z0-9]+\\)/\\(.*\\)\\'" sn) + (re-search-forward (concat "(defhydra " (match-string 1 sn)) + nil t)) + (goto-char (match-beginning 0))) + (cons (current-buffer) (point))))))) ;;* Universal Argument (defvar hydra-base-map @@ -1072,7 +1061,7 @@ If CELL-FORMATS is nil, `hydra-cell-format' is used for all columns." (mapconcat #'identity x " ")))) (defun hydra-reset-radios (names) - "Set variables NAMES to their defaults. + "Set varibles NAMES to their defaults. NAMES should be defined by `defhydradio' or similar." (dolist (n names) (set n (aref (get n 'range) 0)))) @@ -1123,7 +1112,7 @@ Each head of NORMALIZED-HEADS must have a column property." finally return balanced-heads-groups)) (defun hydra--generate-matrix (heads-groups) - "Return a copy of HEADS-GROUPS decorated with table formatting information. + "Return a copy of HEADS-GROUPS decorated with table formating information. Details of modification: 2 virtual heads acting as table header were added to each heads-group. Each head is decorated with 2 new properties max-doc-len and max-key-len @@ -1174,7 +1163,7 @@ representing the maximum dimension of their owning group. (defun hydra--hint-from-matrix (body heads-matrix) - "Generate a formatted table-style docstring according to BODY and HEADS-MATRIX. + "Generate a formated table-style docstring according to BODY and HEADS-MATRIX. HEADS-MATRIX is expected to be a list of heads with following features: Each heads must have the same length Each head must have a property max-key-len and max-doc-len." diff --git a/elpa/hydra-readme.txt b/elpa/hydra-readme.txt new file mode 100644 index 0000000..04ef5ff --- /dev/null +++ b/elpa/hydra-readme.txt @@ -0,0 +1,51 @@ +This package can be used to tie related commands into a family of +short bindings with a common prefix - a Hydra. + +Once you summon the Hydra (through the prefixed binding), all the +heads can be called in succession with only a short extension. +The Hydra is vanquished once Hercules, any binding that isn't the +Hydra's head, arrives. Note that Hercules, besides vanquishing the +Hydra, will still serve his orignal purpose, calling his proper +command. This makes the Hydra very seamless, it's like a minor +mode that disables itself automagically. + +Here's an example Hydra, bound in the global map (you can use any +keymap in place of `global-map'): + + (defhydra hydra-zoom (global-map "") + "zoom" + ("g" text-scale-increase "in") + ("l" text-scale-decrease "out")) + +It allows to start a command chain either like this: +" gg4ll5g", or " lgllg". + +Here's another approach, when you just want a "callable keymap": + + (defhydra hydra-toggle (:color blue) + "toggle" + ("a" abbrev-mode "abbrev") + ("d" toggle-debug-on-error "debug") + ("f" auto-fill-mode "fill") + ("t" toggle-truncate-lines "truncate") + ("w" whitespace-mode "whitespace") + ("q" nil "cancel")) + +This binds nothing so far, but if you follow up with: + + (global-set-key (kbd "C-c C-v") 'hydra-toggle/body) + +you will have bound "C-c C-v a", "C-c C-v d" etc. + +Knowing that `defhydra' defines e.g. `hydra-toggle/body' command, +you can nest Hydras if you wish, with `hydra-toggle/body' possibly +becoming a blue head of another Hydra. + +If you want to learn all intricacies of using `defhydra' without +having to figure it all out from this source code, check out the +wiki: https://github.com/abo-abo/hydra/wiki. There's a wealth of +information there. Everyone is welcome to bring the existing pages +up to date and add new ones. + +Additionally, the file hydra-examples.el serves to demo most of the +functionality. diff --git a/elpa/lv-20191214.1357/lv-autoloads.el b/elpa/lv-0.15.0/lv-autoloads.el similarity index 100% rename from elpa/lv-20191214.1357/lv-autoloads.el rename to elpa/lv-0.15.0/lv-autoloads.el diff --git a/elpa/lv-0.15.0/lv-pkg.el b/elpa/lv-0.15.0/lv-pkg.el new file mode 100644 index 0000000..71a6594 --- /dev/null +++ b/elpa/lv-0.15.0/lv-pkg.el @@ -0,0 +1,2 @@ +;;; -*- no-byte-compile: t -*- +(define-package "lv" "0.15.0" "Other echo area" 'nil :commit "f27fce1b2f0a9162e159557bdeb2c0c94defb4d2" :authors '(("Oleh Krehel")) :maintainer '("Oleh Krehel")) diff --git a/elpa/lv-20191214.1357/lv.el b/elpa/lv-0.15.0/lv.el similarity index 81% rename from elpa/lv-20191214.1357/lv.el rename to elpa/lv-0.15.0/lv.el index 879fd61..c0dcd3d 100644 --- a/elpa/lv-20191214.1357/lv.el +++ b/elpa/lv-0.15.0/lv.el @@ -1,5 +1,5 @@ ;;; lv.el --- Other echo area -;; Package-Version: 20191214.1357 +;; Package-Version: 0.15.0 ;; Copyright (C) 2015 Free Software Foundation, Inc. @@ -44,11 +44,6 @@ :group 'lv :type 'boolean) -(defcustom lv-use-padding nil - "Whether to use horizontal padding in the LV window." - :group 'lv - :type 'boolean) - (defface lv-separator '((((class color) (background light)) :background "grey80") (((class color) (background dark)) :background "grey30")) @@ -61,11 +56,6 @@ Only the background color is significant." "Holds the current LV window.") (defvar display-line-numbers) -(defvar display-fill-column-indicator) -(defvar tab-line-format) - -(defvar lv-window-hook nil - "Hook to run by `lv-window' when a new window is created.") (defun lv-window () "Ensure that LV window is live and return it." @@ -84,14 +74,10 @@ Only the background color is significant." (set-window-hscroll lv-wnd 0) (setq window-size-fixed t) (setq mode-line-format nil) - (setq header-line-format nil) - (setq tab-line-format nil) (setq cursor-type nil) (setq display-line-numbers nil) - (setq display-fill-column-indicator nil) (set-window-dedicated-p lv-wnd t) - (set-window-parameter lv-wnd 'no-other-window t) - (run-hooks 'lv-window-hook)) + (set-window-parameter lv-wnd 'no-other-window t)) (select-window ori))))) (defvar golden-ratio-mode) @@ -99,14 +85,6 @@ Only the background color is significant." (defvar lv-force-update nil "When non-nil, `lv-message' will refresh even for the same string.") -(defun lv--pad-to-center (str width) - "Pad STR with spaces on the left to be centered to WIDTH." - (let* ((strs (split-string str "\n")) - (padding (make-string - (/ (- width (length (car strs))) 2) - ?\ ))) - (mapconcat (lambda (s) (concat padding s)) strs "\n"))) - (defun lv-message (format-string &rest args) "Set LV window contents to (`format' FORMAT-STRING ARGS)." (let* ((str (apply #'format format-string args)) @@ -114,8 +92,6 @@ Only the background color is significant." deactivate-mark golden-ratio-mode) (with-selected-window (lv-window) - (when lv-use-padding - (setq str (lv--pad-to-center str (window-width)))) (unless (and (string= (buffer-string) str) (null lv-force-update)) (delete-region (point-min) (point-max)) diff --git a/elpa/lv-20191214.1357/lv-pkg.el b/elpa/lv-20191214.1357/lv-pkg.el deleted file mode 100644 index 3d746c6..0000000 --- a/elpa/lv-20191214.1357/lv-pkg.el +++ /dev/null @@ -1,2 +0,0 @@ -;;; -*- no-byte-compile: t -*- -(define-package "lv" "20191214.1357" "Other echo area" 'nil :commit "9db28034d7d61bfeff89899633b958f22befc53d" :authors '(("Oleh Krehel")) :maintainer '("Oleh Krehel")) diff --git a/elpa/lv-readme.txt b/elpa/lv-readme.txt new file mode 100644 index 0000000..05ad5b7 --- /dev/null +++ b/elpa/lv-readme.txt @@ -0,0 +1,9 @@ +This package provides `lv-message' intended to be used in place of +`message' when semi-permanent hints are needed, in order to not +interfere with Echo Area. + + "Я тихо-тихо пiдглядаю, + І тiшуся собi, як бачу то, + Шо страшить i не пiдпускає, + А iншi п’ють тебе, як воду пiсок." + -- Андрій Кузьменко, L.V. diff --git a/elpa/use-package-20191126.2034/dir b/elpa/use-package-2.4/dir similarity index 100% rename from elpa/use-package-20191126.2034/dir rename to elpa/use-package-2.4/dir diff --git a/elpa/use-package-20191126.2034/use-package-autoloads.el b/elpa/use-package-2.4/use-package-autoloads.el similarity index 99% rename from elpa/use-package-20191126.2034/use-package-autoloads.el rename to elpa/use-package-2.4/use-package-autoloads.el index a374fcc..503f5db 100644 --- a/elpa/use-package-20191126.2034/use-package-autoloads.el +++ b/elpa/use-package-2.4/use-package-autoloads.el @@ -90,7 +90,6 @@ this file. Usage: package. This is useful if the package is being lazily loaded, and you wish to conditionally call functions in your `:init' block that are defined in the package. -:hook Specify hook(s) to attach this package to. :bind Bind keys, and define autoloads for the bound commands. :bind* Bind keys, and define autoloads for the bound commands, @@ -100,7 +99,7 @@ this file. Usage: :bind-keymap* Like `:bind-keymap', but overrides all minor mode bindings :defer Defer loading of a package -- this is implied when using - `:commands', `:bind', `:bind*', `:mode', `:magic', `:hook', + `:commands', `:bind', `:bind*', `:mode', `:magic', `:magic-fallback', or `:interpreter'. This can be an integer, to force loading after N seconds of idle time, if the package has not already been loaded. diff --git a/elpa/use-package-20191126.2034/use-package-bind-key.el b/elpa/use-package-2.4/use-package-bind-key.el similarity index 100% rename from elpa/use-package-20191126.2034/use-package-bind-key.el rename to elpa/use-package-2.4/use-package-bind-key.el diff --git a/elpa/use-package-20191126.2034/use-package-core.el b/elpa/use-package-2.4/use-package-core.el similarity index 99% rename from elpa/use-package-20191126.2034/use-package-core.el rename to elpa/use-package-2.4/use-package-core.el index 83b9b29..7fc840f 100644 --- a/elpa/use-package-20191126.2034/use-package-core.el +++ b/elpa/use-package-2.4/use-package-core.el @@ -651,8 +651,7 @@ extending any keys already present." ,(when (eq use-package-verbose 'debug) `(message ,(format "Compiling package %s" name-string))) ,(unless (plist-get args :no-require) - `(unless (featurep ',name-symbol) - (load ,name-string nil t)))))))))) + `(load ,name-string nil t))))))))) ;; Certain keywords imply :defer, if :demand was not specified. (when (and (not (plist-member args :demand)) @@ -1029,7 +1028,7 @@ meaning: "use-package statistics" "Show current statistics gathered about use-package declarations." (setq tabulated-list-format - ;; The sum of column width is 80 characters: + ;; The sum of column width is 80 caracters: #[("Package" 25 t) ("Status" 13 t) ("Last Event" 23 t) @@ -1420,7 +1419,7 @@ no keyword implies `:all'." (defun use-package-handler/:custom-face (name _keyword args rest state) "Generate use-package custom-face keyword code." (use-package-concat - (mapcar #'(lambda (def) `(custom-set-faces (backquote ,def))) args) + (mapcar #'(lambda (def) `(custom-set-faces (quote ,def))) args) (use-package-process-keywords name rest state))) ;;;; :init @@ -1534,7 +1533,6 @@ this file. Usage: package. This is useful if the package is being lazily loaded, and you wish to conditionally call functions in your `:init' block that are defined in the package. -:hook Specify hook(s) to attach this package to. :bind Bind keys, and define autoloads for the bound commands. :bind* Bind keys, and define autoloads for the bound commands, @@ -1544,7 +1542,7 @@ this file. Usage: :bind-keymap* Like `:bind-keymap', but overrides all minor mode bindings :defer Defer loading of a package -- this is implied when using - `:commands', `:bind', `:bind*', `:mode', `:magic', `:hook', + `:commands', `:bind', `:bind*', `:mode', `:magic', `:magic-fallback', or `:interpreter'. This can be an integer, to force loading after N seconds of idle time, if the package has not already been loaded. diff --git a/elpa/use-package-20191126.2034/use-package-delight.el b/elpa/use-package-2.4/use-package-delight.el similarity index 100% rename from elpa/use-package-20191126.2034/use-package-delight.el rename to elpa/use-package-2.4/use-package-delight.el diff --git a/elpa/use-package-20191126.2034/use-package-diminish.el b/elpa/use-package-2.4/use-package-diminish.el similarity index 100% rename from elpa/use-package-20191126.2034/use-package-diminish.el rename to elpa/use-package-2.4/use-package-diminish.el diff --git a/elpa/use-package-20191126.2034/use-package-ensure.el b/elpa/use-package-2.4/use-package-ensure.el similarity index 100% rename from elpa/use-package-20191126.2034/use-package-ensure.el rename to elpa/use-package-2.4/use-package-ensure.el diff --git a/elpa/use-package-20191126.2034/use-package-jump.el b/elpa/use-package-2.4/use-package-jump.el similarity index 100% rename from elpa/use-package-20191126.2034/use-package-jump.el rename to elpa/use-package-2.4/use-package-jump.el diff --git a/elpa/use-package-20191126.2034/use-package-lint.el b/elpa/use-package-2.4/use-package-lint.el similarity index 100% rename from elpa/use-package-20191126.2034/use-package-lint.el rename to elpa/use-package-2.4/use-package-lint.el diff --git a/elpa/use-package-20191126.2034/use-package-pkg.el b/elpa/use-package-2.4/use-package-pkg.el similarity index 76% rename from elpa/use-package-20191126.2034/use-package-pkg.el rename to elpa/use-package-2.4/use-package-pkg.el index 3e5195f..bf01364 100644 --- a/elpa/use-package-20191126.2034/use-package-pkg.el +++ b/elpa/use-package-2.4/use-package-pkg.el @@ -1,4 +1,4 @@ -(define-package "use-package" "20191126.2034" "A configuration macro for simplifying your .emacs" +(define-package "use-package" "2.4" "A configuration macro for simplifying your .emacs" '((emacs "24.3") (bind-key "2.4")) :keywords diff --git a/elpa/use-package-20191126.2034/use-package.el b/elpa/use-package-2.4/use-package.el similarity index 100% rename from elpa/use-package-20191126.2034/use-package.el rename to elpa/use-package-2.4/use-package.el diff --git a/elpa/use-package-20191126.2034/use-package.info b/elpa/use-package-2.4/use-package.info similarity index 99% rename from elpa/use-package-20191126.2034/use-package.info rename to elpa/use-package-2.4/use-package.info index 9e6a1d8..8058d9c 100644 --- a/elpa/use-package-20191126.2034/use-package.info +++ b/elpa/use-package-2.4/use-package.info @@ -901,7 +901,7 @@ While the ‘:after’ keyword delays loading until the dependencies are loaded, the somewhat simpler ‘:requires’ keyword simply never loads the package if the dependencies are not available at the time the ‘use-package’ declaration is encountered. By "available" in this -context it means that ‘foo’ is available of ‘(featurep 'foo)’ evaluates +context it means that ‘foo’ is available of ‘(featurep 'foo)’ evaulates to a non-nil value. For example: (use-package abbrev diff --git a/elpa/use-package-readme.txt b/elpa/use-package-readme.txt new file mode 100644 index 0000000..7b5889b --- /dev/null +++ b/elpa/use-package-readme.txt @@ -0,0 +1,8 @@ +The `use-package' declaration macro allows you to isolate package +configuration in your ".emacs" in a way that is performance-oriented and, +well, just tidy. I created it because I have over 80 packages that I use +in Emacs, and things were getting difficult to manage. Yet with this +utility my total load time is just under 1 second, with no loss of +functionality! + +Please see README.md from the same repository for documentation. diff --git a/init.el b/init.el index 79ff518..89766ff 100644 --- a/init.el +++ b/init.el @@ -52,6 +52,10 @@ (package-install package)) (require package))) +(add-to-list 'package-pinned-packages '("diminish" . "melpa-stable")) +(add-to-list 'package-pinned-packages '("use-package" . "melpa-stable")) +(add-to-list 'package-pinned-packages '("bind-key" . "melpa-stable")) + (put 'use-package 'lisp-indent-function 1) (setq use-package-verbose t use-package-minimum-reported-time 0.01) @@ -533,9 +537,11 @@ ;; * Some essential packages -(use-package dash) +(use-package dash + :pin "melpa-stable") -(use-package hydra) +(use-package hydra + :pin "melpa-stable") (use-package db-utils :commands (endless/fill-or-unfill @@ -621,6 +627,7 @@ :commands counsel-projectile) (use-package exec-path-from-shell + :pin "melpa-stable" :commands (exec-path-from-shell-copy-envs)) @@ -2683,6 +2690,7 @@ With given ARG, display files in `db/important-document-path’." :commands (mastodon)) (use-package multiple-cursors + :pin "melpa-stable" :ensure t :commands (mc/edit-lines mc/mark-next-like-this @@ -2696,6 +2704,7 @@ With given ARG, display files in `db/important-document-path’." (require 'org-ref-url-utils))) (use-package page-break-lines + :pin "melpa-stable" :commands (page-break-lines-mode) :diminish page-break-lines-mode)