From fcc946551f38879dd25d0f4a947046341a57ba6c Mon Sep 17 00:00:00 2001 From: Andreas Gerler Date: Fri, 11 Feb 2022 16:27:33 +0100 Subject: [PATCH] update dash Signed-off-by: Andreas Gerler --- bba.org | 2 +- .../dash-autoloads.el | 6 +- .../dash-pkg.el | 4 +- .../dash.el | 1374 ++++++--- .../dash.info | 2610 ++++++++--------- .../dir | 0 6 files changed, 2302 insertions(+), 1694 deletions(-) rename elpa/{dash-20210105.414 => dash-20210826.1149}/dash-autoloads.el (87%) rename elpa/{dash-20210105.414 => dash-20210826.1149}/dash-pkg.el (64%) rename elpa/{dash-20210105.414 => dash-20210826.1149}/dash.el (67%) rename elpa/{dash-20210105.414 => dash-20210826.1149}/dash.info (76%) rename elpa/{dash-20210105.414 => dash-20210826.1149}/dir (100%) diff --git a/bba.org b/bba.org index ad4c4605..7ed0726d 100644 --- a/bba.org +++ b/bba.org @@ -415,7 +415,7 @@ Some key bindings taken from [[https://ebzzry.github.io/emacs-pairs.html][emacs- (if (>= emacs-major-version 24) (progn (add-to-list 'load-path "~/.emacs.d/elpa/smartparens-20201229.1937") - (add-to-list 'load-path "~/.emacs.d/elpa/dash-20210105.414") + (add-to-list 'load-path "~/.emacs.d/elpa/dash-20210826.1149") (require 'smartparens) (smartparens-global-mode 1) (defmacro def-pairs (pairs) diff --git a/elpa/dash-20210105.414/dash-autoloads.el b/elpa/dash-20210826.1149/dash-autoloads.el similarity index 87% rename from elpa/dash-20210105.414/dash-autoloads.el rename to elpa/dash-20210826.1149/dash-autoloads.el index 0b16ab1c..3a96693f 100644 --- a/elpa/dash-20210105.414/dash-autoloads.el +++ b/elpa/dash-20210826.1149/dash-autoloads.el @@ -53,7 +53,11 @@ See `dash-fontify-mode' for more information on Dash-Fontify mode. \(fn &optional ARG)" t nil) -(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "dash" '("!cdr" "!cons" "--" "->" "-a" "-butlast" "-c" "-d" "-e" "-f" "-gr" "-i" "-keep" "-l" "-m" "-non" "-only-some" "-p" "-r" "-s" "-t" "-u" "-value-to-list" "-when-let" "-zip" "dash-"))) +(autoload 'dash-register-info-lookup "dash" "\ +Register the Dash Info manual with `info-lookup-symbol'. +This allows Dash symbols to be looked up with \\[info-lookup-symbol]." t nil) + +(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "dash" '("!cdr" "!cons" "--" "->" "-a" "-butlast" "-c" "-d" "-e" "-f" "-gr" "-i" "-juxt" "-keep" "-l" "-m" "-no" "-o" "-p" "-r" "-s" "-t" "-u" "-value-to-list" "-when-let" "-zip" "dash-"))) ;;;*** diff --git a/elpa/dash-20210105.414/dash-pkg.el b/elpa/dash-20210826.1149/dash-pkg.el similarity index 64% rename from elpa/dash-20210105.414/dash-pkg.el rename to elpa/dash-20210826.1149/dash-pkg.el index 230a6df8..7dc2d7a3 100644 --- a/elpa/dash-20210105.414/dash-pkg.el +++ b/elpa/dash-20210826.1149/dash-pkg.el @@ -1,6 +1,6 @@ -(define-package "dash" "20210105.414" "A modern list library for Emacs" +(define-package "dash" "20210826.1149" "A modern list library for Emacs" '((emacs "24")) - :commit "8879c41d30211ae2e72298e354fdffef627a3836" :authors + :commit "da167c51e9fd167a48d06c7c0ee8e3ac7abd9718" :authors '(("Magnar Sveen" . "magnars@gmail.com")) :maintainer '("Magnar Sveen" . "magnars@gmail.com") diff --git a/elpa/dash-20210105.414/dash.el b/elpa/dash-20210826.1149/dash.el similarity index 67% rename from elpa/dash-20210105.414/dash.el rename to elpa/dash-20210826.1149/dash.el index 6548f8d4..6386c5f6 100644 --- a/elpa/dash-20210105.414/dash.el +++ b/elpa/dash-20210826.1149/dash.el @@ -3,7 +3,7 @@ ;; Copyright (C) 2012-2021 Free Software Foundation, Inc. ;; Author: Magnar Sveen -;; Version: 2.17.0 +;; Version: 2.19.1 ;; Package-Requires: ((emacs "24")) ;; Keywords: extensions, lisp ;; Homepage: https://github.com/magnars/dash.el @@ -43,134 +43,148 @@ (defmacro !cons (car cdr) "Destructive: Set CDR to the cons of CAR and CDR." + (declare (debug (form symbolp))) `(setq ,cdr (cons ,car ,cdr))) (defmacro !cdr (list) "Destructive: Set LIST to the cdr of LIST." + (declare (debug (symbolp))) `(setq ,list (cdr ,list))) (defmacro --each (list &rest body) - "Anaphoric form of `-each'." - (declare (debug (form body)) - (indent 1)) - (let ((l (make-symbol "list"))) + "Evaluate BODY for each element of LIST and return nil. +Each element of LIST in turn is bound to `it' and its index +within LIST to `it-index' before evaluating BODY. +This is the anaphoric counterpart to `-each'." + (declare (debug (form body)) (indent 1)) + (let ((l (make-symbol "list")) + (i (make-symbol "i"))) `(let ((,l ,list) - (it-index 0)) + (,i 0) + it it-index) + (ignore it it-index) (while ,l - (let ((it (car ,l))) - ,@body) - (setq it-index (1+ it-index)) - (!cdr ,l))))) + (setq it (pop ,l) it-index ,i ,i (1+ ,i)) + ,@body)))) -(defmacro -doto (init &rest forms) - "Evaluate INIT and thread the result as the 2nd argument to other FORMS. -INIT is evaluated once. Its result is passed to FORMS, which are -then evaluated sequentially. Returns the target form." - (declare (indent 1)) - (let ((retval (make-symbol "value"))) - `(let ((,retval ,init)) - ,@(mapcar (lambda (form) - (if (listp form) - `(,(car form) ,retval ,@(cdr form)) - `(funcall form ,retval))) - forms) - ,retval))) +(defun -each (list fn) + "Call FN on each element of LIST. +Return nil; this function is intended for side effects. -(defmacro --doto (eval-initial-value &rest forms) - "Anaphoric form of `-doto'. -Note: `it' need not be used in each form." - (declare (indent 1)) - `(let ((it ,eval-initial-value)) - ,@forms - it)) +Its anaphoric counterpart is `--each'. -(defun -each (list fn) - "Call FN with every item in LIST. Return nil, used for side-effects only." +For access to the current element's index in LIST, see +`-each-indexed'." (declare (indent 1)) - (--each list (funcall fn it))) + (ignore (mapc fn list))) (defalias '--each-indexed '--each) (defun -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'. + "Call FN on each index and element of LIST. +For each ITEM at INDEX in LIST, call (funcall FN INDEX ITEM). +Return nil; this function is intended for side effects. See also: `-map-indexed'." (declare (indent 1)) (--each list (funcall fn it-index it))) (defmacro --each-while (list pred &rest body) - "Anaphoric form of `-each-while'." - (declare (debug (form form body)) - (indent 2)) - (let ((l (make-symbol "list"))) + "Evaluate BODY for each item in LIST, while PRED evaluates to non-nil. +Each element of LIST in turn is bound to `it' and its index +within LIST to `it-index' before evaluating PRED or BODY. Once +an element is reached for which PRED evaluates to nil, no further +BODY is evaluated. The return value is always nil. +This is the anaphoric counterpart to `-each-while'." + (declare (debug (form form body)) (indent 2)) + (let ((l (make-symbol "list")) + (i (make-symbol "i")) + (elt (make-symbol "elt"))) `(let ((,l ,list) - (it-index 0) - it) - (ignore it) - (while (when ,l - (setq it (pop ,l)) - ,pred) - ,@body - (setq it-index (1+ it-index)))))) + (,i 0) + ,elt it it-index) + (ignore it it-index) + (while (and ,l (setq ,elt (pop ,l) it ,elt it-index ,i) ,pred) + (setq it ,elt it-index ,i ,i (1+ ,i)) + ,@body)))) (defun -each-while (list pred fn) - "Call FN with every item in LIST while (PRED item) is non-nil. -Return nil, used for side-effects only." + "Call FN on each ITEM in LIST, while (PRED ITEM) is non-nil. +Once an ITEM is reached for which PRED returns nil, FN is no +longer called. Return nil; this function is intended for side +effects. + +Its anaphoric counterpart is `--each-while'." (declare (indent 2)) (--each-while list (funcall pred it) (funcall fn it))) (defmacro --each-r (list &rest body) - "Anaphoric form of `-each-r'." - (declare (debug (form body)) - (indent 1)) - (let ((v (make-symbol "vector"))) - ;; Implementation note: building vector is considerably faster + "Evaluate BODY for each element of LIST in reversed order. +Each element of LIST in turn, starting at its end, is bound to +`it' and its index within LIST to `it-index' before evaluating +BODY. The return value is always nil. +This is the anaphoric counterpart to `-each-r'." + (declare (debug (form body)) (indent 1)) + (let ((v (make-symbol "vector")) + (i (make-symbol "i"))) + ;; Implementation note: building a vector is considerably faster ;; than building a reversed list (vector takes less memory, so - ;; there is less GC), plus length comes naturally. In-place - ;; 'nreverse' would be faster still, but BODY would be able to see - ;; that, even if modification was reversed before we return. + ;; there is less GC), plus `length' comes naturally. In-place + ;; `nreverse' would be faster still, but BODY would be able to see + ;; that, even if the modification was undone before we return. `(let* ((,v (vconcat ,list)) - (it-index (length ,v)) - it) - (while (> it-index 0) - (setq it-index (1- it-index)) - (setq it (aref ,v it-index)) + (,i (length ,v)) + it it-index) + (ignore it it-index) + (while (> ,i 0) + (setq ,i (1- ,i) it-index ,i it (aref ,v ,i)) ,@body)))) (defun -each-r (list fn) - "Call FN with every item in LIST in reversed order. - Return nil, used for side-effects only." + "Call FN on each element of LIST in reversed order. +Return nil; this function is intended for side effects. + +Its anaphoric counterpart is `--each-r'." (--each-r list (funcall fn it))) (defmacro --each-r-while (list pred &rest body) - "Anaphoric form of `-each-r-while'." - (declare (debug (form form body)) - (indent 2)) - (let ((v (make-symbol "vector"))) + "Eval BODY for each item in reversed LIST, while PRED evals to non-nil. +Each element of LIST in turn, starting at its end, is bound to +`it' and its index within LIST to `it-index' before evaluating +PRED or BODY. Once an element is reached for which PRED +evaluates to nil, no further BODY is evaluated. The return value +is always nil. +This is the anaphoric counterpart to `-each-r-while'." + (declare (debug (form form body)) (indent 2)) + (let ((v (make-symbol "vector")) + (i (make-symbol "i")) + (elt (make-symbol "elt"))) `(let* ((,v (vconcat ,list)) - (it-index (length ,v)) - it) - (while (> it-index 0) - (setq it-index (1- it-index)) - (setq it (aref ,v it-index)) - (if (not ,pred) - (setq it-index -1) - ,@body))))) + (,i (length ,v)) + ,elt it it-index) + (ignore it it-index) + (while (when (> ,i 0) + (setq ,i (1- ,i) it-index ,i) + (setq ,elt (aref ,v ,i) it ,elt) + ,pred) + (setq it-index ,i it ,elt) + ,@body)))) (defun -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." + "Call FN on each ITEM in reversed LIST, while (PRED ITEM) is non-nil. +Once an ITEM is reached for which PRED returns nil, FN is no +longer called. Return nil; this function is intended for side +effects. + +Its anaphoric counterpart is `--each-r-while'." (--each-r-while list (funcall pred it) (funcall fn it))) (defmacro --dotimes (num &rest body) - "Evaluate BODY NUM times, presumably for side-effects. + "Evaluate BODY NUM times, presumably for side effects. BODY is evaluated with the local variable `it' temporarily bound to successive integers running from 0, inclusive, to NUM, exclusive. BODY is not evaluated if NUM is less than 1. - -This is the anaphoric version of `-dotimes'." +This is the anaphoric counterpart to `-dotimes'." (declare (debug (form body)) (indent 1)) (let ((n (make-symbol "num")) (i (make-symbol "i"))) @@ -183,258 +197,411 @@ This is the anaphoric version of `-dotimes'." ,@body)))) (defun -dotimes (num fn) - "Call FN NUM times, presumably for side-effects. + "Call FN NUM times, presumably for side effects. FN is called with a single argument on successive integers running from 0, inclusive, to NUM, exclusive. FN is not called -if NUM is less than 1." +if NUM is less than 1. + +This function's anaphoric counterpart is `--dotimes'." (declare (indent 1)) (--dotimes num (funcall fn it))) (defun -map (fn list) - "Return a new list consisting of the result of applying FN to the items in LIST." + "Apply FN to each item in LIST and return the list of results. + +This function's anaphoric counterpart is `--map'." (mapcar fn list)) (defmacro --map (form list) - "Anaphoric form of `-map'." - (declare (debug (form form))) - `(mapcar (lambda (it) ,form) ,list)) - -(defmacro --reduce-from (form initial-value list) - "Anaphoric form of `-reduce-from'." + "Eval FORM for each item in LIST and return the list of results. +Each element of LIST in turn is bound to `it' before evaluating +FORM. +This is the anaphoric counterpart to `-map'." + (declare (debug (def-form form))) + `(mapcar (lambda (it) (ignore it) ,form) ,list)) + +(defmacro --reduce-from (form init list) + "Accumulate a value by evaluating FORM across LIST. +This macro is like `--each' (which see), but it additionally +provides an accumulator variable `acc' which it successively +binds to the result of evaluating FORM for the current LIST +element before processing the next element. For the first +element, `acc' is initialized with the result of evaluating INIT. +The return value is the resulting value of `acc'. If LIST is +empty, FORM is not evaluated, and the return value is the result +of INIT. +This is the anaphoric counterpart to `-reduce-from'." (declare (debug (form form form))) - `(let ((acc ,initial-value)) + `(let ((acc ,init)) (--each ,list (setq acc ,form)) acc)) -(defun -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. +(defun -reduce-from (fn init list) + "Reduce the function FN across LIST, starting with INIT. +Return the result of applying FN to INIT and the first element of +LIST, then applying FN to that result and the second element, +etc. If LIST is empty, return INIT without calling FN. -In the anaphoric form `--reduce-from', the accumulated value is -exposed as symbol `acc'. +This function's anaphoric counterpart is `--reduce-from'. -See also: `-reduce', `-reduce-r'" - (--reduce-from (funcall fn acc it) initial-value list)) +For other folds, see also `-reduce' and `-reduce-r'." + (--reduce-from (funcall fn acc it) init list)) (defmacro --reduce (form list) - "Anaphoric form of `-reduce'." + "Accumulate a value by evaluating FORM across LIST. +This macro is like `--reduce-from' (which see), except the first +element of LIST is taken as INIT. Thus if LIST contains a single +item, it is returned without evaluating FORM. If LIST is empty, +FORM is evaluated with `it' and `acc' bound to nil. +This is the anaphoric counterpart to `-reduce'." (declare (debug (form form))) (let ((lv (make-symbol "list-value"))) `(let ((,lv ,list)) (if ,lv (--reduce-from ,form (car ,lv) (cdr ,lv)) - (let (acc it) ,form))))) + ;; Explicit nil binding pacifies lexical "variable left uninitialized" + ;; warning. See issue #377 and upstream https://bugs.gnu.org/47080. + (let ((acc nil) (it nil)) + (ignore acc it) + ,form))))) (defun -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. + "Reduce the function FN across LIST. +Return the result of applying FN to the first two elements of +LIST, then applying FN to that result and the third element, etc. +If LIST contains a single element, return it without calling FN. +If LIST is empty, return the result of calling FN with no +arguments. -In the anaphoric form `--reduce', the accumulated value is -exposed as symbol `acc'. +This function's anaphoric counterpart is `--reduce'. -See also: `-reduce-from', `-reduce-r'" +For other folds, see also `-reduce-from' and `-reduce-r'." (if list (-reduce-from fn (car list) (cdr list)) (funcall fn))) -(defmacro --reduce-r-from (form initial-value list) - "Anaphoric version of `-reduce-r-from'." +(defmacro --reduce-r-from (form init list) + "Accumulate a value by evaluating FORM across LIST in reverse. +This macro is like `--reduce-from', except it starts from the end +of LIST. +This is the anaphoric counterpart to `-reduce-r-from'." (declare (debug (form form form))) - `(--reduce-from ,form ,initial-value (reverse ,list))) + `(let ((acc ,init)) + (--each-r ,list (setq acc ,form)) + acc)) -(defun -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. +(defun -reduce-r-from (fn init list) + "Reduce the function FN across LIST in reverse, starting with INIT. +Return the result of applying FN to the last element of LIST and +INIT, then applying FN to the second-to-last element and the +previous result of FN, etc. That is, the first argument of FN is +the current element, and its second argument the accumulated +value. If LIST is empty, return INIT without calling FN. -Note: this function works the same as `-reduce-from' but the -operation associates from right instead of from left. +This function is like `-reduce-from' but the operation associates +from the right rather than left. In other words, it starts from +the end of LIST and flips the arguments to FN. Conceptually, it +is like replacing the conses in LIST with applications of FN, and +its last link with INIT, and evaluating the resulting expression. -See also: `-reduce-r', `-reduce'" - (--reduce-r-from (funcall fn it acc) initial-value list)) +This function's anaphoric counterpart is `--reduce-r-from'. + +For other folds, see also `-reduce-r' and `-reduce'." + (--reduce-r-from (funcall fn it acc) init list)) (defmacro --reduce-r (form list) - "Anaphoric version of `-reduce-r'." + "Accumulate a value by evaluating FORM across LIST in reverse order. +This macro is like `--reduce', except it starts from the end of +LIST. +This is the anaphoric counterpart to `-reduce-r'." (declare (debug (form form))) `(--reduce ,form (reverse ,list))) (defun -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' but the operation -associates from right instead of from left. - -See also: `-reduce-r-from', `-reduce'" + "Reduce the function FN across LIST in reverse. +Return the result of applying FN to the last two elements of +LIST, then applying FN to the third-to-last element and the +previous result of FN, etc. That is, the first argument of FN is +the current element, and its second argument the accumulated +value. If LIST contains a single element, return it without +calling FN. If LIST is empty, return the result of calling FN +with no arguments. + +This function is like `-reduce' but the operation associates from +the right rather than left. In other words, it starts from the +end of LIST and flips the arguments to FN. Conceptually, it is +like replacing the conses in LIST with applications of FN, +ignoring its last link, and evaluating the resulting expression. + +This function's anaphoric counterpart is `--reduce-r'. + +For other folds, see also `-reduce-r-from' and `-reduce'." (if list (--reduce-r (funcall fn it acc) list) (funcall fn))) +(defmacro --reductions-from (form init list) + "Return a list of FORM's intermediate reductions across LIST. +That is, a list of the intermediate values of the accumulator +when `--reduce-from' (which see) is called with the same +arguments. +This is the anaphoric counterpart to `-reductions-from'." + (declare (debug (form form form))) + `(nreverse + (--reduce-from (cons (let ((acc (car acc))) (ignore acc) ,form) acc) + (list ,init) + ,list))) + (defun -reductions-from (fn init list) - "Return a list of the intermediate values of the reduction. + "Return a list of FN's intermediate reductions across LIST. +That is, a list of the intermediate values of the accumulator +when `-reduce-from' (which see) is called with the same +arguments. -See `-reduce-from' for explanation of the arguments. +This function's anaphoric counterpart is `--reductions-from'. -See also: `-reductions', `-reductions-r', `-reduce-r'" - (nreverse (--reduce-from (cons (funcall fn (car acc) it) acc) (list init) list))) +For other folds, see also `-reductions' and `-reductions-r'." + (--reductions-from (funcall fn acc it) init list)) + +(defmacro --reductions (form list) + "Return a list of FORM's intermediate reductions across LIST. +That is, a list of the intermediate values of the accumulator +when `--reduce' (which see) is called with the same arguments. +This is the anaphoric counterpart to `-reductions'." + (declare (debug (form form))) + (let ((lv (make-symbol "list-value"))) + `(let ((,lv ,list)) + (if ,lv + (--reductions-from ,form (car ,lv) (cdr ,lv)) + (let (acc it) + (ignore acc it) + (list ,form)))))) (defun -reductions (fn list) - "Return a list of the intermediate values of the reduction. + "Return a list of FN's intermediate reductions across LIST. +That is, a list of the intermediate values of the accumulator +when `-reduce' (which see) is called with the same arguments. -See `-reduce' for explanation of the arguments. +This function's anaphoric counterpart is `--reductions'. -See also: `-reductions-from', `-reductions-r', `-reduce-r'" - (and list (-reductions-from fn (car list) (cdr list)))) +For other folds, see also `-reductions' and `-reductions-r'." + (if list + (--reductions-from (funcall fn acc it) (car list) (cdr list)) + (list (funcall fn)))) + +(defmacro --reductions-r-from (form init list) + "Return a list of FORM's intermediate reductions across reversed LIST. +That is, a list of the intermediate values of the accumulator +when `--reduce-r-from' (which see) is called with the same +arguments. +This is the anaphoric counterpart to `-reductions-r-from'." + (declare (debug (form form form))) + `(--reduce-r-from (cons (let ((acc (car acc))) (ignore acc) ,form) acc) + (list ,init) + ,list)) (defun -reductions-r-from (fn init list) - "Return a list of the intermediate values of the reduction. - -See `-reduce-r-from' for explanation of the arguments. - -See also: `-reductions-r', `-reductions', `-reduce'" - (--reduce-r-from (cons (funcall fn it (car acc)) acc) (list init) list)) + "Return a list of FN's intermediate reductions across reversed LIST. +That is, a list of the intermediate values of the accumulator +when `-reduce-r-from' (which see) is called with the same +arguments. + +This function's anaphoric counterpart is `--reductions-r-from'. + +For other folds, see also `-reductions' and `-reductions-r'." + (--reductions-r-from (funcall fn it acc) init list)) + +(defmacro --reductions-r (form list) + "Return a list of FORM's intermediate reductions across reversed LIST. +That is, a list of the intermediate values of the accumulator +when `--reduce-re' (which see) is called with the same arguments. +This is the anaphoric counterpart to `-reductions-r'." + (declare (debug (form list))) + (let ((lv (make-symbol "list-value"))) + `(let ((,lv (reverse ,list))) + (if ,lv + (--reduce-from (cons (let ((acc (car acc))) (ignore acc) ,form) acc) + (list (car ,lv)) + (cdr ,lv)) + ;; Explicit nil binding pacifies lexical "variable left uninitialized" + ;; warning. See issue #377 and upstream https://bugs.gnu.org/47080. + (let ((acc nil) (it nil)) + (ignore acc it) + (list ,form)))))) (defun -reductions-r (fn list) - "Return a list of the intermediate values of the reduction. + "Return a list of FN's intermediate reductions across reversed LIST. +That is, a list of the intermediate values of the accumulator +when `-reduce-r' (which see) is called with the same arguments. -See `-reduce-r' for explanation of the arguments. +This function's anaphoric counterpart is `--reductions-r'. -See also: `-reductions-r-from', `-reductions', `-reduce'" - (when list - (let ((rev (reverse list))) - (--reduce-from (cons (funcall fn it (car acc)) acc) - (list (car rev)) - (cdr rev))))) +For other folds, see also `-reductions-r-from' and +`-reductions'." + (if list + (--reductions-r (funcall fn it acc) list) + (list (funcall fn)))) (defmacro --filter (form list) - "Anaphoric form of `-filter'. - -See also: `--remove'." + "Return a new list of the items in LIST for which FORM evals to non-nil. +Each element of LIST in turn is bound to `it' and its index +within LIST to `it-index' before evaluating FORM. +This is the anaphoric counterpart to `-filter'. +For the opposite operation, see also `--remove'." (declare (debug (form form))) (let ((r (make-symbol "result"))) `(let (,r) - (--each ,list (when ,form (!cons it ,r))) + (--each ,list (when ,form (push it ,r))) (nreverse ,r)))) (defun -filter (pred list) - "Return a new list of the items in LIST for which PRED returns a non-nil value. + "Return a new list of the items in LIST for which PRED returns non-nil. -Alias: `-select' +Alias: `-select'. -See also: `-keep', `-remove'." +This function's anaphoric counterpart is `--filter'. + +For similar operations, see also `-keep' and `-remove'." (--filter (funcall pred it) list)) (defalias '-select '-filter) (defalias '--select '--filter) (defmacro --remove (form list) - "Anaphoric form of `-remove'. - -See also `--filter'." + "Return a new list of the items in LIST for which FORM evals to nil. +Each element of LIST in turn is bound to `it' and its index +within LIST to `it-index' before evaluating FORM. +This is the anaphoric counterpart to `-remove'. +For the opposite operation, see also `--filter'." (declare (debug (form form))) `(--filter (not ,form) ,list)) (defun -remove (pred list) "Return a new list of the items in LIST for which PRED returns nil. -Alias: `-reject' +Alias: `-reject'. + +This function's anaphoric counterpart is `--remove'. -See also: `-filter'." +For similar operations, see also `-keep' and `-filter'." (--remove (funcall pred it) list)) (defalias '-reject '-remove) (defalias '--reject '--remove) +(defmacro --remove-first (form list) + "Remove the first item from LIST for which FORM evals to non-nil. +Each element of LIST in turn is bound to `it' and its index +within LIST to `it-index' before evaluating FORM. This is a +non-destructive operation, but only the front of LIST leading up +to the removed item is a copy; the rest is LIST's original tail. +If no item is removed, then the result is a complete copy. +This is the anaphoric counterpart to `-remove-first'." + (declare (debug (form form))) + (let ((front (make-symbol "front")) + (tail (make-symbol "tail"))) + `(let ((,tail ,list) ,front) + (--each-while ,tail (not ,form) + (push (pop ,tail) ,front)) + (if ,tail + (nconc (nreverse ,front) (cdr ,tail)) + (nreverse ,front))))) + (defun -remove-first (pred list) - "Return a new list with the first item matching PRED removed. + "Remove the first item from LIST for which PRED returns non-nil. +This is a non-destructive operation, but only the front of LIST +leading up to the removed item is a copy; the rest is LIST's +original tail. If no item is removed, then the result is a +complete copy. -Alias: `-reject-first' +Alias: `-reject-first'. -See also: `-remove', `-map-first'" - (let (front) - (while (and list (not (funcall pred (car list)))) - (push (car list) front) - (!cdr list)) - (if list - (-concat (nreverse front) (cdr list)) - (nreverse front)))) +This function's anaphoric counterpart is `--remove-first'. -(defmacro --remove-first (form list) - "Anaphoric form of `-remove-first'." - (declare (debug (form form))) - `(-remove-first (lambda (it) ,form) ,list)) +See also `-map-first', `-remove-item', and `-remove-last'." + (--remove-first (funcall pred it) list)) (defalias '-reject-first '-remove-first) (defalias '--reject-first '--remove-first) +(defmacro --remove-last (form list) + "Remove the last item from LIST for which FORM evals to non-nil. +Each element of LIST in turn is bound to `it' before evaluating +FORM. The result is a copy of LIST regardless of whether an +element is removed. +This is the anaphoric counterpart to `-remove-last'." + (declare (debug (form form))) + `(nreverse (--remove-first ,form (reverse ,list)))) + (defun -remove-last (pred list) - "Return a new list with the last item matching PRED removed. + "Remove the last item from LIST for which PRED returns non-nil. +The result is a copy of LIST regardless of whether an element is +removed. -Alias: `-reject-last' +Alias: `-reject-last'. -See also: `-remove', `-map-last'" - (nreverse (-remove-first pred (reverse list)))) +This function's anaphoric counterpart is `--remove-last'. -(defmacro --remove-last (form list) - "Anaphoric form of `-remove-last'." - (declare (debug (form form))) - `(-remove-last (lambda (it) ,form) ,list)) +See also `-map-last', `-remove-item', and `-remove-first'." + (--remove-last (funcall pred it) list)) (defalias '-reject-last '-remove-last) (defalias '--reject-last '--remove-last) -(defun -remove-item (item list) - "Remove all occurrences of ITEM from LIST. - -Comparison is done with `equal'." - (declare (pure t) (side-effect-free t)) - (--remove (equal it item) list)) +(defalias '-remove-item #'remove + "Return a copy of LIST with all occurrences of ITEM removed. +The comparison is done with `equal'. +\n(fn ITEM LIST)") (defmacro --keep (form list) - "Anaphoric form of `-keep'." + "Eval FORM for each item in LIST and return the non-nil results. +Like `--filter', but returns the non-nil results of FORM instead +of the corresponding elements of LIST. Each element of LIST in +turn is bound to `it' and its index within LIST to `it-index' +before evaluating FORM. +This is the anaphoric counterpart to `-keep'." (declare (debug (form form))) (let ((r (make-symbol "result")) (m (make-symbol "mapped"))) `(let (,r) - (--each ,list (let ((,m ,form)) (when ,m (!cons ,m ,r)))) + (--each ,list (let ((,m ,form)) (when ,m (push ,m ,r)))) (nreverse ,r)))) (defun -keep (fn list) - "Return a new list of the non-nil results of applying FN to the items in LIST. + "Return a new list of the non-nil results of applying FN to each item in LIST. +Like `-filter', but returns the non-nil results of FN instead of +the corresponding elements of LIST. -If you want to select the original items satisfying a predicate use `-filter'." +Its anaphoric counterpart is `--keep'." (--keep (funcall fn it) list)) (defun -non-nil (list) - "Return all non-nil elements of LIST." + "Return a copy of LIST with all nil items removed." (declare (pure t) (side-effect-free t)) - (-remove 'null list)) + (--filter it list)) (defmacro --map-indexed (form list) - "Anaphoric form of `-map-indexed'." + "Eval FORM for each item in LIST and return the list of results. +Each element of LIST in turn is bound to `it' and its index +within LIST to `it-index' before evaluating FORM. This is like +`--map', but additionally makes `it-index' available to FORM. + +This is the anaphoric counterpart to `-map-indexed'." (declare (debug (form form))) (let ((r (make-symbol "result"))) `(let (,r) (--each ,list - (!cons ,form ,r)) + (push ,form ,r)) (nreverse ,r)))) (defun -map-indexed (fn list) - "Return a new list consisting of the result of (FN index item) for each item in LIST. + "Apply FN to each index and item in LIST and return the list of results. +This is like `-map', but FN takes two arguments: the index of the +current element within LIST, and the element itself. -In the anaphoric form `--map-indexed', the index is exposed as symbol `it-index'. +This function's anaphoric counterpart is `--map-indexed'. -See also: `-each-indexed'." +For a side-effecting variant, see also `-each-indexed'." (--map-indexed (funcall fn it-index it) list)) (defmacro --map-when (pred rep list) @@ -472,6 +639,7 @@ See also: `-map-when', `-replace-first'" (defmacro --map-first (pred rep list) "Anaphoric form of `-map-first'." + (declare (debug (def-form def-form form))) `(-map-first (lambda (it) ,pred) (lambda (it) (ignore it) ,rep) ,list)) (defun -map-last (pred rep list) @@ -482,6 +650,7 @@ See also: `-map-when', `-replace-last'" (defmacro --map-last (pred rep list) "Anaphoric form of `-map-last'." + (declare (debug (def-form def-form form))) `(-map-last (lambda (it) ,pred) (lambda (it) (ignore it) ,rep) ,list)) (defun -replace (old new list) @@ -524,12 +693,15 @@ Thus function FN should return a list." (defmacro --iterate (form init n) "Anaphoric version of `-iterate'." (declare (debug (form form form))) - (let ((res (make-symbol "result"))) - `(let ((it ,init) ,res) - (dotimes (_ ,n) - (push it ,res) - (setq it ,form)) - (nreverse ,res)))) + (let ((res (make-symbol "result")) + (len (make-symbol "n"))) + `(let ((,len ,n)) + (when (> ,len 0) + (let* ((it ,init) + (,res (list it))) + (dotimes (_ (1- ,len)) + (push (setq it ,form) ,res)) + (nreverse ,res)))))) (defun -iterate (fun init n) "Return a list of iterated applications of FUN to INIT. @@ -563,7 +735,9 @@ See also: `-flatten-n'" See also: `-flatten'" (declare (pure t) (side-effect-free t)) - (-last-item (--iterate (--mapcat (-list it) it) list (1+ num)))) + (dotimes (_ num) + (setq list (apply #'append (mapcar #'-list list)))) + list) (defun -concat (&rest lists) "Return a new list with the concatenation of the elements in the supplied LISTS." @@ -595,6 +769,7 @@ See also: `-splice-list', `-insert-at'" (defmacro --splice (pred form list) "Anaphoric form of `-splice'." + (declare (debug (def-form def-form form))) `(-splice (lambda (it) ,pred) (lambda (it) ,form) ,list)) (defun -splice-list (pred new-list list) @@ -605,16 +780,22 @@ See also: `-splice', `-insert-at'" (defmacro --splice-list (pred new-list list) "Anaphoric form of `-splice-list'." + (declare (debug (def-form form form))) `(-splice-list (lambda (it) ,pred) ,new-list ,list)) (defun -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." +The last 2 elements of ARGS are used as the final cons of the +result, so if the final element of ARGS is not a list, the result +is a dotted list. With no ARGS, return nil." (declare (pure t) (side-effect-free t)) - (-reduce-r 'cons args)) + (let* ((len (length args)) + (tail (nthcdr (- len 2) args)) + (last (cdr tail))) + (if (null last) + (car args) + (setcdr tail (car last)) + args))) (defun -snoc (list elem &rest elements) "Append ELEM to the end of the list. @@ -625,43 +806,84 @@ If ELEMENTS is non nil, append these to the list as well." (-concat list (list elem) elements)) (defmacro --first (form list) - "Anaphoric form of `-first'." + "Return the first item in LIST for which FORM evals to non-nil. +Return nil if no such element is found. +Each element of LIST in turn is bound to `it' and its index +within LIST to `it-index' before evaluating FORM. +This is the anaphoric counterpart to `-first'." (declare (debug (form form))) (let ((n (make-symbol "needle"))) `(let (,n) - (--each-while ,list (not ,n) - (when ,form (setq ,n it))) + (--each-while ,list (or (not ,form) + (ignore (setq ,n it)))) ,n))) (defun -first (pred list) - "Return the first x in LIST where (PRED x) is non-nil, else nil. - + "Return the first item in LIST for which PRED returns non-nil. +Return nil if no such element is found. To get the first item in the list no questions asked, use `car'. -Alias: `-find'" +Alias: `-find'. + +This function's anaphoric counterpart is `--first'." (--first (funcall pred it) list)) (defalias '-find '-first) (defalias '--find '--first) (defmacro --some (form list) - "Anaphoric form of `-some'." + "Return non-nil if FORM evals to non-nil for at least one item in LIST. +If so, return the first such result of FORM. +Each element of LIST in turn is bound to `it' and its index +within LIST to `it-index' before evaluating FORM. +This is the anaphoric counterpart to `-some'." (declare (debug (form form))) (let ((n (make-symbol "needle"))) `(let (,n) - (--each-while ,list (not ,n) - (setq ,n ,form)) + (--each-while ,list (not (setq ,n ,form))) ,n))) (defun -some (pred list) "Return (PRED x) for the first LIST item where (PRED x) is non-nil, else nil. -Alias: `-any'" +Alias: `-any'. + +This function's anaphoric counterpart is `--some'." (--some (funcall pred it) list)) (defalias '-any '-some) (defalias '--any '--some) +(defmacro --every (form list) + "Return non-nil if FORM evals to non-nil for all items in LIST. +If so, return the last such result of FORM. Otherwise, once an +item is reached for which FORM yields nil, return nil without +evaluating FORM for any further LIST elements. +Each element of LIST in turn is bound to `it' and its index +within LIST to `it-index' before evaluating FORM. + +This macro is like `--every-p', but on success returns the last +non-nil result of FORM instead of just t. + +This is the anaphoric counterpart to `-every'." + (declare (debug (form form))) + (let ((a (make-symbol "all"))) + `(let ((,a t)) + (--each-while ,list (setq ,a ,form)) + ,a))) + +(defun -every (pred list) + "Return non-nil if PRED returns non-nil for all items in LIST. +If so, return the last such result of PRED. Otherwise, once an +item is reached for which PRED returns nil, return nil without +calling PRED on any further LIST elements. + +This function is like `-every-p', but on success returns the last +non-nil result of PRED instead of just t. + +This function's anaphoric counterpart is `--every'." + (--every (funcall pred it) list)) + (defmacro --last (form list) "Anaphoric form of `-last'." (declare (debug (form form))) @@ -749,14 +971,15 @@ See also: `-last-item'." "Counts the number of items in LIST where (PRED item) is non-nil." (--count (funcall pred it) list)) -(defun ---truthy? (val) +(defun ---truthy? (obj) + "Return OBJ as a boolean value (t or nil)." (declare (pure t) (side-effect-free t)) - (not (null val))) + (and obj t)) (defmacro --any? (form list) "Anaphoric form of `-any?'." (declare (debug (form form))) - `(---truthy? (--some ,form ,list))) + `(and (--some ,form ,list) t)) (defun -any? (pred list) "Return t if (PRED x) is non-nil for any x in LIST, else nil. @@ -772,17 +995,34 @@ Alias: `-any-p', `-some?', `-some-p'" (defalias '--some-p '--any?) (defmacro --all? (form list) - "Anaphoric form of `-all?'." + "Return t if FORM evals to non-nil for all items in LIST. +Otherwise, once an item is reached for which FORM yields nil, +return nil without evaluating FORM for any further LIST elements. +Each element of LIST in turn is bound to `it' and its index +within LIST to `it-index' before evaluating FORM. + +The similar macro `--every' is more widely useful, since it +returns the last non-nil result of FORM instead of just t on +success. + +Alias: `--all-p', `--every-p', `--every?'. + +This is the anaphoric counterpart to `-all?'." (declare (debug (form form))) - (let ((a (make-symbol "all"))) - `(let ((,a t)) - (--each-while ,list ,a (setq ,a ,form)) - (---truthy? ,a)))) + `(and (--every ,form ,list) t)) (defun -all? (pred list) - "Return t if (PRED x) is non-nil for all x in LIST, else nil. + "Return t if (PRED X) is non-nil for all X in LIST, else nil. +In the latter case, stop after the first X for which (PRED X) is +nil, without calling PRED on any subsequent elements of LIST. + +The similar function `-every' is more widely useful, since it +returns the last non-nil result of PRED instead of just t on +success. -Alias: `-all-p', `-every?', `-every-p'" +Alias: `-all-p', `-every-p', `-every?'. + +This function's anaphoric counterpart is `--all?'." (--all? (funcall pred it) list)) (defalias '-every? '-all?) @@ -854,7 +1094,12 @@ section is returned. Defaults to 1." (nreverse new-list))) (defmacro --take-while (form list) - "Anaphoric form of `-take-while'." + "Take successive items from LIST for which FORM evals to non-nil. +Each element of LIST in turn is bound to `it' and its index +within LIST to `it-index' before evaluating FORM. Return a new +list of the successive elements from the start of LIST for which +FORM evaluates to non-nil. +This is the anaphoric counterpart to `-take-while'." (declare (debug (form form))) (let ((r (make-symbol "result"))) `(let (,r) @@ -867,23 +1112,33 @@ PRED is a function of one argument. Return a new list of the successive elements from the start of LIST for which PRED returns non-nil. -See also: `-drop-while'" +This function's anaphoric counterpart is `--take-while'. + +For another variant, see also `-drop-while'." (--take-while (funcall pred it) list)) (defmacro --drop-while (form list) - "Anaphoric form of `-drop-while'." + "Drop successive items from LIST for which FORM evals to non-nil. +Each element of LIST in turn is bound to `it' and its index +within LIST to `it-index' before evaluating FORM. Return the +tail (not a copy) of LIST starting from its first element for +which FORM evaluates to nil. +This is the anaphoric counterpart to `-drop-while'." (declare (debug (form form))) (let ((l (make-symbol "list"))) `(let ((,l ,list)) (--each-while ,l ,form (pop ,l)) - (copy-sequence ,l)))) + ,l))) (defun -drop-while (pred list) "Drop successive items from LIST for which PRED returns non-nil. -PRED is a function of one argument. Return a copy of the tail of -LIST starting from its first element for which PRED returns nil. +PRED is a function of one argument. Return the tail (not a copy) +of LIST starting from its first element for which PRED returns +nil. -See also: `-take-while'" +This function's anaphoric counterpart is `--drop-while'. + +For another variant, see also `-take-while'." (--drop-while (funcall pred it) list)) (defun -take (n list) @@ -891,7 +1146,7 @@ See also: `-take-while'" Return a copy of LIST if it contains N items or fewer. Return nil if N is zero or less. -See also: `-take-last'" +See also: `-take-last'." (declare (pure t) (side-effect-free t)) (--take-while (< it-index n) list)) @@ -900,46 +1155,50 @@ See also: `-take-last'" Return a copy of LIST if it contains N items or fewer. Return nil if N is zero or less. -See also: `-take'" +See also: `-take'." (declare (pure t) (side-effect-free t)) (copy-sequence (last list n))) -(defun -drop (n list) - "Return a copy of the tail of LIST without the first N items. -Return a copy of LIST if N is zero or less. +(defalias '-drop #'nthcdr + "Return the tail (not a copy) of LIST without the first N items. Return nil if LIST contains N items or fewer. +Return LIST if N is zero or less. -See also: `-drop-last'" - (copy-sequence (nthcdr n list))) +For another variant, see also `-drop-last'. +\n(fn N LIST)") (defun -drop-last (n list) "Return a copy of LIST without its last N items. Return a copy of LIST if N is zero or less. Return nil if LIST contains N items or fewer. -See also: `-drop'" +See also: `-drop'." (declare (pure t) (side-effect-free t)) (nbutlast (copy-sequence list) n)) (defun -split-at (n list) - "Return a list of ((-take N LIST) (-drop N LIST)), in no more than one pass through the list." + "Split LIST into two sublists after the Nth element. +The result is a list of two elements (TAKE DROP) where TAKE is a +new list of the first N elements of LIST, and DROP is the +remaining elements of LIST (not a copy). TAKE and DROP are like +the results of `-take' and `-drop', respectively, but the split +is done in a single list traversal." (declare (pure t) (side-effect-free t)) (let (result) - (--dotimes n - (when list - (!cons (car list) result) - (!cdr list))) + (--each-while list (< it-index n) + (push (pop list) result)) (list (nreverse result) list))) (defun -rotate (n list) - "Rotate LIST N places to the right. With N negative, rotate to the left. + "Rotate LIST N places to the right (left if N is negative). The time complexity is O(n)." (declare (pure t) (side-effect-free t)) - (when list - (let* ((len (length list)) - (n-mod-len (mod n len)) - (new-tail-len (- len n-mod-len))) - (append (-drop new-tail-len list) (-take new-tail-len list))))) + (cond ((null list) ()) + ((zerop n) (copy-sequence list)) + ((let* ((len (length list)) + (n-mod-len (mod n len)) + (new-tail-len (- len n-mod-len))) + (append (nthcdr new-tail-len list) (-take new-tail-len list)))))) (defun -insert-at (n x list) "Return a list with X inserted into LIST at position N. @@ -966,7 +1225,7 @@ See also: `-map-when'" (defmacro --update-at (n form list) "Anaphoric version of `-update-at'." - (declare (debug (form form form))) + (declare (debug (form def-form form))) `(-update-at ,n (lambda (it) ,form) ,list)) (defun -remove-at (n list) @@ -1023,12 +1282,12 @@ Empty lists are also removed from the result. Comparison is done by `equal'. See also `-split-when'" - (declare (debug (form form))) + (declare (debug (def-form form))) `(-split-when (lambda (it) (equal it ,item)) ,list)) (defmacro --split-when (form list) "Anaphoric version of `-split-when'." - (declare (debug (form form))) + (declare (debug (def-form form))) `(-split-when (lambda (it) ,form) ,list)) (defun -split-when (fn list) @@ -1062,28 +1321,29 @@ This function can be thought of as a generalization of "Return a list of ((-filter PRED LIST) (-remove PRED LIST)), in one pass through the list." (--separate (funcall pred it) list)) -(defun ---partition-all-in-steps-reversed (n step list) - "Private: Used by -partition-all-in-steps and -partition-in-steps." +(defun dash--partition-all-in-steps-reversed (n step list) + "Used by `-partition-all-in-steps' and `-partition-in-steps'." (when (< step 1) - (error "Step must be a positive number, or you're looking at some juicy infinite loops.")) - (let ((result nil)) + (signal 'wrong-type-argument + `("Step size < 1 results in juicy infinite loops" ,step))) + (let (result) (while list - (!cons (-take n list) result) - (setq list (-drop step list))) + (push (-take n list) result) + (setq list (nthcdr step list))) result)) (defun -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." (declare (pure t) (side-effect-free t)) - (nreverse (---partition-all-in-steps-reversed n step list))) + (nreverse (dash--partition-all-in-steps-reversed n step list))) (defun -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." (declare (pure t) (side-effect-free t)) - (let ((result (---partition-all-in-steps-reversed n step list))) + (let ((result (dash--partition-all-in-steps-reversed n step list))) (while (and result (< (length (car result)) n)) (!cdr result)) (nreverse result))) @@ -1170,20 +1430,31 @@ returns the header value, but only after seeing at least one other value (the body)." (--partition-by-header (funcall fn it) list)) +(defmacro --partition-after-pred (form list) + "Partition LIST after each element for which FORM evaluates to non-nil. +Each element of LIST in turn is bound to `it' before evaluating +FORM. + +This is the anaphoric counterpart to `-partition-after-pred'." + (let ((l (make-symbol "list")) + (r (make-symbol "result")) + (s (make-symbol "sublist"))) + `(let ((,l ,list) ,r ,s) + (when ,l + (--each ,l + (push it ,s) + (when ,form + (push (nreverse ,s) ,r) + (setq ,s ()))) + (when ,s + (push (nreverse ,s) ,r)) + (nreverse ,r))))) + (defun -partition-after-pred (pred list) - "Partition directly after each time PRED is true on an element of LIST." - (when list - (let ((rest (-partition-after-pred pred - (cdr list)))) - (if (funcall pred (car list)) - ;;split after (car list) - (cons (list (car list)) - rest) - - ;;don't split after (car list) - (cons (cons (car list) - (car rest)) - (cdr rest)))))) + "Partition LIST after each element for which PRED returns non-nil. + +This function's anaphoric counterpart is `--partition-after-pred'." + (--partition-after-pred (funcall pred it) list)) (defun -partition-before-pred (pred list) "Partition directly before each time PRED is true on an element of LIST." @@ -1371,7 +1642,7 @@ element of LIST paired with the unmodified element of LIST." (defmacro --annotate (form list) "Anaphoric version of `-annotate'." - (declare (debug (form form))) + (declare (debug (def-form form))) `(-annotate (lambda (it) ,form) ,list)) (defun dash--table-carry (lists restore-lists &optional re) @@ -1436,13 +1707,6 @@ See also: `-flatten-n', `-table'" (dash--table-carry lists restore-lists))) (nreverse re))) -(defun -partial (fn &rest args) - "Take a function FN and fewer than the normal arguments to FN, -and return a fn that takes a variable number of additional ARGS. -When called, the returned function calls FN with ARGS first and -then additional args." - (apply 'apply-partially fn args)) - (defun -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 @@ -1463,7 +1727,7 @@ predicate PRED, in ascending order." (defmacro --find-indices (form list) "Anaphoric version of `-find-indices'." - (declare (debug (form form))) + (declare (debug (def-form form))) `(-find-indices (lambda (it) ,form) ,list)) (defun -find-index (pred list) @@ -1476,7 +1740,7 @@ See also `-first'." (defmacro --find-index (form list) "Anaphoric version of `-find-index'." - (declare (debug (form form))) + (declare (debug (def-form form))) `(-find-index (lambda (it) ,form) ,list)) (defun -find-last-index (pred list) @@ -1489,6 +1753,7 @@ See also `-last'." (defmacro --find-last-index (form list) "Anaphoric version of `-find-last-index'." + (declare (debug (def-form form))) `(-find-last-index (lambda (it) ,form) ,list)) (defun -select-by-indices (indices list) @@ -1570,9 +1835,9 @@ VARIABLE to the result of the first form, and so forth." `,value `(let ((,variable ,value)) (-as-> ,(if (symbolp (car forms)) - (list (car forms) variable) - (car forms)) - ,variable + (list (car forms) variable) + (car forms)) + ,variable ,@(cdr forms))))) (defmacro -some-> (x &optional form &rest more) @@ -1584,7 +1849,7 @@ and when that result is non-nil, through the next form, etc." (let ((result (make-symbol "result"))) `(-some-> (-when-let (,result ,x) (-> ,result ,form)) - ,@more)))) + ,@more)))) (defmacro -some->> (x &optional form &rest more) "When expr is non-nil, thread it through the first form (via `->>'), @@ -1595,38 +1860,56 @@ and when that result is non-nil, through the next form, etc." (let ((result (make-symbol "result"))) `(-some->> (-when-let (,result ,x) (->> ,result ,form)) - ,@more)))) - -(defmacro -some--> (x &optional form &rest more) - "When expr is non-nil, thread it through the first form (via `-->'), -and when that result is non-nil, through the next form, etc." - (declare (debug ->) - (indent 1)) - (if (null form) x + ,@more)))) + +(defmacro -some--> (expr &rest forms) + "Thread EXPR through FORMS via `-->', while the result is non-nil. +When EXPR evaluates to non-nil, thread the result through the +first of FORMS, and when that result is non-nil, thread it +through the next form, etc." + (declare (debug (form &rest &or symbolp consp)) (indent 1)) + (if (null forms) expr (let ((result (make-symbol "result"))) - `(-some--> (-when-let (,result ,x) - (--> ,result ,form)) - ,@more)))) + `(-some--> (-when-let (,result ,expr) + (--> ,result ,(car forms))) + ,@(cdr forms))))) + +(defmacro -doto (init &rest forms) + "Evaluate INIT and pass it as argument to FORMS with `->'. +The RESULT of evaluating INIT is threaded through each of FORMS +individually using `->', which see. The return value is RESULT, +which FORMS may have modified by side effect." + (declare (debug (form &rest &or symbolp consp)) (indent 1)) + (let ((retval (make-symbol "result"))) + `(let ((,retval ,init)) + ,@(mapcar (lambda (form) `(-> ,retval ,form)) forms) + ,retval))) + +(defmacro --doto (init &rest forms) + "Anaphoric form of `-doto'. +This just evaluates INIT, binds the result to `it', evaluates +FORMS, and returns the final value of `it'. +Note: `it' need not be used in each form." + (declare (debug (form body)) (indent 1)) + `(let ((it ,init)) + ,@forms + it)) (defun -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." - ;; ugly hack to "fix" lack of lexical scope - (let ((comp `(lambda (it other) (funcall ',comparator (car it) (car other))))) - (->> (--map-indexed (cons it it-index) list) - (-sort comp) - (-map 'cdr)))) + "Grade elements of LIST using COMPARATOR relation. +This yields a permutation vector such that applying this +permutation to LIST sorts it in ascending order." + (->> (--map-indexed (cons it it-index) list) + (-sort (lambda (it other) (funcall comparator (car it) (car other)))) + (mapcar #'cdr))) (defun -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." - ;; ugly hack to "fix" lack of lexical scope - (let ((comp `(lambda (it other) (funcall ',comparator (car other) (car it))))) - (->> (--map-indexed (cons it it-index) list) - (-sort comp) - (-map 'cdr)))) + "Grade elements of LIST using COMPARATOR relation. +This yields a permutation vector such that applying this +permutation to LIST sorts it in descending order." + (->> (--map-indexed (cons it it-index) list) + (-sort (lambda (it other) (funcall comparator (car other) (car it)))) + (mapcar #'cdr))) (defvar dash--source-counter 0 "Monotonic counter for generated symbols.") @@ -2152,27 +2435,28 @@ such that: (-lambda (x y ...) body) has the usual semantics of `lambda'. Furthermore, these get -translated into normal lambda, so there is no performance +translated into normal `lambda', so there is no performance penalty. -See `-let' for the description of destructuring mechanism." +See `-let' for a description of the destructuring mechanism." (declare (doc-string 2) (indent defun) (debug (&define sexp [&optional stringp] [&optional ("interactive" interactive)] def-body))) (cond - ((not (consp match-form)) - (signal 'wrong-type-argument "match-form must be a list")) - ;; no destructuring, so just return regular lambda to make things faster - ((-all? 'symbolp match-form) + ((nlistp match-form) + (signal 'wrong-type-argument (list #'listp match-form))) + ;; No destructuring, so just return regular `lambda' for speed. + ((-all? #'symbolp match-form) `(lambda ,match-form ,@body)) - (t - (let* ((inputs (--map-indexed (list it (make-symbol (format "input%d" it-index))) match-form))) - ;; TODO: because inputs to the lambda are evaluated only once, - ;; -let* need not to create the extra bindings to ensure that. + ((let ((inputs (--map-indexed + (list it (make-symbol (format "input%d" it-index))) + match-form))) + ;; TODO: because inputs to the `lambda' are evaluated only once, + ;; `-let*' need not create the extra bindings to ensure that. ;; We should find a way to optimize that. Not critical however. - `(lambda ,(--map (cadr it) inputs) + `(lambda ,(mapcar #'cadr inputs) (-let* ,inputs ,@body)))))) (defmacro -setq (&rest forms) @@ -2199,7 +2483,7 @@ multiple assignments it does not cause unexpected side effects. (declare (debug (&rest sexp form)) (indent 1)) (when (= (mod (length forms) 2) 1) - (error "Odd number of arguments")) + (signal 'wrong-number-of-arguments (list '-setq (1+ (length forms))))) (let* ((forms-and-sources ;; First get all the necessary mappings with all the ;; intermediate bindings. @@ -2432,20 +2716,20 @@ Alias: `-same-items-p'" (defalias '-same-items-p '-same-items?) (defun -is-prefix? (prefix list) - "Return non-nil if PREFIX is prefix of LIST. + "Return non-nil if PREFIX is a prefix of LIST. -Alias: `-is-prefix-p'" +Alias: `-is-prefix-p'." (declare (pure t) (side-effect-free t)) - (--each-while list (equal (car prefix) it) - (!cdr prefix)) - (not prefix)) + (--each-while list (and (equal (car prefix) it) + (!cdr prefix))) + (null prefix)) (defun -is-suffix? (suffix list) - "Return non-nil if SUFFIX is suffix of LIST. + "Return non-nil if SUFFIX is a suffix of LIST. -Alias: `-is-suffix-p'" +Alias: `-is-suffix-p'." (declare (pure t) (side-effect-free t)) - (-is-prefix? (reverse suffix) (reverse list))) + (equal suffix (last list (length suffix)))) (defun -is-infix? (infix list) "Return non-nil if INFIX is infix of LIST. @@ -2473,17 +2757,21 @@ if the first element should sort before the second." (defmacro --sort (form list) "Anaphoric form of `-sort'." - (declare (debug (form form))) + (declare (debug (def-form form))) `(-sort (lambda (it other) ,form) ,list)) -(defun -list (&rest args) - "Return a list with ARGS. +(defun -list (&optional arg &rest args) + "Ensure ARG is a list. +If ARG is already a list, return it as is (not a copy). +Otherwise, return a new list with ARG as its only element. -If first item of ARGS is already a list, simply return ARGS. If -not, return a list with ARGS as elements." - (declare (pure t) (side-effect-free t)) - (let ((arg (car args))) - (if (listp arg) arg args))) +Another supported calling convention is (-list &rest ARGS). +In this case, if ARG is not a list, a new list with all of +ARGS as elements is returned. This use is supported for +backward compatibility and is otherwise deprecated." + (declare (advertised-calling-convention (arg) "2.18.0") + (pure t) (side-effect-free t)) + (if (listp arg) arg (cons arg args))) (defun -repeat (n x) "Return a new list of length N with each element being X. @@ -2498,12 +2786,10 @@ Return nil if N is less than 1." (defun -running-sum (list) "Return a list with running sums of items in LIST. - LIST must be non-empty." (declare (pure t) (side-effect-free t)) - (unless (consp list) - (error "LIST must be non-empty")) - (-reductions '+ list)) + (or list (signal 'wrong-type-argument (list #'consp list))) + (-reductions #'+ list)) (defun -product (list) "Return the product of LIST." @@ -2512,12 +2798,10 @@ LIST must be non-empty." (defun -running-product (list) "Return a list with running products of items in LIST. - LIST must be non-empty." (declare (pure t) (side-effect-free t)) - (unless (consp list) - (error "LIST must be non-empty")) - (-reductions '* list)) + (or list (signal 'wrong-type-argument (list #'consp list))) + (-reductions #'* list)) (defun -max (list) "Return the largest value from LIST of numbers or markers." @@ -2549,16 +2833,31 @@ comparing them." "Anaphoric version of `-max-by'. The items for the comparator form are exposed as \"it\" and \"other\"." - (declare (debug (form form))) + (declare (debug (def-form form))) `(-max-by (lambda (it other) ,form) ,list)) (defmacro --min-by (form list) "Anaphoric version of `-min-by'. The items for the comparator form are exposed as \"it\" and \"other\"." - (declare (debug (form form))) + (declare (debug (def-form form))) `(-min-by (lambda (it other) ,form) ,list)) +(defun -iota (count &optional start step) + "Return a list containing COUNT numbers. +Starts from START and adds STEP each time. The default START is +zero, the default STEP is 1. +This function takes its name from the corresponding primitive in +the APL language." + (declare (pure t) (side-effect-free t)) + (unless (natnump count) + (signal 'wrong-type-argument (list #'natnump count))) + (or start (setq start 0)) + (or step (setq step 1)) + (if (zerop step) + (make-list count start) + (--iterate (+ it step) start count))) + (defun -fix (fn list) "Compute the (least) fixpoint of FN with initial input LIST. @@ -2571,6 +2870,7 @@ FN is called at least once, results are compared with `equal'." (defmacro --fix (form list) "Anaphoric form of `-fix'." + (declare (debug (def-form form))) `(-fix (lambda (it) ,form) ,list)) (defun -unfold (fun seed) @@ -2591,17 +2891,16 @@ the new seed." (defmacro --unfold (form seed) "Anaphoric version of `-unfold'." - (declare (debug (form form))) + (declare (debug (def-form form))) `(-unfold (lambda (it) ,form) ,seed)) -(defun -cons-pair? (con) - "Return non-nil if CON is true cons pair. -That is (A . B) where B is not a list. +(defun -cons-pair? (obj) + "Return non-nil if OBJ is a true cons pair. +That is, a cons (A . B) where B is not a list. -Alias: `-cons-pair-p'" +Alias: `-cons-pair-p'." (declare (pure t) (side-effect-free t)) - (and (listp con) - (not (listp (cdr con))))) + (nlistp (cdr-safe obj))) (defalias '-cons-pair-p '-cons-pair?) @@ -2641,7 +2940,7 @@ but is twice as fast as it only traverse the structure once." (defmacro --tree-mapreduce-from (form folder init-value tree) "Anaphoric form of `-tree-mapreduce-from'." - (declare (debug (form form form form))) + (declare (debug (def-form def-form form form))) `(-tree-mapreduce-from (lambda (it) ,form) (lambda (it acc) ,folder) ,init-value ,tree)) (defun -tree-mapreduce (fn folder tree) @@ -2663,7 +2962,7 @@ but is twice as fast as it only traverse the structure once." (defmacro --tree-mapreduce (form folder tree) "Anaphoric form of `-tree-mapreduce'." - (declare (debug (form form form))) + (declare (debug (def-form def-form form))) `(-tree-mapreduce (lambda (it) ,form) (lambda (it acc) ,folder) ,tree)) (defun -tree-map (fn tree) @@ -2677,7 +2976,7 @@ but is twice as fast as it only traverse the structure once." (defmacro --tree-map (form tree) "Anaphoric form of `-tree-map'." - (declare (debug (form form))) + (declare (debug (def-form form))) `(-tree-map (lambda (it) ,form) ,tree)) (defun -tree-reduce-from (fn init-value tree) @@ -2698,7 +2997,7 @@ two elements." (defmacro --tree-reduce-from (form init-value tree) "Anaphoric form of `-tree-reduce-from'." - (declare (debug (form form form))) + (declare (debug (def-form form form))) `(-tree-reduce-from (lambda (it acc) ,form) ,init-value ,tree)) (defun -tree-reduce (fn tree) @@ -2718,7 +3017,7 @@ See `-reduce-r' for how exactly are lists of zero or one element handled." (defmacro --tree-reduce (form tree) "Anaphoric form of `-tree-reduce'." - (declare (debug (form form))) + (declare (debug (def-form form))) `(-tree-reduce (lambda (it acc) ,form) ,tree)) (defun -tree-map-nodes (pred fun tree) @@ -2736,6 +3035,7 @@ further." (defmacro --tree-map-nodes (pred form tree) "Anaphoric form of `-tree-map-nodes'." + (declare (debug (def-form def-form form))) `(-tree-map-nodes (lambda (it) ,pred) (lambda (it) ,form) ,tree)) (defun -tree-seq (branch children tree) @@ -2755,6 +3055,7 @@ Non-branch nodes are simply copied." (defmacro --tree-seq (branch children tree) "Anaphoric form of `-tree-seq'." + (declare (debug (def-form def-form form))) `(-tree-seq (lambda (it) ,branch) (lambda (it) ,children) ,tree)) (defun -clone (list) @@ -2764,14 +3065,286 @@ replaced with new ones. This is useful when you need to clone a structure such as plist or alist." (declare (pure t) (side-effect-free t)) (-tree-map 'identity list)) + +;;; Combinators + +(defalias '-partial #'apply-partially) + +(defun -rpartial (fn &rest args) + "Return a function that is a partial application of FN to ARGS. +ARGS is a list of the last N arguments to pass to FN. The result +is a new function which does the same as FN, except that the last +N arguments are fixed at the values with which this function was +called. This is like `-partial', except the arguments are fixed +starting from the right rather than the left." + (declare (pure t) (side-effect-free t)) + (lambda (&rest args-before) (apply fn (append args-before args)))) + +(defun -juxt (&rest fns) + "Return a function that is the juxtaposition of FNS. +The returned function takes a variable number of ARGS, applies +each of FNS in turn to ARGS, and returns the list of results." + (declare (pure t) (side-effect-free t)) + (lambda (&rest args) (mapcar (lambda (x) (apply x args)) fns))) + +(defun -compose (&rest fns) + "Compose FNS into a single composite function. +Return a function that takes a variable number of ARGS, applies +the last function in FNS to ARGS, and returns the result of +calling each remaining function on the result of the previous +function, right-to-left. If no FNS are given, return a variadic +`identity' function." + (declare (pure t) (side-effect-free t)) + (let* ((fns (nreverse fns)) + (head (car fns)) + (tail (cdr fns))) + (cond (tail + (lambda (&rest args) + (--reduce-from (funcall it acc) (apply head args) tail))) + (fns head) + ((lambda (&optional arg &rest _) arg))))) + +(defun -applify (fn) + "Return a function that applies FN to a single list of args. +This changes the arity of FN from taking N distinct arguments to +taking 1 argument which is a list of N arguments." + (declare (pure t) (side-effect-free t)) + (lambda (args) (apply fn args))) +(defun -on (op trans) + "Return a function that calls TRANS on each arg and OP on the results. +The returned function takes a variable number of arguments, calls +the function TRANS on each one in turn, and then passes those +results as the list of arguments to OP, in the same order. + +For example, the following pairs of expressions are morally +equivalent: + + (funcall (-on #\\='+ #\\='1+) 1 2 3) = (+ (1+ 1) (1+ 2) (1+ 3)) + (funcall (-on #\\='+ #\\='1+)) = (+)" + (declare (pure t) (side-effect-free t)) + (lambda (&rest args) + ;; This unrolling seems to be a relatively cheap way to keep the + ;; overhead of `mapcar' + `apply' in check. + (cond ((cddr args) + (apply op (mapcar trans args))) + ((cdr args) + (funcall op (funcall trans (car args)) (funcall trans (cadr args)))) + (args + (funcall op (funcall trans (car args)))) + ((funcall op))))) + +(defun -flip (fn) + "Return a function that calls FN with its arguments reversed. +The returned function takes the same number of arguments as FN. + +For example, the following two expressions are morally +equivalent: + + (funcall (-flip #\\='-) 1 2) = (- 2 1) + +See also: `-rotate-args'." + (declare (pure t) (side-effect-free t)) + (lambda (&rest args) ;; Open-code for speed. + (cond ((cddr args) (apply fn (nreverse args))) + ((cdr args) (funcall fn (cadr args) (car args))) + (args (funcall fn (car args))) + ((funcall fn))))) + +(defun -rotate-args (n fn) + "Return a function that calls FN with args rotated N places to the right. +The returned function takes the same number of arguments as FN, +rotates the list of arguments N places to the right (left if N is +negative) just like `-rotate', and applies FN to the result. + +See also: `-flip'." + (declare (pure t) (side-effect-free t)) + (if (zerop n) + fn + (let ((even (= (% n 2) 0))) + (lambda (&rest args) + (cond ((cddr args) ;; Open-code for speed. + (apply fn (-rotate n args))) + ((cdr args) + (let ((fst (car args)) + (snd (cadr args))) + (funcall fn (if even fst snd) (if even snd fst)))) + (args + (funcall fn (car args))) + ((funcall fn))))))) + +(defun -const (c) + "Return a function that returns C ignoring any additional arguments. + +In types: a -> b -> a" + (declare (pure t) (side-effect-free t)) + (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." + (declare (debug (&optional sexp &rest &or "<>" form))) + (let* ((i 0) + (args (--keep (when (eq it '<>) + (setq i (1+ i)) + (make-symbol (format "D%d" i))) + params))) + `(lambda ,args + ,(let ((body (--map (if (eq it '<>) (pop args) it) params))) + (if (eq (car params) '<>) + (cons #'funcall body) + body))))) + +(defun -not (pred) + "Return a predicate that negates the result of PRED. +The returned predicate passes its arguments to PRED. If PRED +returns nil, the result is non-nil; otherwise the result is nil. + +See also: `-andfn' and `-orfn'." + (declare (pure t) (side-effect-free t)) + (lambda (&rest args) (not (apply pred args)))) + +(defun -orfn (&rest preds) + "Return a predicate that returns the first non-nil result of PREDS. +The returned predicate takes a variable number of arguments, +passes them to each predicate in PREDS in turn until one of them +returns non-nil, and returns that non-nil result without calling +the remaining PREDS. If all PREDS return nil, or if no PREDS are +given, the returned predicate returns nil. + +See also: `-andfn' and `-not'." + (declare (pure t) (side-effect-free t)) + ;; Open-code for speed. + (cond ((cdr preds) (lambda (&rest args) (--some (apply it args) preds))) + (preds (car preds)) + (#'ignore))) + +(defun -andfn (&rest preds) + "Return a predicate that returns non-nil if all PREDS do so. +The returned predicate P takes a variable number of arguments and +passes them to each predicate in PREDS in turn. If any one of +PREDS returns nil, P also returns nil without calling the +remaining PREDS. If all PREDS return non-nil, P returns the last +such value. If no PREDS are given, P always returns non-nil. + +See also: `-orfn' and `-not'." + (declare (pure t) (side-effect-free t)) + ;; Open-code for speed. + (cond ((cdr preds) (lambda (&rest args) (--every (apply it args) preds))) + (preds (car preds)) + ;; As a `pure' function, this runtime check may generate + ;; backward-incompatible bytecode for `(-andfn)' at compile-time, + ;; but I doubt that's a problem in practice (famous last words). + ((fboundp 'always) #'always) + ((lambda (&rest _) t)))) + +(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 satisfied: + + 1. Iteration converges to the fixpoint, with equality being + tested using EQUAL-TEST. If EQUAL-TEST is not specified, + `equal' is used. For functions over the floating point + numbers, it may be necessary to provide an appropriate + approximate comparison test. + + 2. HALT-TEST returns a non-nil value. HALT-TEST defaults to a + simple counter that returns t after `-fixfn-max-iterations', + to 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))) + ;;; Font lock (defvar dash--keywords `(;; TODO: Do not fontify the following automatic variables ;; globally; detect and limit to their local anaphoric scope. - (,(concat "\\_<" (regexp-opt '("acc" "it" "it-index" "other")) "\\_>") + (,(rx symbol-start (| "acc" "it" "it-index" "other") symbol-end) 0 font-lock-variable-name-face) + ;; Macros in dev/examples.el. Based on `lisp-mode-symbol-regexp'. + (,(rx ?\( (group (| "defexamples" "def-example-group")) symbol-end + (+ (in "\t ")) + (group (* (| (syntax word) (syntax symbol) (: ?\\ nonl))))) + (1 font-lock-keyword-face) + (2 font-lock-function-name-face)) + ;; Symbols in dev/examples.el. + ,(rx symbol-start (| "=>" "~>" "!!>") symbol-end) ;; Elisp macro fontification was static prior to Emacs 25. ,@(when (< emacs-major-version 25) (let ((macs '("!cdr" @@ -2815,6 +3388,10 @@ structure such as plist or alist." "--reduce-from" "--reduce-r" "--reduce-r-from" + "--reductions" + "--reductions-from" + "--reductions-r" + "--reductions-r-from" "--remove" "--remove-first" "--remove-last" @@ -2916,6 +3493,39 @@ See also `dash-fontify-mode-lighter' and (define-obsolete-function-alias 'dash-enable-font-lock #'global-dash-fontify-mode "2.18.0") + +;;; Info + +(defvar dash--info-doc-spec '("(dash) Index" nil "^ -+ .*: " "\\( \\|$\\)") + "The Dash :doc-spec entry for `info-lookup-alist'. +It is based on that for `emacs-lisp-mode'.") + +(defun dash--info-elisp-docs () + "Return the `emacs-lisp-mode' symbol docs from `info-lookup-alist'. +Specifically, return the cons containing their +`info-lookup->doc-spec' so that we can modify it." + (defvar info-lookup-alist) + (nthcdr 3 (assq #'emacs-lisp-mode (cdr (assq 'symbol info-lookup-alist))))) + +;;;###autoload +(defun dash-register-info-lookup () + "Register the Dash Info manual with `info-lookup-symbol'. +This allows Dash symbols to be looked up with \\[info-lookup-symbol]." + (interactive) + (require 'info-look) + (let ((docs (dash--info-elisp-docs))) + (setcar docs (append (car docs) (list dash--info-doc-spec))) + (info-lookup-reset))) + +(defun dash-unload-function () + "Remove Dash from `info-lookup-alist'. +Used by `unload-feature', which see." + (let ((docs (and (featurep 'info-look) + (dash--info-elisp-docs)))) + (when (member dash--info-doc-spec (car docs)) + (setcar docs (remove dash--info-doc-spec (car docs))) + (info-lookup-reset))) + nil) (provide 'dash) ;;; dash.el ends here diff --git a/elpa/dash-20210105.414/dash.info b/elpa/dash-20210826.1149/dash.info similarity index 76% rename from elpa/dash-20210105.414/dash.info rename to elpa/dash-20210826.1149/dash.info index a0c99c25..a6a2dc60 100644 --- a/elpa/dash-20210105.414/dash.info +++ b/elpa/dash-20210826.1149/dash.info @@ -1,6 +1,6 @@ -This is dash.info, produced by makeinfo version 6.5 from dash.texi. +This is dash.info, produced by makeinfo version 6.7 from dash.texi. -This manual is for Dash version 2.17.0. +This manual is for Dash version 2.19.1. Copyright © 2012–2021 Free Software Foundation, Inc. @@ -22,7 +22,7 @@ File: dash.info, Node: Top, Next: Installation, Up: (dir) Dash **** -This manual is for Dash version 2.17.0. +This manual is for Dash version 2.19.1. Copyright © 2012–2021 Free Software Foundation, Inc. @@ -52,6 +52,7 @@ Installation * Using in a package:: Listing Dash as a package dependency. * Fontification of special variables:: Font Lock of anaphoric macro variables. +* Info symbol lookup:: Looking up Dash symbols in this manual. Functions @@ -68,14 +69,13 @@ Functions * Tree operations:: * Threading macros:: * Binding:: -* Side-effects:: +* Side effects:: * Destructive operations:: * Function combinators:: Development * Contribute:: How to contribute. -* Change log:: List of significant changes by version. * Contributors:: List of contributors.  @@ -84,23 +84,22 @@ File: dash.info, Node: Installation, Next: Functions, Prev: Top, Up: Top 1 Installation ************** -Dash is available on GNU ELPA (https://elpa.gnu.org/) and MELPA -(https://melpa.org/), and can be installed with the standard command -‘package-install’ (*note (emacs)Package Installation::). +Dash is available on GNU ELPA (https://elpa.gnu.org/), GNU-devel ELPA +(https://elpa.gnu.org/devel/), and MELPA (https://melpa.org/), and can +be installed with the standard command ‘package-install’ (*note +(emacs)Package Installation::). ‘M-x package-install dash ’ Install the Dash library. -‘M-x package-install dash-functional ’ - Install an optional library of additional function combinators. - - Alternatively, you can just dump ‘dash.el’ or ‘dash-functional.el’ in -your load path somewhere. + Alternatively, you can just dump ‘dash.el’ in your ‘load-path’ +somewhere (*note (emacs)Lisp Libraries::). * Menu: * Using in a package:: Listing Dash as a package dependency. * Fontification of special variables:: Font Lock of anaphoric macro variables. +* Info symbol lookup:: Looking up Dash symbols in this manual.  File: dash.info, Node: Using in a package, Next: Fontification of special variables, Up: Installation @@ -111,15 +110,10 @@ File: dash.info, Node: Using in a package, Next: Fontification of special vari If you use Dash in your own package, be sure to list it as a dependency in the library’s headers as follows (*note (elisp)Library Headers::). - ;; Package-Requires: ((dash "2.17.0")) - - The same goes for the ‘dash-functional.el’ library of function -combinators: - - ;; Package-Requires: ((dash "2.17.0") (dash-functional "1.2.0")) + ;; Package-Requires: ((dash "2.19.1"))  -File: dash.info, Node: Fontification of special variables, Prev: Using in a package, Up: Installation +File: dash.info, Node: Fontification of special variables, Next: Info symbol lookup, Prev: Using in a package, Up: Installation 1.2 Fontification of special variables ====================================== @@ -136,6 +130,21 @@ either interactively or from your ‘user-init-file’: (global-dash-fontify-mode) + +File: dash.info, Node: Info symbol lookup, Prev: Fontification of special variables, Up: Installation + +1.3 Info symbol lookup +====================== + +While editing Elisp files, you can use ‘C-h S’ (‘info-lookup-symbol’) to +look up Elisp symbols in the relevant Info manuals (*note (emacs)Info +Lookup::). To enable the same for Dash symbols, use the command +‘dash-register-info-lookup’. It can be called directly when needed, or +automatically from your ‘user-init-file’. For example: + + (with-eval-after-load 'info-look + (dash-register-info-lookup)) +  File: dash.info, Node: Functions, Next: Development, Prev: Installation, Up: Top @@ -188,7 +197,7 @@ following example, which demonstrates the utility of both versions. * Tree operations:: * Threading macros:: * Binding:: -* Side-effects:: +* Side effects:: * Destructive operations:: * Function combinators:: @@ -200,18 +209,19 @@ File: dash.info, Node: Maps, Next: Sublist selection, Up: Functions 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. +The results are collected in order and returned as a new list. -- Function: -map (fn list) - Return a new list consisting of the result of applying FN to the - items in LIST. + Apply FN to each item in LIST and return the list of results. + + This function’s anaphoric counterpart is ‘--map’. (-map (lambda (num) (* num num)) '(1 2 3 4)) - ⇒ '(1 4 9 16) - (-map 'square '(1 2 3 4)) - ⇒ '(1 4 9 16) + ⇒ (1 4 9 16) + (-map #'1+ '(1 2 3 4)) + ⇒ (2 3 4 5) (--map (* it it) '(1 2 3 4)) - ⇒ '(1 4 9 16) + ⇒ (1 4 9 16) -- Function: -map-when (pred rep list) Return a new list where the elements in LIST that do not match the @@ -223,11 +233,11 @@ The results are collected in order and returned as new list. See also: ‘-update-at’ (*note -update-at::) (-map-when 'even? 'square '(1 2 3 4)) - ⇒ '(1 4 3 16) + ⇒ (1 4 3 16) (--map-when (> it 2) (* it it) '(1 2 3 4)) - ⇒ '(1 2 9 16) + ⇒ (1 2 9 16) (--map-when (= it 2) 17 '(1 2 3 4)) - ⇒ '(1 17 3 4) + ⇒ (1 17 3 4) -- Function: -map-first (pred rep list) Replace first item in LIST satisfying PRED with result of REP @@ -237,11 +247,11 @@ The results are collected in order and returned as new list. -replace-first::) (-map-first 'even? 'square '(1 2 3 4)) - ⇒ '(1 4 3 4) + ⇒ (1 4 3 4) (--map-first (> it 2) (* it it) '(1 2 3 4)) - ⇒ '(1 2 9 4) + ⇒ (1 2 9 4) (--map-first (= it 2) 17 '(1 2 3 2)) - ⇒ '(1 17 3 2) + ⇒ (1 17 3 2) -- Function: -map-last (pred rep list) Replace last item in LIST satisfying PRED with result of REP called @@ -251,36 +261,40 @@ The results are collected in order and returned as new list. -replace-last::) (-map-last 'even? 'square '(1 2 3 4)) - ⇒ '(1 2 3 16) + ⇒ (1 2 3 16) (--map-last (> it 2) (* it it) '(1 2 3 4)) - ⇒ '(1 2 3 16) + ⇒ (1 2 3 16) (--map-last (= it 2) 17 '(1 2 3 2)) - ⇒ '(1 2 3 17) + ⇒ (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. + Apply FN to each index and item in LIST and return the list of + results. This is like ‘-map’ (*note -map::), but FN takes two + arguments: the index of the current element within LIST, and the + element itself. - In the anaphoric form ‘--map-indexed’, the index is exposed as - symbol ‘it-index’. + This function’s anaphoric counterpart is ‘--map-indexed’. - See also: ‘-each-indexed’ (*note -each-indexed::). + For a side-effecting variant, see also ‘-each-indexed’ (*note + -each-indexed::). (-map-indexed (lambda (index item) (- item index)) '(1 2 3 4)) - ⇒ '(1 1 1 1) + ⇒ (1 1 1 1) (--map-indexed (- it it-index) '(1 2 3 4)) - ⇒ '(1 1 1 1) + ⇒ (1 1 1 1) + (-map-indexed #'* '(1 2 3 4)) + ⇒ (0 2 6 12) -- 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)) + ⇒ ((2 . 1) (3 . 2) (4 . 3)) (-annotate 'length '(("h" "e" "l" "l" "o") ("hello" "world"))) - ⇒ '((5 "h" "e" "l" "l" "o") (2 "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)) + ⇒ ((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 @@ -296,11 +310,11 @@ The results are collected in order and returned as new list. (*note -insert-at::) (-splice 'even? (lambda (x) (list x x)) '(1 2 3 4)) - ⇒ '(1 2 2 3 4 4) + ⇒ (1 2 2 3 4 4) (--splice 't (list it it) '(1 2 3 4)) - ⇒ '(1 1 2 2 3 3 4 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)) + ⇒ ((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. @@ -309,30 +323,28 @@ The results are collected in order and returned as new list. -insert-at::) (-splice-list 'keywordp '(a b c) '(1 :foo 2)) - ⇒ '(1 a b c 2) + ⇒ (1 a b c 2) (-splice-list 'keywordp nil '(1 :foo 2)) - ⇒ '(1 2) + ⇒ (1 2) (--splice-list (keywordp it) '(a b c) '(1 :foo 2)) - ⇒ '(1 a b c 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) + ⇒ (1 2 3) (-mapcat (lambda (item) (list 0 item)) '(1 2 3)) - ⇒ '(0 1 0 2 0 3) + ⇒ (0 1 0 2 0 3) (--mapcat (list 0 it) '(1 2 3)) - ⇒ '(0 1 0 2 0 3) + ⇒ (0 1 0 2 0 3) - -- Function: -copy (arg) + -- Function: -copy (list) Create a shallow copy of LIST. - (fn LIST) - (-copy '(1 2 3)) - ⇒ '(1 2 3) + ⇒ (1 2 3) (let ((a '(1 2 3))) (eq a (-copy a))) ⇒ nil @@ -345,81 +357,100 @@ File: dash.info, Node: Sublist selection, Next: List to list, Prev: Maps, Up 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. + Return a new list of the items in LIST for which PRED returns + non-nil. + + Alias: ‘-select’. - Alias: ‘-select’ + This function’s anaphoric counterpart is ‘--filter’. - See also: ‘-keep’ (*note -keep::), ‘-remove’ (*note -remove::). + For similar operations, see also ‘-keep’ (*note -keep::) and + ‘-remove’ (*note -remove::). (-filter (lambda (num) (= 0 (% num 2))) '(1 2 3 4)) - ⇒ '(2 4) - (-filter 'even? '(1 2 3 4)) - ⇒ '(2 4) + ⇒ (2 4) + (-filter #'natnump '(-2 -1 0 1 2)) + ⇒ (0 1 2) (--filter (= 0 (% it 2)) '(1 2 3 4)) - ⇒ '(2 4) + ⇒ (2 4) -- Function: -remove (pred list) Return a new list of the items in LIST for which PRED returns nil. - Alias: ‘-reject’ + Alias: ‘-reject’. - See also: ‘-filter’ (*note -filter::). + This function’s anaphoric counterpart is ‘--remove’. + + For similar operations, see also ‘-keep’ (*note -keep::) and + ‘-filter’ (*note -filter::). (-remove (lambda (num) (= 0 (% num 2))) '(1 2 3 4)) - ⇒ '(1 3) - (-remove 'even? '(1 2 3 4)) - ⇒ '(1 3) + ⇒ (1 3) + (-remove #'natnump '(-2 -1 0 1 2)) + ⇒ (-2 -1) (--remove (= 0 (% it 2)) '(1 2 3 4)) - ⇒ '(1 3) + ⇒ (1 3) -- Function: -remove-first (pred list) - Return a new list with the first item matching PRED removed. + Remove the first item from LIST for which PRED returns non-nil. + This is a non-destructive operation, but only the front of LIST + leading up to the removed item is a copy; the rest is LIST’s + original tail. If no item is removed, then the result is a + complete copy. + + Alias: ‘-reject-first’. - Alias: ‘-reject-first’ + This function’s anaphoric counterpart is ‘--remove-first’. - See also: ‘-remove’ (*note -remove::), ‘-map-first’ (*note - -map-first::) + See also ‘-map-first’ (*note -map-first::), ‘-remove-item’ (*note + -remove-item::), and ‘-remove-last’ (*note -remove-last::). - (-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) + (-remove-first #'natnump '(-2 -1 0 1 2)) + ⇒ (-2 -1 1 2) + (-remove-first #'stringp '(1 2 "first" "second")) + ⇒ (1 2 "second") + (--remove-first (> it 3) '(1 2 3 4 5 6)) + ⇒ (1 2 3 5 6) -- Function: -remove-last (pred list) - Return a new list with the last item matching PRED removed. + Remove the last item from LIST for which PRED returns non-nil. The + result is a copy of LIST regardless of whether an element is + removed. - Alias: ‘-reject-last’ + Alias: ‘-reject-last’. - See also: ‘-remove’ (*note -remove::), ‘-map-last’ (*note - -map-last::) + This function’s anaphoric counterpart is ‘--remove-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") + See also ‘-map-last’ (*note -map-last::), ‘-remove-item’ (*note + -remove-item::), and ‘-remove-first’ (*note -remove-first::). + + (-remove-last #'natnump '(1 3 5 4 7 8 10 -11)) + ⇒ (1 3 5 4 7 8 -11) + (-remove-last #'stringp '(1 2 "last" "second")) + ⇒ (1 2 "last") (--remove-last (> it 3) '(1 2 3 4 5 6 7 8 9 10)) - ⇒ '(1 2 3 4 5 6 7 8 9) + ⇒ (1 2 3 4 5 6 7 8 9) -- Function: -remove-item (item list) - Remove all occurrences of ITEM from LIST. - - Comparison is done with ‘equal’. + Return a copy of LIST with all occurrences of ITEM removed. The + comparison is done with ‘equal’. (-remove-item 3 '(1 2 3 2 3 4 5 3)) - ⇒ '(1 2 2 4 5) + ⇒ (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") + ⇒ (bar baz) + (-remove-item "bob" '("alice" "bob" "eve" "bob")) + ⇒ ("alice" "eve") -- Function: -non-nil (list) - Return all non-nil elements of LIST. + Return a copy of LIST with all nil items removed. - (-non-nil '(1 nil 2 nil nil 3 4 nil 5 nil)) - ⇒ '(1 2 3 4 5) + (-non-nil '(nil 1 nil 2 nil nil 3 4 nil 5 nil)) + ⇒ (1 2 3 4 5) + (-non-nil '((nil))) + ⇒ ((nil)) + (-non-nil ()) + ⇒ () -- Function: -slice (list from &optional to step) Return copy of LIST, starting from index FROM to index TO. @@ -431,66 +462,66 @@ Functions returning a sublist of the original list. is returned. Defaults to 1. (-slice '(1 2 3 4 5) 1) - ⇒ '(2 3 4 5) + ⇒ (2 3 4 5) (-slice '(1 2 3 4 5) 0 3) - ⇒ '(1 2 3) + ⇒ (1 2 3) (-slice '(1 2 3 4 5 6 7 8 9) 1 -1 2) - ⇒ '(2 4 6 8) + ⇒ (2 4 6 8) -- Function: -take (n list) Return a copy of the first N items in LIST. Return a copy of LIST if it contains N items or fewer. Return nil if N is zero or less. - See also: ‘-take-last’ (*note -take-last::) + See also: ‘-take-last’ (*note -take-last::). (-take 3 '(1 2 3 4 5)) - ⇒ '(1 2 3) + ⇒ (1 2 3) (-take 17 '(1 2 3 4 5)) - ⇒ '(1 2 3 4 5) + ⇒ (1 2 3 4 5) (-take 0 '(1 2 3 4 5)) - ⇒ nil + ⇒ () -- Function: -take-last (n list) Return a copy of the last N items of LIST in order. Return a copy of LIST if it contains N items or fewer. Return nil if N is zero or less. - See also: ‘-take’ (*note -take::) + See also: ‘-take’ (*note -take::). (-take-last 3 '(1 2 3 4 5)) - ⇒ '(3 4 5) + ⇒ (3 4 5) (-take-last 17 '(1 2 3 4 5)) - ⇒ '(1 2 3 4 5) + ⇒ (1 2 3 4 5) (-take-last 1 '(1 2 3 4 5)) - ⇒ '(5) + ⇒ (5) -- Function: -drop (n list) - Return a copy of the tail of LIST without the first N items. - Return a copy of LIST if N is zero or less. Return nil if LIST - contains N items or fewer. + Return the tail (not a copy) of LIST without the first N items. + Return nil if LIST contains N items or fewer. Return LIST if N is + zero or less. - See also: ‘-drop-last’ (*note -drop-last::) + For another variant, see also ‘-drop-last’ (*note -drop-last::). (-drop 3 '(1 2 3 4 5)) - ⇒ '(4 5) + ⇒ (4 5) (-drop 17 '(1 2 3 4 5)) - ⇒ nil + ⇒ () (-drop 0 '(1 2 3 4 5)) - ⇒ '(1 2 3 4 5) + ⇒ (1 2 3 4 5) -- Function: -drop-last (n list) Return a copy of LIST without its last N items. Return a copy of LIST if N is zero or less. Return nil if LIST contains N items or fewer. - See also: ‘-drop’ (*note -drop::) + See also: ‘-drop’ (*note -drop::). (-drop-last 3 '(1 2 3 4 5)) - ⇒ '(1 2) + ⇒ (1 2) (-drop-last 17 '(1 2 3 4 5)) - ⇒ nil + ⇒ () (-drop-last 0 '(1 2 3 4 5)) - ⇒ '(1 2 3 4 5) + ⇒ (1 2 3 4 5) -- Function: -take-while (pred list) Take successive items from LIST for which PRED returns non-nil. @@ -498,39 +529,43 @@ Functions returning a sublist of the original list. successive elements from the start of LIST for which PRED returns non-nil. - See also: ‘-drop-while’ (*note -drop-while::) + This function’s anaphoric counterpart is ‘--take-while’. - (-take-while 'even? '(1 2 3 4)) - ⇒ nil - (-take-while 'even? '(2 4 5 6)) - ⇒ '(2 4) + For another variant, see also ‘-drop-while’ (*note -drop-while::). + + (-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) + ⇒ (1 2 3) -- Function: -drop-while (pred list) Drop successive items from LIST for which PRED returns non-nil. - PRED is a function of one argument. Return a copy of the tail of - LIST starting from its first element for which PRED returns nil. + PRED is a function of one argument. Return the tail (not a copy) + of LIST starting from its first element for which PRED returns nil. + + This function’s anaphoric counterpart is ‘--drop-while’. - See also: ‘-take-while’ (*note -take-while::) + For another variant, see also ‘-take-while’ (*note -take-while::). - (-drop-while 'even? '(1 2 3 4)) - ⇒ '(1 2 3 4) - (-drop-while 'even? '(2 4 5 6)) - ⇒ '(5 6) + (-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) + ⇒ (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") + ⇒ ("c" "o" "l" "o" "r") (-select-by-indices '(2 1 0) '("a" "b" "c")) - ⇒ '("c" "b" "a") + ⇒ ("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") + ⇒ ("f" "a" "r" "f" "a" "l" "l" "a") -- Function: -select-columns (columns table) Select COLUMNS from TABLE. @@ -545,11 +580,11 @@ Functions returning a sublist of the original list. ‘-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)) + ⇒ ((1 3) (a c) (:a :c)) (-select-columns '(1) '((1 2 3) (a b c) (:a :b :c))) - ⇒ '((2) (b) (:b)) + ⇒ ((2) (b) (:b)) (-select-columns nil '((1 2 3) (a b c) (:a :b :c))) - ⇒ '(nil nil nil) + ⇒ (nil nil nil) -- Function: -select-column (column table) Select COLUMN from TABLE. @@ -563,7 +598,7 @@ Functions returning a sublist of the original list. ‘-select-by-indices’ (*note -select-by-indices::) (-select-column 1 '((1 2 3) (a b c) (:a :b :c))) - ⇒ '(2 b :b) + ⇒ (2 b :b)  File: dash.info, Node: List to list, Next: Reductions, Prev: Sublist selection, Up: Functions @@ -574,29 +609,30 @@ File: dash.info, Node: List to list, Next: Reductions, Prev: Sublist selectio 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. + Return a new list of the non-nil results of applying FN to each + item in LIST. Like ‘-filter’ (*note -filter::), but returns the + non-nil results of FN instead of the corresponding elements of + LIST. - If you want to select the original items satisfying a predicate use - ‘-filter’ (*note -filter::). + Its anaphoric counterpart is ‘--keep’. - (-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) + (-keep #'cdr '((1 2 3) (4 5) (6))) + ⇒ ((2 3) (5)) + (-keep (lambda (n) (and (> n 3) (* 10 n))) '(1 2 3 4 5 6)) + ⇒ (40 50 60) + (--keep (and (> 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) + ⇒ (1) (-concat '(1) '(2)) - ⇒ '(1 2) + ⇒ (1 2) (-concat '(1) '(2 3) '(4)) - ⇒ '(1 2 3 4) + ⇒ (1 2 3 4) -- Function: -flatten (l) Take a nested list L and return its contents as a single, flat @@ -614,11 +650,11 @@ Functions returning a modified copy of the input list. See also: ‘-flatten-n’ (*note -flatten-n::) (-flatten '((1))) - ⇒ '(1) + ⇒ (1) (-flatten '((1 (2 3) (((4 (5))))))) - ⇒ '(1 2 3 4 5) + ⇒ (1 2 3 4 5) (-flatten '(1 2 (3 . 4))) - ⇒ '(1 2 (3 . 4)) + ⇒ (1 2 (3 . 4)) -- Function: -flatten-n (num list) Flatten NUM levels of a nested LIST. @@ -626,11 +662,11 @@ Functions returning a modified copy of the input list. See also: ‘-flatten’ (*note -flatten::) (-flatten-n 1 '((1 2) ((3 4) ((5 6))))) - ⇒ '(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)) + ⇒ (1 2 3 4 (5 6)) (-flatten-n 3 '((1 2) ((3 4) ((5 6))))) - ⇒ '(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. @@ -640,9 +676,9 @@ Functions returning a modified copy of the input list. See also: ‘-replace-at’ (*note -replace-at::) (-replace 1 "1" '(1 2 3 4 3 2 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") + ⇒ ("a" "nice" "bar" "sentence" "about" "bar") (-replace 1 2 nil) ⇒ nil @@ -654,9 +690,9 @@ Functions returning a modified copy of the input list. 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) + ⇒ ("1" 2 3 4 3 2 1) (-replace-first "foo" "bar" '("a" "nice" "foo" "sentence" "about" "foo")) - ⇒ '("a" "nice" "bar" "sentence" "about" "foo") + ⇒ ("a" "nice" "bar" "sentence" "about" "foo") (-replace-first 1 2 nil) ⇒ nil @@ -668,9 +704,9 @@ Functions returning a modified copy of the input list. 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") + ⇒ (1 2 3 4 3 2 "1") (-replace-last "foo" "bar" '("a" "nice" "foo" "sentence" "about" "foo")) - ⇒ '("a" "nice" "foo" "sentence" "about" "bar") + ⇒ ("a" "nice" "foo" "sentence" "about" "bar") (-replace-last 1 2 nil) ⇒ nil @@ -681,9 +717,9 @@ Functions returning a modified copy of the input list. -splice-list::) (-insert-at 1 'x '(a b c)) - ⇒ '(a x b c) + ⇒ (a x b c) (-insert-at 12 'x '(a b c)) - ⇒ '(a b c x) + ⇒ (a b c x) -- Function: -replace-at (n x list) Return a list with element at Nth position in LIST replaced with X. @@ -691,11 +727,11 @@ Functions returning a modified copy of the input list. See also: ‘-replace’ (*note -replace::) (-replace-at 0 9 '(0 1 2 3 4 5)) - ⇒ '(9 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) + ⇒ (0 9 2 3 4 5) (-replace-at 4 9 '(0 1 2 3 4 5)) - ⇒ '(0 1 2 3 9 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 @@ -704,11 +740,11 @@ Functions returning a modified copy of the input 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) + ⇒ (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) + ⇒ (0 9 2 3 4 5) (--update-at 2 (length it) '("foo" "bar" "baz" "quux")) - ⇒ '("foo" "bar" 3 "quux") + ⇒ ("foo" "bar" 3 "quux") -- Function: -remove-at (n list) Return a list with element at Nth position in LIST removed. @@ -717,11 +753,11 @@ Functions returning a modified copy of the input list. ‘-remove’ (*note -remove::) (-remove-at 0 '("0" "1" "2" "3" "4" "5")) - ⇒ '("1" "2" "3" "4" "5") + ⇒ ("1" "2" "3" "4" "5") (-remove-at 1 '("0" "1" "2" "3" "4" "5")) - ⇒ '("0" "2" "3" "4" "5") + ⇒ ("0" "2" "3" "4" "5") (-remove-at 2 '("0" "1" "2" "3" "4" "5")) - ⇒ '("0" "1" "3" "4" "5") + ⇒ ("0" "1" "3" "4" "5") -- Function: -remove-at-indices (indices list) Return a list whose elements are elements from LIST without @@ -731,11 +767,11 @@ Functions returning a modified copy of the input list. -remove::) (-remove-at-indices '(0) '("0" "1" "2" "3" "4" "5")) - ⇒ '("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") + ⇒ ("1" "3" "5") (-remove-at-indices '(0 5) '("0" "1" "2" "3" "4" "5")) - ⇒ '("1" "2" "3" "4") + ⇒ ("1" "2" "3" "4")  File: dash.info, Node: Reductions, Next: Unfolding, Prev: List to list, Up: Functions @@ -743,150 +779,171 @@ File: dash.info, Node: Reductions, Next: Unfolding, Prev: List to list, Up: 2.4 Reductions ============== -Functions reducing lists into single value. +Functions reducing lists to a single value (which may also be a list). - -- 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. + -- Function: -reduce-from (fn init list) + Reduce the function FN across LIST, starting with INIT. Return the + result of applying FN to INIT and the first element of LIST, then + applying FN to that result and the second element, etc. If LIST is + empty, return INIT without calling FN. - In the anaphoric form ‘--reduce-from’, the accumulated value is - exposed as symbol ‘acc’. + This function’s anaphoric counterpart is ‘--reduce-from’. - See also: ‘-reduce’ (*note -reduce::), ‘-reduce-r’ (*note - -reduce-r::) + For other folds, see also ‘-reduce’ (*note -reduce::) and + ‘-reduce-r’ (*note -reduce-r::). - (-reduce-from '- 10 '(1 2 3)) + (-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 #'list 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. + -- Function: -reduce-r-from (fn init list) + Reduce the function FN across LIST in reverse, starting with INIT. + Return the result of applying FN to the last element of LIST and + INIT, then applying FN to the second-to-last element and the + previous result of FN, etc. That is, the first argument of FN is + the current element, and its second argument the accumulated value. + If LIST is empty, return INIT without calling FN. + + This function is like ‘-reduce-from’ (*note -reduce-from::) but the + operation associates from the right rather than left. In other + words, it starts from the end of LIST and flips the arguments to + FN. Conceptually, it is like replacing the conses in LIST with + applications of FN, and its last link with INIT, and evaluating the + resulting expression. - Note: this function works the same as ‘-reduce-from’ (*note - -reduce-from::) but the operation associates from right instead of - from left. + This function’s anaphoric counterpart is ‘--reduce-r-from’. - See also: ‘-reduce-r’ (*note -reduce-r::), ‘-reduce’ (*note - -reduce::) + For other folds, see also ‘-reduce-r’ (*note -reduce-r::) and + ‘-reduce’ (*note -reduce::). - (-reduce-r-from '- 10 '(1 2 3)) + (-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 #'list 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. + Reduce the function FN across LIST. Return the result of applying + FN to the first two elements of LIST, then applying FN to that + result and the third element, etc. If LIST contains a single + element, return it without calling FN. If LIST is empty, return + the result of calling FN with no arguments. - In the anaphoric form ‘--reduce’, the accumulated value is exposed - as symbol ‘acc’. + This function’s anaphoric counterpart is ‘--reduce’. - See also: ‘-reduce-from’ (*note -reduce-from::), ‘-reduce-r’ (*note - -reduce-r::) + For other folds, see also ‘-reduce-from’ (*note -reduce-from::) and + ‘-reduce-r’ (*note -reduce-r::). - (-reduce '- '(1 2 3 4)) + (-reduce #'- '(1 2 3 4)) ⇒ -8 - (-reduce 'list '(1 2 3 4)) - ⇒ '(((1 2) 3) 4) + (-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)) + Reduce the function FN across LIST in reverse. Return the result + of applying FN to the last two elements of LIST, then applying FN + to the third-to-last element and the previous result of FN, etc. + That is, the first argument of FN is the current element, and its + second argument the accumulated value. If LIST contains a single + element, return it without calling FN. If LIST is empty, return + the result of calling FN with no arguments. + + This function is like ‘-reduce’ (*note -reduce::) but the operation + associates from the right rather than left. In other words, it + starts from the end of LIST and flips the arguments to FN. + Conceptually, it is like replacing the conses in LIST with + applications of FN, ignoring its last link, and evaluating the + resulting expression. + + This function’s anaphoric counterpart is ‘--reduce-r’. + + For other folds, see also ‘-reduce-r-from’ (*note -reduce-r-from::) + and ‘-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 #'list '(1 2 3 4)) + ⇒ (1 (2 (3 4))) (--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. + Return a list of FN’s intermediate reductions across LIST. That + is, a list of the intermediate values of the accumulator when + ‘-reduce-from’ (*note -reduce-from::) (which see) is called with + the same arguments. - See ‘-reduce-from’ (*note -reduce-from::) for explanation of the - arguments. + This function’s anaphoric counterpart is ‘--reductions-from’. - See also: ‘-reductions’ (*note -reductions::), ‘-reductions-r’ - (*note -reductions-r::), ‘-reduce-r’ (*note -reduce-r::) + For other folds, see also ‘-reductions’ (*note -reductions::) and + ‘-reductions-r’ (*note -reductions-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) + (-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) + (--reductions-from (format "(FN %s %d)" acc it) "INIT" '(1 2 3)) + ⇒ ("INIT" "(FN INIT 1)" "(FN (FN INIT 1) 2)" "(FN (FN (FN INIT 1) 2) 3)") -- Function: -reductions-r-from (fn init list) - Return a list of the intermediate values of the reduction. + Return a list of FN’s intermediate reductions across reversed LIST. + That is, a list of the intermediate values of the accumulator when + ‘-reduce-r-from’ (*note -reduce-r-from::) (which see) is called + with the same arguments. - See ‘-reduce-r-from’ (*note -reduce-r-from::) for explanation of - the arguments. + This function’s anaphoric counterpart is ‘--reductions-r-from’. - See also: ‘-reductions-r’ (*note -reductions-r::), ‘-reductions’ - (*note -reductions::), ‘-reduce’ (*note -reduce::) + For other folds, see also ‘-reductions’ (*note -reductions::) and + ‘-reductions-r’ (*note -reductions-r::). - (-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) + (-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) + (--reductions-r-from (format "(FN %d %s)" it acc) "INIT" '(1 2 3)) + ⇒ ("(FN 1 (FN 2 (FN 3 INIT)))" "(FN 2 (FN 3 INIT))" "(FN 3 INIT)" "INIT") -- Function: -reductions (fn list) - Return a list of the intermediate values of the reduction. + Return a list of FN’s intermediate reductions across LIST. That + is, a list of the intermediate values of the accumulator when + ‘-reduce’ (*note -reduce::) (which see) is called with the same + arguments. - See ‘-reduce’ (*note -reduce::) for explanation of the arguments. + This function’s anaphoric counterpart is ‘--reductions’. - See also: ‘-reductions-from’ (*note -reductions-from::), - ‘-reductions-r’ (*note -reductions-r::), ‘-reduce-r’ (*note - -reduce-r::) + For other folds, see also ‘-reductions’ (*note -reductions::) and + ‘-reductions-r’ (*note -reductions-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) + (-reductions #'+ '(1 2 3 4)) + ⇒ (1 3 6 10) + (-reductions #'* '(1 2 3 4)) + ⇒ (1 2 6 24) + (--reductions (format "(FN %s %d)" acc it) '(1 2 3)) + ⇒ (1 "(FN 1 2)" "(FN (FN 1 2) 3)") -- 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 + Return a list of FN’s intermediate reductions across reversed LIST. + That is, a list of the intermediate values of the accumulator when + ‘-reduce-r’ (*note -reduce-r::) (which see) is called with the same arguments. - See also: ‘-reductions-r-from’ (*note -reductions-r-from::), - ‘-reductions’ (*note -reductions::), ‘-reduce’ (*note -reduce::) + This function’s anaphoric counterpart is ‘--reductions-r’. + + For other folds, see also ‘-reductions-r-from’ (*note + -reductions-r-from::) and ‘-reductions’ (*note -reductions::). - (-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) + (-reductions-r #'+ '(1 2 3 4)) + ⇒ (10 9 7 4) + (-reductions-r #'* '(1 2 3 4)) + ⇒ (24 24 12 4) + (--reductions-r (format "(FN %d %s)" it acc) '(1 2 3)) + ⇒ ("(FN 1 (FN 2 3))" "(FN 2 3)" 3) -- Function: -count (pred list) Counts the number of items in LIST where (PRED item) is non-nil. @@ -899,7 +956,7 @@ Functions reducing lists into single value. -- Function: -sum (list) Return the sum of LIST. - (-sum '()) + (-sum ()) ⇒ 0 (-sum '(1)) ⇒ 1 @@ -907,21 +964,20 @@ Functions reducing lists into single value. ⇒ 10 -- Function: -running-sum (list) - Return a list with running sums of items in LIST. - - LIST must be non-empty. + 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) + ⇒ (1 3 6 10) (-running-sum '(1)) - ⇒ '(1) - (-running-sum '()) - ⇒ error + ⇒ (1) + (-running-sum ()) + error→ Wrong type argument: consp, nil -- Function: -product (list) Return the product of LIST. - (-product '()) + (-product ()) ⇒ 1 (-product '(1)) ⇒ 1 @@ -929,56 +985,55 @@ Functions reducing lists into single value. ⇒ 24 -- Function: -running-product (list) - Return a list with running products of items in LIST. - - LIST must be non-empty. + 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) + ⇒ (1 2 6 24) (-running-product '(1)) - ⇒ '(1) - (-running-product '()) - ⇒ error + ⇒ (1) + (-running-product ()) + error→ Wrong type argument: consp, nil -- Function: -inits (list) Return all prefixes of LIST. (-inits '(1 2 3 4)) - ⇒ '(nil (1) (1 2) (1 2 3) (1 2 3 4)) + ⇒ (nil (1) (1 2) (1 2 3) (1 2 3 4)) (-inits nil) - ⇒ '(nil) + ⇒ (nil) (-inits '(1)) - ⇒ '(nil (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) + ⇒ ((1 2 3 4) (2 3 4) (3 4) (4) nil) (-tails nil) - ⇒ '(nil) + ⇒ (nil) (-tails '(1)) - ⇒ '((1) nil) + ⇒ ((1) nil) -- Function: -common-prefix (&rest lists) Return the longest common prefix of LISTS. (-common-prefix '(1)) - ⇒ '(1) + ⇒ (1) (-common-prefix '(1 2) '(3 4) '(1 2)) - ⇒ nil + ⇒ () (-common-prefix '(1 2) '(1 2 3) '(1 2 3 4)) - ⇒ '(1 2) + ⇒ (1 2) -- Function: -common-suffix (&rest lists) Return the longest common suffix of LISTS. (-common-suffix '(1)) - ⇒ '(1) + ⇒ (1) (-common-suffix '(1 2) '(3 4) '(1 2)) - ⇒ nil + ⇒ () (-common-suffix '(1 2 3 4) '(2 3 4) '(3 4)) - ⇒ '(3 4) + ⇒ (3 4) -- Function: -min (list) Return the smallest value from LIST of numbers or markers. @@ -1000,9 +1055,9 @@ Functions reducing lists into single value. (-min-by '> '(4 3 6 1)) ⇒ 1 (--min-by (> (car it) (car other)) '((1 2 3) (2) (3 2))) - ⇒ '(1 2 3) + ⇒ (1 2 3) (--min-by (> (length it) (length other)) '((1 2 3) (2) (3 2))) - ⇒ '(2) + ⇒ (2) -- Function: -max (list) Return the largest value from LIST of numbers or markers. @@ -1024,9 +1079,9 @@ Functions reducing lists into single value. (-max-by '> '(4 3 6 1)) ⇒ 6 (--max-by (> (car it) (car other)) '((1 2 3) (2) (3 2))) - ⇒ '(3 2) + ⇒ (3 2) (--max-by (> (length it) (length other)) '((1 2 3) (2) (3 2))) - ⇒ '(1 2 3) + ⇒ (1 2 3)  File: dash.info, Node: Unfolding, Next: Predicates, Prev: Reductions, Up: Functions @@ -1047,11 +1102,11 @@ than consuming a list to produce a single value. N is the length of the returned list. (-iterate #'1+ 1 10) - ⇒ '(1 2 3 4 5 6 7 8 9 10) + ⇒ (1 2 3 4 5 6 7 8 9 10) (-iterate (lambda (x) (+ x x)) 2 5) - ⇒ '(2 4 8 16 32) + ⇒ (2 4 8 16 32) (--iterate (* it it) 2 5) - ⇒ '(2 4 16 256 65536) + ⇒ (2 4 16 256 65536) -- Function: -unfold (fun seed) Build a list from SEED using FUN. @@ -1066,11 +1121,11 @@ than consuming a list to produce a single value. seed. (-unfold (lambda (x) (unless (= x 0) (cons x (1- x)))) 10) - ⇒ '(10 9 8 7 6 5 4 3 2 1) + ⇒ (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)) + ⇒ ((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)) + ⇒ ((1 2 3 4) (1 2 3) (1 2) (1))  File: dash.info, Node: Predicates, Next: Partitioning, Prev: Unfolding, Up: Functions @@ -1078,27 +1133,70 @@ File: dash.info, Node: Predicates, Next: Partitioning, Prev: Unfolding, Up: 2.6 Predicates ============== +Reductions of one or more lists to a boolean value. + + -- Function: -some (pred list) + Return (PRED x) for the first LIST item where (PRED x) is non-nil, + else nil. + + Alias: ‘-any’. + + This function’s anaphoric counterpart is ‘--some’. + + (-some #'stringp '(1 "2" 3)) + ⇒ t + (--some (string-match-p "x" it) '("foo" "axe" "xor")) + ⇒ 1 + (--some (= it-index 3) '(0 1 2)) + ⇒ nil + + -- Function: -every (pred list) + Return non-nil if PRED returns non-nil for all items in LIST. If + so, return the last such result of PRED. Otherwise, once an item + is reached for which PRED returns nil, return nil without calling + PRED on any further LIST elements. + + This function is like ‘-every-p’, but on success returns the last + non-nil result of PRED instead of just t. + + This function’s anaphoric counterpart is ‘--every’. + + (-every #'numberp '(1 2 3)) + ⇒ t + (--every (string-match-p "x" it) '("axe" "xor")) + ⇒ 0 + (--every (= it it-index) '(0 1 3)) + ⇒ nil + -- 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)) + (-any? #'numberp '(nil 0 t)) ⇒ t - (-any? 'even? '(1 3 5)) + (-any? #'numberp '(nil t t)) ⇒ nil - (-any? 'null '(1 3 5)) + (-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. + Return t if (PRED X) is non-nil for all X in LIST, else nil. In + the latter case, stop after the first X for which (PRED X) is nil, + without calling PRED on any subsequent elements of LIST. - Alias: ‘-all-p’, ‘-every?’, ‘-every-p’ + The similar function ‘-every’ (*note -every::) is more widely + useful, since it returns the last non-nil result of PRED instead of + just t on success. - (-all? 'even? '(1 2 3)) - ⇒ nil - (-all? 'even? '(2 4 6)) + Alias: ‘-all-p’, ‘-every-p’, ‘-every?’. + + This function’s anaphoric counterpart is ‘--all?’. + + (-all? #'numberp '(1 2 3)) ⇒ t + (-all? #'numberp '(2 t 6)) + ⇒ nil (--all? (= 0 (% it 2)) '(2 4 6)) ⇒ t @@ -1159,9 +1257,9 @@ File: dash.info, Node: Predicates, Next: Partitioning, Prev: Unfolding, Up: ⇒ nil -- Function: -is-prefix? (prefix list) - Return non-nil if PREFIX is prefix of LIST. + Return non-nil if PREFIX is a prefix of LIST. - Alias: ‘-is-prefix-p’ + Alias: ‘-is-prefix-p’. (-is-prefix? '(1 2 3) '(1 2 3 4 5)) ⇒ t @@ -1171,9 +1269,9 @@ File: dash.info, Node: Predicates, Next: Partitioning, Prev: Unfolding, Up: ⇒ nil -- Function: -is-suffix? (suffix list) - Return non-nil if SUFFIX is suffix of LIST. + Return non-nil if SUFFIX is a suffix of LIST. - Alias: ‘-is-suffix-p’ + Alias: ‘-is-suffix-p’. (-is-suffix? '(3 4 5) '(1 2 3 4 5)) ⇒ t @@ -1196,6 +1294,19 @@ File: dash.info, Node: Predicates, Next: Partitioning, Prev: Unfolding, Up: (-is-infix? '(3 4 5) '(1 2 3 4 5)) ⇒ t + -- Function: -cons-pair? (obj) + Return non-nil if OBJ is a true cons pair. That is, a cons (A . + B) where B is not a list. + + Alias: ‘-cons-pair-p’. + + (-cons-pair? '(1 . 2)) + ⇒ t + (-cons-pair? '(1 2)) + ⇒ nil + (-cons-pair? '(1)) + ⇒ nil +  File: dash.info, Node: Partitioning, Next: Indexing, Prev: Predicates, Up: Functions @@ -1205,24 +1316,30 @@ File: dash.info, Node: Partitioning, Next: Indexing, Prev: Predicates, Up: F 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 LIST into two sublists after the Nth element. The result is + a list of two elements (TAKE DROP) where TAKE is a new list of the + first N elements of LIST, and DROP is the remaining elements of + LIST (not a copy). TAKE and DROP are like the results of ‘-take’ + (*note -take::) and ‘-drop’ (*note -drop::), respectively, but the + split is done in a single list traversal. (-split-at 3 '(1 2 3 4 5)) - ⇒ '((1 2 3) (4 5)) + ⇒ ((1 2 3) (4 5)) (-split-at 17 '(1 2 3 4 5)) - ⇒ '((1 2 3 4 5) nil) + ⇒ ((1 2 3 4 5) nil) + (-split-at 0 '(1 2 3 4 5)) + ⇒ (nil (1 2 3 4 5)) -- 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)) + ⇒ (nil (1 2 3 4)) (-split-with 'even? '(2 4 5 6)) - ⇒ '((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)) + ⇒ ((1 2 3) (4 3 2 1)) -- Macro: -split-on (item list) Split the LIST each time ITEM is found. @@ -1236,11 +1353,11 @@ Functions partitioning the input list into a list of lists. 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")) + ⇒ ((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. @@ -1253,22 +1370,22 @@ Functions partitioning the input list into a list of lists. ‘split-string’. (-split-when 'even? '(1 2 3 4 5 6)) - ⇒ '((1) (3) (5)) + ⇒ ((1) (3) (5)) (-split-when 'even? '(1 2 3 4 6 8 9)) - ⇒ '((1) (3) (9)) + ⇒ ((1) (3) (9)) (--split-when (memq it '(&optional &rest)) '(a b &optional c d &rest args)) - ⇒ '((a b) (c d) (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)) + ⇒ ((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)) + ⇒ ((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))) + ⇒ (((1 2) (1 2 3)) ((1) (4))) -- Function: -partition (n list) Return a new list with the items in LIST grouped into N-sized @@ -1276,22 +1393,22 @@ Functions partitioning the input list into a list of lists. N-sized, those items are discarded. (-partition 2 '(1 2 3 4 5 6)) - ⇒ '((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)) + ⇒ ((1 2) (3 4) (5 6)) (-partition 3 '(1 2 3 4 5 6 7)) - ⇒ '((1 2 3) (4 5 6)) + ⇒ ((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)) + ⇒ ((1 2) (3 4) (5 6)) (-partition-all 2 '(1 2 3 4 5 6 7)) - ⇒ '((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)) + ⇒ ((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 @@ -1299,11 +1416,11 @@ Functions partitioning the input list into a list of lists. 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)) + ⇒ ((1 2) (2 3) (3 4)) (-partition-in-steps 3 2 '(1 2 3 4)) - ⇒ '((1 2 3)) + ⇒ ((1 2 3)) (-partition-in-steps 3 2 '(1 2 3 4 5)) - ⇒ '((1 2 3) (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 @@ -1311,22 +1428,22 @@ Functions partitioning the input list into a list of lists. than N items. (-partition-all-in-steps 2 1 '(1 2 3 4)) - ⇒ '((1 2) (2 3) (3 4) (4)) + ⇒ ((1 2) (2 3) (3 4) (4)) (-partition-all-in-steps 3 2 '(1 2 3 4)) - ⇒ '((1 2 3) (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)) + ⇒ ((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? ()) + ⇒ () (-partition-by 'even? '(1 1 2 2 2 3 4 6 8)) - ⇒ '((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)) + ⇒ ((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. @@ -1335,64 +1452,65 @@ Functions partitioning the input list into a list of lists. (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)) + ⇒ ((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)) + ⇒ ((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)) + ⇒ ((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 LIST after each element for which PRED returns non-nil. + + This function’s anaphoric counterpart is ‘--partition-after-pred’. - (-partition-after-pred #'odd? '()) - ⇒ '() - (-partition-after-pred #'odd? '(1)) - ⇒ '((1)) - (-partition-after-pred #'odd? '(0 1)) - ⇒ '((0 1)) + (-partition-after-pred #'booleanp ()) + ⇒ () + (-partition-after-pred #'booleanp '(t t)) + ⇒ ((t) (t)) + (-partition-after-pred #'booleanp '(0 0 t t 0 t)) + ⇒ ((0 0 t) (t) (0 t)) -- Function: -partition-before-pred (pred list) Partition directly before each time PRED is true on an element of LIST. - (-partition-before-pred #'odd? '()) - ⇒ '() - (-partition-before-pred #'odd? '(1)) - ⇒ '((1)) - (-partition-before-pred #'odd? '(0 1)) - ⇒ '((0) (1)) + (-partition-before-pred #'booleanp ()) + ⇒ () + (-partition-before-pred #'booleanp '(0 t)) + ⇒ ((0) (t)) + (-partition-before-pred #'booleanp '(0 0 t 0 t t)) + ⇒ ((0 0) (t 0) (t) (t)) -- Function: -partition-before-item (item list) Partition directly before each time ITEM appears in LIST. - (-partition-before-item 3 '()) - ⇒ '() + (-partition-before-item 3 ()) + ⇒ () (-partition-before-item 3 '(1)) - ⇒ '((1)) + ⇒ ((1)) (-partition-before-item 3 '(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 ()) + ⇒ () (-partition-after-item 3 '(1)) - ⇒ '((1)) + ⇒ ((1)) (-partition-after-item 3 '(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? ()) + ⇒ () (-group-by 'even? '(1 1 2 2 2 3 4 6 8)) - ⇒ '((nil 1 1 3) (t 2 2 2 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")) + ⇒ (("a" "a/b" "a/e") ("c" "c/d"))  File: dash.info, Node: Indexing, Next: Set operations, Prev: Partitioning, Up: Functions @@ -1400,8 +1518,8 @@ File: dash.info, Node: Indexing, Next: Set operations, Prev: Partitioning, U 2.8 Indexing ============ -Return indices of elements based on predicates, sort elements by indices -etc. +Functions retrieving or sorting based on list indices and related +predicates. -- Function: -elem-index (elem list) Return the index of the first element in the given LIST which is @@ -1420,11 +1538,11 @@ etc. element ELEM, in ascending order. (-elem-indices 2 '(6 7 8 2 3 4 2 1)) - ⇒ '(3 6) + ⇒ (3 6) (-elem-indices "bar" '("foo" "bar" "baz")) - ⇒ '(1) + ⇒ (1) (-elem-indices '(1 2) '((3) (1 2) (5 6) (1 2) nil)) - ⇒ '(1 3) + ⇒ (1 3) -- Function: -find-index (pred list) Take a predicate PRED and a LIST and return the index of the first @@ -1459,31 +1577,31 @@ etc. PRED, in ascending order. (-find-indices 'even? '(2 4 1 6 3 3 5 8)) - ⇒ '(0 1 3 7) + ⇒ (0 1 3 7) (--find-indices (< 5 it) '(2 4 1 6 3 3 5 8)) - ⇒ '(3 7) + ⇒ (3 7) (-find-indices (-partial 'string-lessp "baz") '("bar" "foo" "baz")) - ⇒ '(1) + ⇒ (1) -- Function: -grade-up (comparator list) - Grade elements of LIST using COMPARATOR relation, yielding a + Grade elements of LIST using COMPARATOR relation. This yields 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) + (-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 + Grade elements of LIST using COMPARATOR relation. This yields 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) + (-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 @@ -1499,53 +1617,53 @@ Operations pretending lists are sets. ‘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) + ⇒ (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) + ⇒ (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 () ()) + ⇒ () (-difference '(1 2 3) '(4 5 6)) - ⇒ '(1 2 3) + ⇒ (1 2 3) (-difference '(1 2 3 4) '(3 4 5 6)) - ⇒ '(1 2) + ⇒ (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 () ()) + ⇒ () (-intersection '(1 2 3) '(4 5 6)) - ⇒ '() + ⇒ () (-intersection '(1 2 3 4) '(3 4 5 6)) - ⇒ '(3 4) + ⇒ (3 4) -- Function: -powerset (list) Return the power set of LIST. - (-powerset '()) - ⇒ '(nil) + (-powerset ()) + ⇒ (nil) (-powerset '(x y z)) - ⇒ '((x y z) (x y) (x z) (x) (y z) (y) (z) nil) + ⇒ ((x y z) (x y) (x z) (x) (y z) (y) (z) nil) -- Function: -permutations (list) Return the permutations of LIST. - (-permutations '()) - ⇒ '(nil) + (-permutations ()) + ⇒ (nil) (-permutations '(1 2)) - ⇒ '((1 2) (2 1)) + ⇒ ((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)) + ⇒ ((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 @@ -1554,12 +1672,12 @@ Operations pretending lists are sets. Alias: ‘-uniq’ - (-distinct '()) - ⇒ '() + (-distinct ()) + ⇒ () (-distinct '(1 2 2 4)) - ⇒ '(1 2 4) + ⇒ (1 2 4) (-distinct '(t t t)) - ⇒ '(t) + ⇒ (t)  File: dash.info, Node: Other list operations, Next: Tree operations, Prev: Set operations, Up: Functions @@ -1570,38 +1688,37 @@ File: dash.info, Node: Other list operations, Next: Tree operations, Prev: Se 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 LIST N places to the right (left if N is negative). The + time complexity is O(n). (-rotate 3 '(1 2 3 4 5 6 7)) - ⇒ '(5 6 7 1 2 3 4) + ⇒ (5 6 7 1 2 3 4) (-rotate -3 '(1 2 3 4 5 6 7)) - ⇒ '(4 5 6 7 1 2 3) + ⇒ (4 5 6 7 1 2 3) (-rotate 16 '(1 2 3 4 5 6 7)) - ⇒ '(6 7 1 2 3 4 5) + ⇒ (6 7 1 2 3 4 5) -- Function: -repeat (n x) Return a new list of length N with each element being X. Return nil if N is less than 1. (-repeat 3 :a) - ⇒ '(:a :a :a) + ⇒ (:a :a :a) (-repeat 1 :a) - ⇒ '(: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. + Make a new list from the elements of ARGS. The last 2 elements of + ARGS are used as the final cons of the result, so if the final + element of ARGS is not a list, the result is a dotted list. With + no ARGS, return nil. (-cons* 1 2) - ⇒ '(1 . 2) + ⇒ (1 . 2) (-cons* 1 2 3) - ⇒ '(1 2 . 3) + ⇒ (1 2 . 3) (-cons* 1) ⇒ 1 @@ -1613,32 +1730,45 @@ Other list functions not fit to be classified elsewhere. If ELEMENTS is non nil, append these to the list as well. (-snoc '(1 2 3) 4) - ⇒ '(1 2 3 4) + ⇒ (1 2 3 4) (-snoc '(1 2 3) 4 5 6) - ⇒ '(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)) + ⇒ (1 2 3 (4 5 6)) -- Function: -interpose (sep list) Return a new list of all elements in LIST separated by SEP. - (-interpose "-" '()) - ⇒ '() + (-interpose "-" ()) + ⇒ () (-interpose "-" '("a")) - ⇒ '("a") + ⇒ ("a") (-interpose "-" '("a" "b" "c")) - ⇒ '("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") + ⇒ (1 "a" 2 "b") (-interleave '(1 2) '("a" "b") '("A" "B")) - ⇒ '(1 "a" "A" 2 "b" "B") + ⇒ (1 "a" "A" 2 "b" "B") (-interleave '(1 2 3) '("a" "b")) - ⇒ '(1 "a" 2 "b") + ⇒ (1 "a" 2 "b") + + -- Function: -iota (count &optional start step) + Return a list containing COUNT numbers. Starts from START and adds + STEP each time. The default START is zero, the default STEP is 1. + This function takes its name from the corresponding primitive in + the APL language. + + (-iota 6) + ⇒ (0 1 2 3 4 5) + (-iota 4 2.5 -2) + ⇒ (2.5 0.5 -1.5 -3.5) + (-iota -1) + error→ Wrong type argument: natnump, -1 -- Function: -zip-with (fn list1 list2) Zip the two lists LIST1 and LIST2 using a function FN. This @@ -1650,11 +1780,11 @@ Other list functions not fit to be classified elsewhere. symbol ‘it’, and the elements from LIST2 as symbol ‘other’. (-zip-with '+ '(1 2 3) '(4 5 6)) - ⇒ '(5 7 9) + ⇒ (5 7 9) (-zip-with 'cons '(1 2 3) '(4 5 6)) - ⇒ '((1 . 4) (2 . 5) (3 . 6)) + ⇒ ((1 . 4) (2 . 5) (3 . 6)) (--zip-with (concat it " and " other) '("Batman" "Jekyll") '("Robin" "Hyde")) - ⇒ '("Batman and Robin" "Jekyll and Hyde") + ⇒ ("Batman and Robin" "Jekyll and Hyde") -- Function: -zip (&rest lists) Zip LISTS together. Group the head of each list, followed by the @@ -1674,11 +1804,11 @@ Other list functions not fit to be classified elsewhere. See also: ‘-zip-lists’ (*note -zip-lists::) (-zip '(1 2 3) '(4 5 6)) - ⇒ '((1 . 4) (2 . 5) (3 . 6)) + ⇒ ((1 . 4) (2 . 5) (3 . 6)) (-zip '(1 2 3) '(4 5 6 7)) - ⇒ '((1 . 4) (2 . 5) (3 . 6)) + ⇒ ((1 . 4) (2 . 5) (3 . 6)) (-zip '(1 2) '(3 4 5) '(6)) - ⇒ '((1 3 6)) + ⇒ ((1 3 6)) -- Function: -zip-lists (&rest lists) Zip LISTS together. Group the head of each list, followed by the @@ -1693,11 +1823,11 @@ Other list functions not fit to be classified elsewhere. See also: ‘-zip’ (*note -zip::) (-zip-lists '(1 2 3) '(4 5 6)) - ⇒ '((1 4) (2 5) (3 6)) + ⇒ ((1 4) (2 5) (3 6)) (-zip-lists '(1 2 3) '(4 5 6 7)) - ⇒ '((1 4) (2 5) (3 6)) + ⇒ ((1 4) (2 5) (3 6)) (-zip-lists '(1 2) '(3 4 5) '(6)) - ⇒ '((1 3 6)) + ⇒ ((1 3 6)) -- Function: -zip-fill (fill-value &rest lists) Zip LISTS, with FILL-VALUE padded onto the shorter lists. The @@ -1705,7 +1835,7 @@ Other list functions not fit to be classified elsewhere. 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)) + ⇒ ((1 . 6) (2 . 7) (3 . 8) (4 . 9) (5 . 0)) -- Function: -unzip (lists) Unzip LISTS. @@ -1723,33 +1853,33 @@ Other list functions not fit to be classified elsewhere. 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")) + ⇒ ((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)) + ⇒ ((1 3 5 7 9) (2 4 6 8 10)) (-unzip '((1 2) (3 4))) - ⇒ '((1 . 3) (2 . 4)) + ⇒ ((1 . 3) (2 . 4)) -- Function: -cycle (list) Return an infinite circular copy of LIST. The returned list cycles through the elements of LIST and repeats from the beginning. (-take 5 (-cycle '(1 2 3))) - ⇒ '(1 2 3 1 2) + ⇒ (1 2 3 1 2) (-take 7 (-cycle '(1 "and" 3))) - ⇒ '(1 "and" 3 1 "and" 3 1) + ⇒ (1 "and" 3 1 "and" 3 1) (-zip (-cycle '(1 2 3)) '(1 2)) - ⇒ '((1 . 1) (2 . 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 ()) + ⇒ (nil) (-pad 0 '(1)) - ⇒ '((1)) + ⇒ ((1)) (-pad 0 '(1 2 3) '(4 5)) - ⇒ '((1 2 3) (4 5 0)) + ⇒ ((1 2 3) (4 5 0)) -- Function: -table (fn &rest lists) Compute outer product of LISTS using function FN. @@ -1764,11 +1894,11 @@ Other list functions not fit to be classified elsewhere. See also: ‘-table-flat’ (*note -table-flat::) (-table '* '(1 2 3) '(1 2 3)) - ⇒ '((1 2 3) (2 4 6) (3 6 9)) + ⇒ ((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)) + ⇒ ((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)))) + ⇒ ((((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. @@ -1789,38 +1919,27 @@ Other list functions not fit to be classified elsewhere. -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)) + ⇒ ((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) + ⇒ (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)) + ⇒ ((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. + Return the first item in LIST for which PRED returns non-nil. + Return nil if no such element is found. To get the first item in + the list no questions asked, use ‘car’. - To get the first item in the list no questions asked, use ‘car’. + Alias: ‘-find’. - Alias: ‘-find’ + This function’s anaphoric counterpart is ‘--first’. - (-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)) + (-first #'natnump '(-1 0 1)) + ⇒ 0 + (-first #'null '(1 2 3)) ⇒ nil - (-some 'null '(1 2 nil)) - ⇒ t + (--first (> it 2) '(1 2 3)) + ⇒ 3 -- Function: -last (pred list) Return the last x in LIST where (PRED x) is non-nil, else nil. @@ -1838,34 +1957,28 @@ Other list functions not fit to be classified elsewhere. 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) + ⇒ (5 2 3) - -- Function: -second-item (arg1) + -- Function: -second-item (list) 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) + -- Function: -third-item (list) 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) @@ -1899,15 +2012,15 @@ Other list functions not fit to be classified elsewhere. (-last-item nil) ⇒ nil (let ((list (list 1 2 3))) (setf (-last-item list) 5) list) - ⇒ '(1 2 5) + ⇒ (1 2 5) -- Function: -butlast (list) Return a list of all items in list except for the last. (-butlast '(1 2 3)) - ⇒ '(1 2) + ⇒ (1 2) (-butlast '(1 2)) - ⇒ '(1) + ⇒ (1) (-butlast '(1)) ⇒ nil @@ -1918,34 +2031,38 @@ Other list functions not fit to be classified elsewhere. first element should sort before the second. (-sort '< '(3 1 2)) - ⇒ '(1 2 3) + ⇒ (1 2 3) (-sort '> '(3 1 2)) - ⇒ '(3 2 1) + ⇒ (3 2 1) (--sort (< it other) '(3 1 2)) - ⇒ '(1 2 3) + ⇒ (1 2 3) - -- Function: -list (&rest args) - Return a list with ARGS. + -- Function: -list (arg) + Ensure ARG is a list. If ARG is already a list, return it as is + (not a copy). Otherwise, return a new list with ARG as its only + element. - If first item of ARGS is already a list, simply return ARGS. If - not, return a list with ARGS as elements. + Another supported calling convention is (-list &rest ARGS). In + this case, if ARG is not a list, a new list with all of ARGS as + elements is returned. This use is supported for backward + compatibility and is otherwise deprecated. (-list 1) - ⇒ '(1) - (-list 1 2 3) - ⇒ '(1 2 3) + ⇒ (1) + (-list ()) + ⇒ () (-list '(1 2 3)) - ⇒ '(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") + (-fix (lambda (l) (-non-nil (--mapcat (-split-at (/ (length it) 2) it) l))) '((1 2 3))) + ⇒ ((1) (2) (3)) + (let ((l '((starwars scifi) (jedi starwars warrior)))) (--fix (-uniq (--mapcat (cons it (cdr (assq it l))) it)) '(jedi book))) + ⇒ (jedi starwars warrior scifi book)  File: dash.info, Node: Tree operations, Next: Threading macros, Prev: Other list operations, Up: Functions @@ -1969,22 +2086,22 @@ Functions pretending lists are trees. 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) + ⇒ ((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) + ⇒ ((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) + ⇒ ([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)) + ⇒ (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)) + ⇒ ((1 . 2) ((2 . 4) (3 . 8)) (4 . 16)) (--tree-map (length it) '("" ("

" "text" "

") "")) - ⇒ '(6 (3 4 4) 7) + ⇒ (6 (3 4 4) 7) -- Function: -tree-map-nodes (pred fun tree) Call FUN on each node of TREE that satisfies PRED. @@ -1993,11 +2110,11 @@ Functions pretending lists are trees. 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)) + ⇒ (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)) + ⇒ (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))) + ⇒ (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 @@ -2029,7 +2146,7 @@ Functions pretending lists are trees. (-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) + ⇒ ((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. @@ -2044,7 +2161,7 @@ Functions pretending lists are trees. 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) + ⇒ (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)))) @@ -2065,9 +2182,9 @@ Functions pretending lists are trees. (-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}}" + ⇒ (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) "}" '((elisp-mode (foo (bar . booze)) (baz . qux)) (c-mode (foo . bla) (bum . bam))))) + ⇒ "{elisp-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 @@ -2075,7 +2192,7 @@ Functions pretending lists are trees. 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) + ⇒ (1 2 3)  File: dash.info, Node: Threading macros, Next: Binding, Prev: Tree operations, Up: Functions @@ -2083,6 +2200,9 @@ File: dash.info, Node: Threading macros, Next: Binding, Prev: Tree operations 2.12 Threading macros ===================== +Macros that conditionally combine sequential forms for brevity or +readability. + -- 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. @@ -2090,11 +2210,11 @@ File: dash.info, Node: Threading macros, Next: Binding, Prev: Tree operations in second form, etc. (-> '(2 3 5)) - ⇒ '(2 3 5) + ⇒ (2 3 5) (-> '(2 3 5) (append '(8 13))) - ⇒ '(2 3 5 8 13) + ⇒ (2 3 5 8 13) (-> '(2 3 5) (append '(8 13)) (-slice 1 -1)) - ⇒ '(3 5 8) + ⇒ (3 5 8) -- Macro: ->> (x &optional form &rest more) Thread the expr through the forms. Insert X as the last item in @@ -2103,9 +2223,9 @@ File: dash.info, Node: Threading macros, Next: Binding, Prev: Tree operations second form, etc. (->> '(1 2 3) (-map 'square)) - ⇒ '(1 4 9) + ⇒ (1 4 9) (->> '(1 2 3) (-map 'square) (-remove 'even?)) - ⇒ '(1 9) + ⇒ (1 9) (->> '(1 2 3) (-map 'square) (-reduce '+)) ⇒ 14 @@ -2130,7 +2250,7 @@ File: dash.info, Node: Threading macros, Next: Binding, Prev: Tree operations 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) + ⇒ (8) (-as-> 3 my-var 1+) ⇒ 4 (-as-> 3 my-var) @@ -2142,7 +2262,7 @@ File: dash.info, Node: Threading macros, Next: Binding, Prev: Tree operations form, etc. (-some-> '(2 3 5)) - ⇒ '(2 3 5) + ⇒ (2 3 5) (-some-> 5 square) ⇒ 25 (-some-> 5 even? square) @@ -2154,40 +2274,52 @@ File: dash.info, Node: Threading macros, Next: Binding, Prev: Tree operations form, etc. (-some->> '(1 2 3) (-map 'square)) - ⇒ '(1 4 9) + ⇒ (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 is non-nil, thread it through the first form (via ‘-->’ - (*note -->::)), and when that result is non-nil, through the next - form, etc. + -- Macro: -some--> (expr &rest forms) + Thread EXPR through FORMS via ‘-->’ (*note -->::), while the result + is non-nil. When EXPR evaluates to non-nil, thread the result + through the first of FORMS, and when that result is non-nil, thread + it 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 + (-some--> '(0 1) (-remove #'natnump it) (append it it) (-map #'1+ it)) + ⇒ () + + -- Macro: -doto (init &rest forms) + Evaluate INIT and pass it as argument to FORMS with ‘->’ (*note + ->::). The RESULT of evaluating INIT is threaded through each of + FORMS individually using ‘->’ (*note ->::), which see. The return + value is RESULT, which FORMS may have modified by side effect. + + (-doto (list 1 2 3) pop pop) + ⇒ (3) + (-doto (cons 1 2) (setcar 3) (setcdr 4)) + ⇒ (3 . 4) + (gethash 'k (--doto (make-hash-table) (puthash 'k 'v it))) + ⇒ v  -File: dash.info, Node: Binding, Next: Side-effects, Prev: Threading macros, Up: Functions +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 +Macros that combine ‘let’ and ‘let*’ with destructuring and flow control. - -- Macro: -when-let (var-val &rest body) + -- 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) @@ -2208,14 +2340,12 @@ control. (-when-let* ((x 5) (y nil) (z 7)) (+ x y z)) ⇒ nil - -- Macro: -if-let (var-val then &rest else) + -- 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) @@ -2397,11 +2527,11 @@ control. 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) + ⇒ (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)) + ⇒ (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) + ⇒ (1 2) -- Macro: -let* (varlist &rest body) Bind variables according to VARLIST then eval BODY. @@ -2417,11 +2547,11 @@ control. 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) + ⇒ (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) + ⇒ (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)) + ⇒ (1 a b c (a b c)) -- Macro: -lambda (match-form &rest body) Return a lambda which destructures its input as MATCH-FORM and @@ -2433,19 +2563,20 @@ control. (-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. + translated into normal ‘lambda’, so there is no performance + penalty. - See ‘-let’ (*note -let::) for the description of destructuring + See ‘-let’ (*note -let::) for a description of the destructuring mechanism. (-map (-lambda ((x y)) (+ x y)) '((1 2) (3 4) (5 6))) - ⇒ '(3 7 11) + ⇒ (3 7 11) (-map (-lambda ([x y]) (+ x y)) '([1 2] [3 4] [5 6])) - ⇒ '(3 7 11) + ⇒ (3 7 11) (funcall (-lambda ((_ . a) (_ . b)) (-concat a b)) '(1 2 3) '(4 5 6)) - ⇒ '(2 3 5 6) + ⇒ (2 3 5 6) - -- Macro: -setq (&rest forms) + -- Macro: -setq ([match-form val] ...) Bind each MATCH-FORM to the value of its VAL. MATCH-FORM destructuring is done according to the rules of ‘-let’ @@ -2463,123 +2594,130 @@ control. 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) + (let (a) (-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) + (let (a b) (-setq (a b) (list 1 2)) (list a b)) + ⇒ (1 2) + (let (c) (-setq (&plist :c c) (list :c "c")) c) ⇒ "c"  -File: dash.info, Node: Side-effects, Next: Destructive operations, Prev: Binding, Up: Functions +File: dash.info, Node: Side effects, Next: Destructive operations, Prev: Binding, Up: Functions -2.14 Side-effects +2.14 Side effects ================= -Functions iterating over lists for side-effect only. +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. + Call FN on each element of LIST. Return nil; this function is + intended for side effects. - (let (s) (-each '(1 2 3) (lambda (item) (setq s (cons item s))))) + Its anaphoric counterpart is ‘--each’. + + For access to the current element’s index in LIST, see + ‘-each-indexed’ (*note -each-indexed::). + + (let (l) (-each '(1 2 3) (lambda (x) (push x l))) l) + ⇒ (3 2 1) + (let (l) (--each '(1 2 3) (push it l)) l) + ⇒ (3 2 1) + (-each '(1 2 3) #'identity) ⇒ 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) (push item s))) s) - ⇒ '(4 2) - (let (s) (--each-while '(1 2 3 4) (< it 3) (push it s)) s) - ⇒ '(2 1) - (let ((s 0)) (--each-while '(1 3 4 5) (odd? it) (setq s (+ s it))) s) - ⇒ 4 + Call FN on each ITEM in LIST, while (PRED ITEM) is non-nil. Once + an ITEM is reached for which PRED returns nil, FN is no longer + called. Return nil; this function is intended for side effects. - -- Function: -each-indexed (list fn) - Call (FN index item) for each item in LIST. + Its anaphoric counterpart is ‘--each-while’. + + (let (l) (-each-while '(2 4 5 6) #'even? (lambda (x) (push x l))) l) + ⇒ (4 2) + (let (l) (--each-while '(1 2 3 4) (< it 3) (push it l)) l) + ⇒ (2 1) + (let ((s 0)) (--each-while '(1 3 4 5) (< it 5) (setq s (+ s it))) s) + ⇒ 8 - In the anaphoric form ‘--each-indexed’, the index is exposed as - symbol ‘it-index’. + -- Function: -each-indexed (list fn) + Call FN on each index and element of LIST. For each ITEM at INDEX + in LIST, call (funcall FN INDEX ITEM). Return nil; this function + is intended for side effects. 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)) + (let (l) (-each-indexed '(a b c) (lambda (i x) (push (list x i) l))) l) + ⇒ ((c 2) (b 1) (a 0)) + (let (l) (--each-indexed '(a b c) (push (list it it-index) l)) l) + ⇒ ((c 2) (b 1) (a 0)) + (let (l) (--each-indexed () (push it l)) l) + ⇒ () -- Function: -each-r (list fn) - Call FN with every item in LIST in reversed order. Return nil, - used for side-effects only. + Call FN on each element of LIST in reversed order. Return nil; + this function is intended for side effects. + + Its anaphoric counterpart is ‘--each-r’. - (let (s) (-each-r '(1 2 3) (lambda (item) (setq s (cons item s))))) + (let (l) (-each-r '(1 2 3) (lambda (x) (push x l))) l) + ⇒ (1 2 3) + (let (l) (--each-r '(1 2 3) (push it l)) l) + ⇒ (1 2 3) + (-each-r '(1 2 3) #'identity) ⇒ 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) + Call FN on each ITEM in reversed LIST, while (PRED ITEM) is + non-nil. Once an ITEM is reached for which PRED returns nil, FN is + no longer called. Return nil; this function is intended for side + effects. + + Its anaphoric counterpart is ‘--each-r-while’. + + (let (l) (-each-r-while '(2 4 5 6) #'even? (lambda (x) (push x l))) l) + ⇒ (6) + (let (l) (--each-r-while '(1 2 3 4) (>= it 3) (push it l)) l) + ⇒ (3 4) + (let ((s 0)) (--each-r-while '(1 2 3 5) (> it 1) (setq s (+ s it))) s) + ⇒ 10 -- Function: -dotimes (num fn) - Call FN NUM times, presumably for side-effects. FN is called with + Call FN NUM times, presumably for side effects. FN is called with a single argument on successive integers running from 0, inclusive, to NUM, exclusive. FN is not called if NUM is less than 1. + This function’s anaphoric counterpart is ‘--dotimes’. + (let (s) (-dotimes 3 (lambda (n) (push n s))) s) - ⇒ '(2 1 0) + ⇒ (2 1 0) (let (s) (-dotimes 0 (lambda (n) (push n s))) s) - ⇒ nil + ⇒ () (let (s) (--dotimes 5 (push it s)) s) - ⇒ '(4 3 2 1 0) - - -- Macro: -doto (init &rest forms) - Evaluate INIT and thread the result as the 2nd argument to other - FORMS. INIT is evaluated once. Its result is passed to FORMS, - which are then evaluated sequentially. Returns the target form. - - (-doto (list 1 2 3) (pop) (pop)) - ⇒ '(3) - (-doto (cons 1 2) (setcar 3) (setcdr 4)) - ⇒ '(3 . 4) - (gethash 'k (--doto (make-hash-table) (puthash 'k 'v it))) - ⇒ 'v + ⇒ (4 3 2 1 0)  -File: dash.info, Node: Destructive operations, Next: Function combinators, Prev: Side-effects, Up: Functions +File: dash.info, Node: Destructive operations, Next: Function combinators, Prev: Side effects, Up: Functions 2.15 Destructive operations =========================== +Macros that modify variables holding lists. + -- Macro: !cons (car cdr) Destructive: Set CDR to the cons of CAR and CDR. (let (l) (!cons 5 l) l) - ⇒ '(5) + ⇒ (5) (let ((l '(3))) (!cons 5 l) l) - ⇒ '(5 3) + ⇒ (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) + ⇒ (5)  File: dash.info, Node: Function combinators, Prev: Destructive operations, Up: Functions @@ -2587,91 +2725,127 @@ File: dash.info, Node: Function combinators, Prev: Destructive operations, Up 2.16 Function combinators ========================= -These combinators require Emacs 24 for its lexical scope. So they are -offered in a separate package: ‘dash-functional‘. +Functions that manipulate and compose other functions. - -- Function: -partial (fn &rest args) - Take a function FN and fewer than the normal arguments to FN, and - return a fn that takes a variable number of additional ARGS. When - called, the returned function calls FN with ARGS first and then - additional args. + -- Function: -partial (fun &rest args) + Return a function that is a partial application of FUN to ARGS. + ARGS is a list of the first N arguments to pass to FUN. The result + is a new function which does the same as FUN, except that the first + N arguments are fixed at the values with which this function was + called. - (funcall (-partial '- 5) 3) + (funcall (-partial #'+ 5)) + ⇒ 5 + (funcall (-partial #'- 5) 3) ⇒ 2 - (funcall (-partial '+ 5 2) 3) + (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) + Return a function that is a partial application of FN to ARGS. + ARGS is a list of the last N arguments to pass to FN. The result + is a new function which does the same as FN, except that the last N + arguments are fixed at the values with which this function was + called. This is like ‘-partial’ (*note -partial::), except the + arguments are fixed starting from the right rather than the left. + + (funcall (-rpartial #'- 5)) + ⇒ -5 + (funcall (-rpartial #'- 5) 8) ⇒ 3 - (funcall (-rpartial '- 5 2) 10) + (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). + Return a function that is the juxtaposition of FNS. The returned + function takes a variable number of ARGS, applies each of FNS in + turn to ARGS, and returns the list of results. - (funcall (-juxt '+ '-) 3 5) - ⇒ '(8 -2) - (-map (-juxt 'identity 'square) '(1 2 3)) - ⇒ '((1 1) (2 4) (3 9)) + (funcall (-juxt) 1 2) + ⇒ () + (funcall (-juxt #'+ #'- #'* #'/) 7 5) + ⇒ (12 2 35 1) + (mapcar (-juxt #'number-to-string #'1+) '(1 2)) + ⇒ (("1" 2) ("2" 3)) -- 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) + Compose FNS into a single composite function. Return a function + that takes a variable number of ARGS, applies the last function in + FNS to ARGS, and returns the result of calling each remaining + function on the result of the previous function, right-to-left. If + no FNS are given, return a variadic ‘identity’ function. + + (funcall (-compose #'- #'1+ #'+) 1 2 3) + ⇒ -7 + (funcall (-compose #'identity #'1+) 3) + ⇒ 4 + (mapcar (-compose #'not #'stringp) '(nil "")) + ⇒ (t nil) -- 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)) + Return a function that applies FN to a single list of args. This + changes the arity of FN from taking N distinct arguments to taking + 1 argument which is a list of N arguments. + + (funcall (-applify #'+) nil) + ⇒ 0 + (mapcar (-applify #'+) '((1 1 1) (1 2 3) (5 5 5))) + ⇒ (3 6 15) + (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). + -- Function: -on (op trans) + Return a function that calls TRANS on each arg and OP on the + results. The returned function takes a variable number of + arguments, calls the function TRANS on each one in turn, and then + passes those results as the list of arguments to OP, in the same + order. - In types: (b -> b -> c) -> (a -> b) -> a -> a -> c + For example, the following pairs of expressions are morally + equivalent: - (-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 + (funcall (-on #’+ #’1+) 1 2 3) = (+ (1+ 1) (1+ 2) (1+ 3)) (funcall + (-on #’+ #’1+)) = (+) - -- Function: -flip (func) - Swap the order of arguments for binary function FUNC. + (-sort (-on #'< #'length) '((1 2 3) (1) (1 2))) + ⇒ ((1) (1 2) (1 2 3)) + (funcall (-on #'min #'string-to-number) "22" "2" "1" "12") + ⇒ 1 + (-min-by (-on #'> #'length) '((1 2 3) (4) (1 2))) + ⇒ (4) - In types: (a -> b -> c) -> b -> a -> c + -- Function: -flip (fn) + Return a function that calls FN with its arguments reversed. The + returned function takes the same number of arguments as FN. - (funcall (-flip '<) 2 1) - ⇒ t - (funcall (-flip '-) 3 8) - ⇒ 5 - (-sort (-flip '<) '(4 3 6 1)) - ⇒ '(6 4 3 1) + For example, the following two expressions are morally equivalent: + + (funcall (-flip #’-) 1 2) = (- 2 1) + + See also: ‘-rotate-args’ (*note -rotate-args::). + + (-sort (-flip #'<) '(4 3 6 1)) + ⇒ (6 4 3 1) + (funcall (-flip #'-) 3 2 1 10) + ⇒ 4 + (funcall (-flip #'1+) 1) + ⇒ 2 + + -- Function: -rotate-args (n fn) + Return a function that calls FN with args rotated N places to the + right. The returned function takes the same number of arguments as + FN, rotates the list of arguments N places to the right (left if N + is negative) just like ‘-rotate’ (*note -rotate::), and applies FN + to the result. + + See also: ‘-flip’ (*note -flip::). + + (funcall (-rotate-args -1 #'list) 1 2 3 4) + ⇒ (2 3 4 1) + (funcall (-rotate-args 1 #'-) 1 10 100) + ⇒ 89 + (funcall (-rotate-args 2 #'list) 3 4 5 1 2) + ⇒ (1 2 3 4 5) -- Function: -const (c) Return a function that returns C ignoring any additional arguments. @@ -2680,9 +2854,9 @@ offered in a separate package: ‘dash-functional‘. (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"))) + (mapcar (-const 1) '("a" "b" "c" "d")) + ⇒ (1 1 1 1) + (-sum (mapcar (-const 1) '("a" "b" "c" "d"))) ⇒ 4 -- Macro: -cut (&rest params) @@ -2692,46 +2866,59 @@ offered in a separate package: ‘dash-functional‘. 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] "") + ⇒ (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 vector string)) + ⇒ ((1 2 3) [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. + Return a predicate that negates the result of PRED. The returned + predicate passes its arguments to PRED. If PRED returns nil, the + result is non-nil; otherwise the result is nil. + + See also: ‘-andfn’ (*note -andfn::) and ‘-orfn’ (*note -orfn::). - (funcall (-not 'even?) 5) + (funcall (-not #'numberp) "5") ⇒ t - (-filter (-not (-partial '< 4)) '(1 2 3 4 5 6 7 8)) - ⇒ '(1 2 3 4) + (-sort (-not #'<) '(5 2 1 0 6)) + ⇒ (6 5 2 1 0) + (-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") + Return a predicate that returns the first non-nil result of PREDS. + The returned predicate takes a variable number of arguments, passes + them to each predicate in PREDS in turn until one of them returns + non-nil, and returns that non-nil result without calling the + remaining PREDS. If all PREDS return nil, or if no PREDS are + given, the returned predicate returns nil. + + See also: ‘-andfn’ (*note -andfn::) and ‘-not’ (*note -not::). + + (-filter (-orfn #'natnump #'booleanp) '(1 nil "a" -4 b c t)) + ⇒ (1 nil t) + (funcall (-orfn #'symbolp (-cut string-match-p "x" <>)) "axe") + ⇒ 1 + (funcall (-orfn #'= #'+) 1 1) ⇒ 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) + Return a predicate that returns non-nil if all PREDS do so. The + returned predicate P takes a variable number of arguments and + passes them to each predicate in PREDS in turn. If any one of + PREDS returns nil, P also returns nil without calling the remaining + PREDS. If all PREDS return non-nil, P returns the last such value. + If no PREDS are given, P always returns non-nil. + + See also: ‘-orfn’ (*note -orfn::) and ‘-not’ (*note -not::). + + (-filter (-andfn #'numberp (-cut < <> 5)) '(a 1 b 6 c 2)) + ⇒ (1 2) + (mapcar (-andfn #'numberp #'1+) '(a 1 b 6)) + ⇒ (nil 2 nil 7) + (funcall (-andfn #'= #'+) 1 1) + ⇒ 2 -- Function: -iteratefn (fn n) Return a function FN composed N times with itself. @@ -2754,7 +2941,7 @@ offered in a separate package: ‘dash-functional‘. (funcall (-iteratefn '1+ 3) 1) ⇒ 4 (funcall (-iteratefn 'cdr 3) '(1 2 3 4 5)) - ⇒ '(4 5) + ⇒ (4 5) -- Function: -fixfn (fn &optional equal-test halt-test) Return a function that computes the (least) fixpoint of FN. @@ -2783,12 +2970,12 @@ offered in a separate package: ‘dash-functional‘. In types: (a -> a) -> a -> a. - (funcall (-fixfn 'cos 'approx-equal) 0.7) + (funcall (-fixfn #'cos #'approx=) 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) + (funcall (-fixfn #'sin #'approx=) 0.1) + ⇒ (halted . t) -- Function: -prodfn (&rest fns) Take a list of n functions and return a function that takes a list @@ -2807,9 +2994,9 @@ offered in a separate package: ‘dash-functional‘. ...)) = (-compose fn (-partial ’nth n)) (funcall (-prodfn '1+ '1- 'number-to-string) '(1 2 3)) - ⇒ '(2 1 "3") + ⇒ (2 1 "3") (-map (-prodfn '1+ '1-) '((1 2) (3 4) (5 6) (7 8))) - ⇒ '((2 1) (4 3) (6 5) (8 7)) + ⇒ ((2 1) (4 3) (6 5) (8 7)) (apply '+ (funcall (-prodfn 'length 'string-to-number) '((1 2 3) "15"))) ⇒ 18 @@ -2825,11 +3012,10 @@ The Dash repository is hosted on GitHub at * Menu: * Contribute:: How to contribute. -* Change log:: List of significant changes by version. * Contributors:: List of contributors.  -File: dash.info, Node: Contribute, Next: Change log, Up: Development +File: dash.info, Node: Contribute, Next: Contributors, Up: Development 3.1 Contribute ============== @@ -2843,7 +3029,7 @@ docs’. Contributors are encouraged to install these commands as a Git 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 + $ cp dev/pre-commit.sh .git/hooks/pre-commit Oh, and don’t edit ‘README.md’ or ‘dash.texi’ directly, as they are auto-generated. Instead, change their respective templates @@ -2854,212 +3040,9 @@ require that all contributors assign copyright to the Free Software Foundation. For more on this, *note (emacs)Copyright Assignment::.  -File: dash.info, Node: Change log, Next: Contributors, Prev: Contribute, Up: Development - -3.2 Change log -============== - -Changes in 2.17: - - • Sped up ‘-uniq’ by using hash-tables when possible (Zhu - Zihao). - • Fixed ‘-inits’ to be non-destructive (Zach Shaftel). - • Fixed indent rules for ‘-some->’ and family (Wouter - Bolsterlee). - • Added ‘-zip-lists’ which always returns a list of proper - lists, even for two input lists (see issue #135). - -Changes in 2.16: - - • Added ‘--doto’, anaphoric version of ‘-doto’. - • Aliased ‘-cons-pair-p’ to ‘-cons-pair?’. - • Generalized ‘-rotate’ for |N| greater than the length of the - list (Brian Leung). - • Added a mechanism to extend destructuring with custom matchers - (Ivan Yonchovski). - -Changes in 2.15: - - This release brought new destructuring features, some new control - flow functions, and performance optimizations. - - • Added ‘-setq’ with destructuring binding support similar to - the ‘-let’ family. - • Added smarter key destructuring in ‘-let’ and friends where - variables are auto-derived from keys. - • Allowed ‘-let’ bindings without a source value form. - • Added ‘-each-r’ and ‘-each-r-while’ (Paul Pogonyshev). - • Added ‘-common-suffix’ (Basil L. Contovounesios). - • Improved performance of folds (‘-reduce’ and friends) (Basil - L. Contovounesios). - -Changes in 2.14: - - This release retired support for Emacs 23. - - • Added Edebug support for threading macros (Wilfred Hughes). - • Added ‘-unzip’. - • Added support for ‘-first-item’ and ‘-last-item’ as place - forms (*note (elisp)Generalized Variables::). - • Added ‘-powerset’ and ‘-permutations’ (Mark Oteiza). - • Added ‘-as->’ for threading a named variable (Zachary Kanfer). - • Added ‘-partition-after-pred’, ‘-partition-before-pred’, - ‘-partition-after-item’, and ‘-partition-before-item’ (Zachary - Kanfer). - • Fixed a bug in ‘-any-p’ and friends testing for ‘null’ on - lists containing ‘nil’. - • Fixed infinite loop bug in ‘-zip’ and ‘-interleave’ when - called with empty input. - • Added ‘-second-item’ through ‘-fifth-item’ as alternatives to - ‘nth’ (Wilfred Hughes). - • Added ‘-tails’ and ‘-inits’. - • Added ‘-running-sum’ and ‘-running-product’. - • Added the ‘-reductions[-r][-from]’ family of functions (like - ‘-reduce’ but collecting intermediate results). - • Added ‘-common-prefix’ (Basil L. Contovounesios). - -Changes in 2.13: - - • ‘-let’ now supports ‘&alist’ destructuring. - • Various performance improvements. - • ‘-zip’ might change in a future release to always return a - list of proper lists. Added ‘-zip-pair’ for users who - explicitly want the old behavior. - • Enabled lexical binding in ‘dash.el’ for Emacs versions 24 or - newer. - • Added ‘-select-column’ and ‘-select-columns’. - • Fixed ‘-map-last’ and ‘--remove-last’ to be non-destructive. - • Added ‘-each-indexed’ and ‘--each-indexed’. - • Added ‘-take-last’ and ‘-drop-last’. - • Added the ‘-doto’ macro. - • ‘-cut <>’ is now treated as a function, consistent with SRFI - 26 (https://srfi.schemers.org/srfi-26/srfi-26.html). - -Changes in 2.12: - - • Added GNU ELPA support (Phillip Lord). - • Added ‘-some->’, ‘-some->>’, and ‘-some-->’ macros (Cam Saul). - • ‘-is-suffix?’ is now non-destructive. - • Faster hash table implementation for ‘-union’. - • Improvements to docstrings and examples. - -Changes in 2.11: - - • Lots of clean up w.r.t. byte compilation, debug macros, and - tests. - -Changes in 2.10: - - • Added ‘-let’ destructuring to ‘-if-let’ and ‘-when-let’ - (Fredrik Bergroth). - -Changes in 2.9: - - • Added ‘-let’, ‘-let*’, and ‘-lambda’ with destructuring. - • Added ‘-tree-seq’ and ‘-tree-map-nodes’. - • Added ‘-non-nil’. - • Added ‘-fix’. - • Added ‘-fixfn’ (‘dash-functional’ version 1.2). - • Added ‘-copy’ (Wilfred Hughes). - -Changes in 2.8: - - • Added ‘-butlast’. - -Changes in 2.7: - - • ‘-zip’ now supports more than two lists (Steve Lamb). - • Added ‘-cycle’, ‘-pad’, ‘-annotate’, and ‘-zip-fill’ (Steve - Lamb). - • Added ‘-table’, ‘-table-flat’ (finite Cartesian product). - • Added ‘-flatten-n’. - • ‘-slice’ now supports a “step” argument. - • Added functional combinators ‘-iteratefn’ and ‘-prodfn’. - • Added ‘-replace’, ‘-splice’, and ‘-splice-list’ which - generalize ‘-replace-at’ and ‘-insert-at’. - • Added ‘-compose’, ‘-iteratefn’, and ‘-prodfn’ - (‘dash-functional’ version 1.1). - -Changes in 2.6: - - • Added ‘-is-prefix-p’, ‘-is-suffix-p’, and ‘-is-infix-p’ (Matus - Goljer). - • Added ‘-iterate’ and ‘-unfold’ (Matus Goljer). - • Added ‘-split-on’ and ‘-split-when’ (Matus Goljer). - • Added ‘-find-last-index’ (Matus Goljer). - • Added ‘-list’ (Johan Andersson). - -Changes in 2.5: - - • Added ‘-same-items?’ (Johan Andersson). - • Various bugfixes. - -Changes in 2.4: - - • Added ‘-snoc’ (Matus Goljer). - • Added ‘-replace-at’, ‘-update-at’, ‘-remove-at’, and - ‘-remove-at-indices’ (Matus Goljer). - -Changes in 2.3: - - • Added tree operations (Matus Goljer). - • Made Font Lock optional. - -Changes in 2.2: - - • Added ‘-compose’ (Christina Whyte). - -Changes in 2.1: - - • Added indexing operations (Matus Goljer). - -Changes in 2.0: - - • Split out ‘dash-functional.el’ (Matus Goljer). - • Added ‘-andfn’, ‘-orfn’, ‘-not’, ‘-cut’, ‘-const’, ‘-flip’, - and ‘-on’ (Matus Goljer). - • Fixed ‘-min’, ‘-max’, ‘-min-by’, and ‘-max-by’ (Matus Goljer). - -Changes in 1.8: - - • Added ‘-first-item’ and ‘-last-item’ (Wilfred Hughes). - -Changes in 1.7: - - • Added ‘-rotate’ (Matus Goljer). - -Changes in 1.6: - - • Added ‘-min’, ‘-max’, ‘-min-by’, and ‘-max-by’ (Johan - Andersson). - -Changes in 1.5: - - • Added ‘-sum’ and ‘-product’ (Johan Andersson). - -Changes in 1.4: - - • Added ‘-sort’. - • Added ‘-reduce-r’ (Matus Goljer). - • Added ‘-reduce-r-from’ (Matus Goljer). - -Changes in 1.3: - - • Added ‘-partition-in-steps’. - • Added ‘-partition-all-in-steps’. - -Changes in 1.2: - - • Added ‘-last’ (Matus Goljer). - • Added ‘-insert-at’ (Emanuel Evans). - • Added ‘-when-let’ and ‘-if-let’ (Emanuel Evans). - • Added ‘-when-let*’ and ‘-if-let*’ (Emanuel Evans). - • Various bugfixes. - - -File: dash.info, Node: Contributors, Prev: Change log, Up: Development +File: dash.info, Node: Contributors, Prev: Contribute, Up: Development -3.3 Contributors +3.2 Contributors ================ • Matus Goljer (https://github.com/Fuco1) contributed lots of @@ -3082,8 +3065,8 @@ File: dash.info, Node: Contributors, Prev: Change log, Up: Development • Fredrik Bergroth (https://github.com/fbergroth) made the ‘-if-let’ family use ‘-let’ destructuring and improved the script for generating documentation. - • Mark Oteiza (https://github.com/holomorph) contributed the script - to create an Info manual. + • Mark Oteiza (https://github.com/holomorph) contributed ‘-iota’ and + the script to create an Info manual. • Vasilij Schneidermann (https://github.com/wasamasa) contributed ‘-some’. • William West (https://github.com/occidens) made ‘-fixfn’ more @@ -3091,7 +3074,8 @@ File: dash.info, Node: Contributors, Prev: Change log, Up: Development • Cam Saul (https://github.com/camsaul) contributed ‘-some->’, ‘-some->>’, and ‘-some-->’. • Basil L. Contovounesios (https://github.com/basil-conto) - contributed ‘-common-prefix’. + contributed ‘-common-prefix’, ‘-common-suffix’, and various other + improvements. • Paul Pogonyshev (https://github.com/doublep) contributed ‘-each-r’ and ‘-each-r-while’. @@ -4307,202 +4291,207 @@ Index * Menu: * !cdr: Destructive operations. - (line 14) + (line 16) * !cons: Destructive operations. - (line 6) -* -->: Threading macros. (line 32) -* ->: Threading macros. (line 6) -* ->>: Threading macros. (line 19) -* -all?: Predicates. (line 18) + (line 8) +* -->: Threading macros. (line 35) +* ->: Threading macros. (line 9) +* ->>: Threading macros. (line 22) +* -all?: Predicates. (line 53) * -andfn: Function combinators. - (line 138) -* -annotate: Maps. (line 79) -* -any?: Predicates. (line 6) + (line 184) +* -annotate: Maps. (line 84) +* -any?: Predicates. (line 41) * -applify: Function combinators. - (line 55) -* -as->: Threading macros. (line 46) + (line 63) +* -as->: Threading macros. (line 49) * -butlast: Other list operations. - (line 340) + (line 335) * -clone: Tree operations. (line 122) -* -common-prefix: Reductions. (line 223) -* -common-suffix: Reductions. (line 233) +* -common-prefix: Reductions. (line 242) +* -common-suffix: Reductions. (line 252) * -compose: Function combinators. - (line 42) -* -concat: List to list. (line 22) + (line 49) +* -concat: List to list. (line 23) * -cons*: Other list operations. (line 30) +* -cons-pair?: Predicates. (line 167) * -const: Function combinators. - (line 92) -* -contains?: Predicates. (line 57) -* -copy: Maps. (line 134) -* -count: Reductions. (line 151) + (line 128) +* -contains?: Predicates. (line 100) +* -copy: Maps. (line 139) +* -count: Reductions. (line 172) * -cut: Function combinators. - (line 104) + (line 140) * -cycle: Other list operations. - (line 168) + (line 180) * -difference: Set operations. (line 20) * -distinct: Set operations. (line 62) -* -dotimes: Side-effects. (line 63) -* -doto: Side-effects. (line 75) -* -drop: Sublist selection. (line 128) -* -drop-last: Sublist selection. (line 142) -* -drop-while: Sublist selection. (line 171) -* -each: Side-effects. (line 8) -* -each-indexed: Side-effects. (line 30) -* -each-r: Side-effects. (line 43) -* -each-r-while: Side-effects. (line 54) -* -each-while: Side-effects. (line 19) +* -dotimes: Side effects. (line 80) +* -doto: Threading macros. (line 99) +* -drop: Sublist selection. (line 147) +* -drop-last: Sublist selection. (line 161) +* -drop-while: Sublist selection. (line 192) +* -each: Side effects. (line 8) +* -each-indexed: Side effects. (line 38) +* -each-r: Side effects. (line 52) +* -each-r-while: Side effects. (line 65) +* -each-while: Side effects. (line 24) * -elem-index: Indexing. (line 9) * -elem-indices: Indexing. (line 21) +* -every: Predicates. (line 23) * -fifth-item: Other list operations. - (line 320) + (line 315) * -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 234) + (line 246) * -first-item: Other list operations. - (line 271) + (line 272) * -fix: Other list operations. - (line 376) + (line 375) * -fixfn: Function combinators. - (line 175) -* -flatten: List to list. (line 33) -* -flatten-n: List to list. (line 55) + (line 224) +* -flatten: List to list. (line 34) +* -flatten-n: List to list. (line 56) * -flip: Function combinators. - (line 80) + (line 95) * -fourth-item: Other list operations. - (line 310) + (line 305) * -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) +* -group-by: Partitioning. (line 194) +* -if-let: Binding. (line 34) +* -if-let*: Binding. (line 45) +* -inits: Reductions. (line 222) +* -insert-at: List to list. (line 110) * -interleave: Other list operations. - (line 68) + (line 67) * -interpose: Other list operations. - (line 58) + (line 57) * -intersection: Set operations. (line 32) -* -is-infix?: Predicates. (line 110) -* -is-prefix?: Predicates. (line 86) -* -is-suffix?: Predicates. (line 98) +* -iota: Other list operations. + (line 78) +* -is-infix?: Predicates. (line 153) +* -is-prefix?: Predicates. (line 129) +* -is-suffix?: Predicates. (line 141) * -iterate: Unfolding. (line 9) * -iteratefn: Function combinators. - (line 152) + (line 201) * -juxt: Function combinators. - (line 31) + (line 37) * -keep: List to list. (line 8) -* -lambda: Binding. (line 251) +* -lambda: Binding. (line 247) * -last: Other list operations. - (line 261) + (line 262) * -last-item: Other list operations. - (line 330) -* -let: Binding. (line 65) -* -let*: Binding. (line 231) + (line 325) +* -let: Binding. (line 61) +* -let*: Binding. (line 227) * -list: Other list operations. - (line 363) + (line 358) * -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) +* -map-first: Maps. (line 38) +* -map-indexed: Maps. (line 66) +* -map-last: Maps. (line 52) +* -map-when: Maps. (line 22) +* -mapcat: Maps. (line 128) +* -max: Reductions. (line 286) +* -max-by: Reductions. (line 296) +* -min: Reductions. (line 262) +* -min-by: Reductions. (line 272) +* -non-nil: Sublist selection. (line 94) +* -none?: Predicates. (line 73) * -not: Function combinators. - (line 117) + (line 153) * -on: Function combinators. - (line 66) -* -only-some?: Predicates. (line 42) + (line 75) +* -only-some?: Predicates. (line 85) * -orfn: Function combinators. - (line 126) + (line 167) * -pad: Other list operations. - (line 179) + (line 191) * -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) + (line 8) +* -partition: Partitioning. (line 80) +* -partition-after-item: Partitioning. (line 184) +* -partition-after-pred: Partitioning. (line 151) +* -partition-all: Partitioning. (line 92) +* -partition-all-in-steps: Partitioning. (line 115) +* -partition-before-item: Partitioning. (line 174) +* -partition-before-pred: Partitioning. (line 163) +* -partition-by: Partitioning. (line 127) +* -partition-by-header: Partitioning. (line 138) +* -partition-in-steps: Partitioning. (line 103) * -permutations: Set operations. (line 52) * -powerset: Set operations. (line 44) * -prodfn: Function combinators. - (line 209) -* -product: Reductions. (line 181) -* -reduce: Reductions. (line 46) + (line 258) +* -product: Reductions. (line 201) +* -reduce: Reductions. (line 53) * -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) +* -reduce-r: Reductions. (line 72) +* -reduce-r-from: Reductions. (line 26) +* -reductions: Reductions. (line 136) +* -reductions-from: Reductions. (line 100) +* -reductions-r: Reductions. (line 154) +* -reductions-r-from: Reductions. (line 118) +* -remove: Sublist selection. (line 26) +* -remove-at: List to list. (line 146) +* -remove-at-indices: List to list. (line 159) +* -remove-first: Sublist selection. (line 43) +* -remove-item: Sublist selection. (line 83) +* -remove-last: Sublist selection. (line 64) * -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) +* -replace: List to list. (line 68) +* -replace-at: List to list. (line 121) +* -replace-first: List to list. (line 82) +* -replace-last: List to list. (line 96) * -rotate: Other list operations. (line 8) +* -rotate-args: Function combinators. + (line 112) * -rpartial: Function combinators. - (line 20) -* -running-product: Reductions. (line 191) -* -running-sum: Reductions. (line 169) -* -same-items?: Predicates. (line 72) + (line 22) +* -running-product: Reductions. (line 211) +* -running-sum: Reductions. (line 190) +* -same-items?: Predicates. (line 115) * -second-item: Other list operations. - (line 286) -* -select-by-indices: Sublist selection. (line 185) -* -select-column: Sublist selection. (line 215) -* -select-columns: Sublist selection. (line 196) -* -separate: Partitioning. (line 63) -* -setq: Binding. (line 273) -* -slice: Sublist selection. (line 85) + (line 285) +* -select-by-indices: Sublist selection. (line 208) +* -select-column: Sublist selection. (line 238) +* -select-columns: Sublist selection. (line 219) +* -separate: Partitioning. (line 69) +* -setq: Binding. (line 270) +* -slice: Sublist selection. (line 104) * -snoc: Other list operations. - (line 44) -* -some: Other list operations. - (line 248) -* -some-->: Threading macros. (line 83) -* -some->: Threading macros. (line 59) -* -some->>: Threading macros. (line 71) + (line 43) +* -some: Predicates. (line 8) +* -some-->: Threading macros. (line 86) +* -some->: Threading macros. (line 62) +* -some->>: Threading macros. (line 74) * -sort: Other list operations. - (line 350) -* -splice: Maps. (line 90) -* -splice-list: Maps. (line 110) + (line 345) +* -splice: Maps. (line 95) +* -splice-list: Maps. (line 115) * -split-at: Partitioning. (line 8) -* -split-on: Partitioning. (line 28) -* -split-when: Partitioning. (line 46) -* -split-with: Partitioning. (line 17) -* -sum: Reductions. (line 159) +* -split-on: Partitioning. (line 34) +* -split-when: Partitioning. (line 52) +* -split-with: Partitioning. (line 23) +* -sum: Reductions. (line 180) * -table: Other list operations. - (line 190) + (line 202) * -table-flat: Other list operations. - (line 209) -* -tails: Reductions. (line 213) -* -take: Sublist selection. (line 101) -* -take-last: Sublist selection. (line 114) -* -take-while: Sublist selection. (line 156) + (line 221) +* -tails: Reductions. (line 232) +* -take: Sublist selection. (line 120) +* -take-last: Sublist selection. (line 133) +* -take-while: Sublist selection. (line 175) * -third-item: Other list operations. - (line 298) + (line 295) * -tree-map: Tree operations. (line 28) * -tree-map-nodes: Tree operations. (line 39) * -tree-mapreduce: Tree operations. (line 84) @@ -4513,20 +4502,21 @@ Index * -unfold: Unfolding. (line 25) * -union: Set operations. (line 8) * -unzip: Other list operations. - (line 146) -* -update-at: List to list. (line 132) + (line 158) +* -update-at: List to list. (line 133) * -when-let: Binding. (line 9) -* -when-let*: Binding. (line 23) +* -when-let*: Binding. (line 21) * -zip: Other list operations. - (line 95) + (line 107) * -zip-fill: Other list operations. - (line 138) + (line 150) * -zip-lists: Other list operations. - (line 119) + (line 131) * -zip-with: Other list operations. - (line 79) + (line 91) * dash-fontify-mode: Fontification of special variables. (line 6) +* dash-register-info-lookup: Info symbol lookup. (line 6) * global-dash-fontify-mode: Fontification of special variables. (line 12) @@ -4535,206 +4525,210 @@ Index Tag Table: Node: Top742 Node: Installation2397 -Node: Using in a package3162 -Node: Fontification of special variables3662 -Node: Functions4425 -Node: Maps5909 -Ref: -map6204 -Ref: -map-when6545 -Ref: -map-first7123 -Ref: -map-last7601 -Ref: -map-indexed8074 -Ref: -annotate8554 -Ref: -splice9044 -Ref: -splice-list9825 -Ref: -mapcat10287 -Ref: -copy10663 -Node: Sublist selection10867 -Ref: -filter11060 -Ref: -remove11512 -Ref: -remove-first11918 -Ref: -remove-last12445 -Ref: -remove-item12966 -Ref: -non-nil13361 -Ref: -slice13520 -Ref: -take14052 -Ref: -take-last14461 -Ref: -drop14894 -Ref: -drop-last15324 -Ref: -take-while15752 -Ref: -drop-while16278 -Ref: -select-by-indices16802 -Ref: -select-columns17316 -Ref: -select-column18022 -Node: List to list18486 -Ref: -keep18678 -Ref: -concat19181 -Ref: -flatten19478 -Ref: -flatten-n20237 -Ref: -replace20624 -Ref: -replace-first21087 -Ref: -replace-last21584 -Ref: -insert-at22074 -Ref: -replace-at22401 -Ref: -update-at22791 -Ref: -remove-at23282 -Ref: -remove-at-indices23770 -Node: Reductions24352 -Ref: -reduce-from24521 -Ref: -reduce-r-from25287 -Ref: -reduce26054 -Ref: -reduce-r26783 -Ref: -reductions-from27654 -Ref: -reductions-r-from28369 -Ref: -reductions29094 -Ref: -reductions-r29719 -Ref: -count30354 -Ref: -sum30578 -Ref: -running-sum30767 -Ref: -product31060 -Ref: -running-product31269 -Ref: -inits31582 -Ref: -tails31830 -Ref: -common-prefix32077 -Ref: -common-suffix32374 -Ref: -min32671 -Ref: -min-by32897 -Ref: -max33420 -Ref: -max-by33645 -Node: Unfolding34173 -Ref: -iterate34414 -Ref: -unfold34864 -Node: Predicates35672 -Ref: -any?35796 -Ref: -all?36116 -Ref: -none?36446 -Ref: -only-some?36748 -Ref: -contains?37233 -Ref: -same-items?37622 -Ref: -is-prefix?38007 -Ref: -is-suffix?38330 -Ref: -is-infix?38653 -Node: Partitioning39007 -Ref: -split-at39195 -Ref: -split-with39480 -Ref: -split-on39883 -Ref: -split-when40559 -Ref: -separate41199 -Ref: -partition41641 -Ref: -partition-all42093 -Ref: -partition-in-steps42521 -Ref: -partition-all-in-steps43018 -Ref: -partition-by43503 -Ref: -partition-by-header43885 -Ref: -partition-after-pred44489 -Ref: -partition-before-pred44833 -Ref: -partition-before-item45184 -Ref: -partition-after-item45495 -Ref: -group-by45801 -Node: Indexing46238 -Ref: -elem-index46440 -Ref: -elem-indices46835 -Ref: -find-index47218 -Ref: -find-last-index47707 -Ref: -find-indices48211 -Ref: -grade-up48619 -Ref: -grade-down49022 -Node: Set operations49432 -Ref: -union49615 -Ref: -difference50057 -Ref: -intersection50474 -Ref: -powerset50911 -Ref: -permutations51124 -Ref: -distinct51424 -Node: Other list operations51802 -Ref: -rotate52027 -Ref: -repeat52397 -Ref: -cons*52678 -Ref: -snoc53065 -Ref: -interpose53478 -Ref: -interleave53776 -Ref: -zip-with54145 -Ref: -zip54862 -Ref: -zip-lists55694 -Ref: -zip-fill56395 -Ref: -unzip56718 -Ref: -cycle57463 -Ref: -pad57865 -Ref: -table58188 -Ref: -table-flat58977 -Ref: -first59985 -Ref: -some60357 -Ref: -last60666 -Ref: -first-item61000 -Ref: -second-item61416 -Ref: -third-item61696 -Ref: -fourth-item61974 -Ref: -fifth-item62240 -Ref: -last-item62502 -Ref: -butlast62794 -Ref: -sort63041 -Ref: -list63530 -Ref: -fix63861 -Node: Tree operations64401 -Ref: -tree-seq64597 -Ref: -tree-map65455 -Ref: -tree-map-nodes65898 -Ref: -tree-reduce66748 -Ref: -tree-reduce-from67630 -Ref: -tree-mapreduce68231 -Ref: -tree-mapreduce-from69091 -Ref: -clone70377 -Node: Threading macros70705 -Ref: ->70850 -Ref: ->>71341 -Ref: -->71846 -Ref: -as->72402 -Ref: -some->72857 -Ref: -some->>73231 -Ref: -some-->73667 -Node: Binding74138 -Ref: -when-let74350 -Ref: -when-let*74835 -Ref: -if-let75358 -Ref: -if-let*75753 -Ref: -let76370 -Ref: -let*82445 -Ref: -lambda83385 -Ref: -setq84181 -Node: Side-effects84997 -Ref: -each85191 -Ref: -each-while85598 -Ref: -each-indexed86056 -Ref: -each-r86574 -Ref: -each-r-while87007 -Ref: -dotimes87382 -Ref: -doto87872 -Node: Destructive operations88353 -Ref: !cons88526 -Ref: !cdr88732 -Node: Function combinators88927 -Ref: -partial89201 -Ref: -rpartial89595 -Ref: -juxt89998 -Ref: -compose90430 -Ref: -applify90983 -Ref: -on91414 -Ref: -flip91940 -Ref: -const92252 -Ref: -cut92591 -Ref: -not93077 -Ref: -orfn93387 -Ref: -andfn93821 -Ref: -iteratefn94316 -Ref: -fixfn95019 -Ref: -prodfn96582 -Node: Development97642 -Node: Contribute97995 -Node: Change log99001 -Node: Contributors106539 -Node: FDL108557 -Node: GPL133877 -Node: Index171626 +Node: Using in a package3159 +Node: Fontification of special variables3504 +Node: Info symbol lookup4294 +Node: Functions4877 +Node: Maps6361 +Ref: -map6658 +Ref: -map-when7031 +Ref: -map-first7606 +Ref: -map-last8081 +Ref: -map-indexed8551 +Ref: -annotate9237 +Ref: -splice9724 +Ref: -splice-list10502 +Ref: -mapcat10961 +Ref: -copy11334 +Node: Sublist selection11522 +Ref: -filter11715 +Ref: -remove12262 +Ref: -remove-first12800 +Ref: -remove-last13642 +Ref: -remove-item14367 +Ref: -non-nil14767 +Ref: -slice15043 +Ref: -take15572 +Ref: -take-last15979 +Ref: -drop16410 +Ref: -drop-last16851 +Ref: -take-while17277 +Ref: -drop-while17892 +Ref: -select-by-indices18508 +Ref: -select-columns19019 +Ref: -select-column19722 +Node: List to list20185 +Ref: -keep20377 +Ref: -concat20941 +Ref: -flatten21235 +Ref: -flatten-n21991 +Ref: -replace22375 +Ref: -replace-first22836 +Ref: -replace-last23331 +Ref: -insert-at23819 +Ref: -replace-at24144 +Ref: -update-at24531 +Ref: -remove-at25019 +Ref: -remove-at-indices25504 +Node: Reductions26083 +Ref: -reduce-from26279 +Ref: -reduce-r-from27003 +Ref: -reduce28266 +Ref: -reduce-r29017 +Ref: -reductions-from30295 +Ref: -reductions-r-from31101 +Ref: -reductions31931 +Ref: -reductions-r32642 +Ref: -count33387 +Ref: -sum33611 +Ref: -running-sum33799 +Ref: -product34120 +Ref: -running-product34328 +Ref: -inits34669 +Ref: -tails34914 +Ref: -common-prefix35158 +Ref: -common-suffix35452 +Ref: -min35746 +Ref: -min-by35972 +Ref: -max36493 +Ref: -max-by36718 +Node: Unfolding37244 +Ref: -iterate37485 +Ref: -unfold37932 +Node: Predicates38737 +Ref: -some38914 +Ref: -every39331 +Ref: -any?40010 +Ref: -all?40341 +Ref: -none?41048 +Ref: -only-some?41350 +Ref: -contains?41835 +Ref: -same-items?42224 +Ref: -is-prefix?42609 +Ref: -is-suffix?42935 +Ref: -is-infix?43261 +Ref: -cons-pair?43615 +Node: Partitioning43940 +Ref: -split-at44128 +Ref: -split-with44792 +Ref: -split-on45192 +Ref: -split-when45863 +Ref: -separate46500 +Ref: -partition46939 +Ref: -partition-all47388 +Ref: -partition-in-steps47813 +Ref: -partition-all-in-steps48307 +Ref: -partition-by48789 +Ref: -partition-by-header49167 +Ref: -partition-after-pred49768 +Ref: -partition-before-pred50215 +Ref: -partition-before-item50600 +Ref: -partition-after-item50907 +Ref: -group-by51209 +Node: Indexing51642 +Ref: -elem-index51844 +Ref: -elem-indices52239 +Ref: -find-index52619 +Ref: -find-last-index53108 +Ref: -find-indices53612 +Ref: -grade-up54017 +Ref: -grade-down54424 +Node: Set operations54838 +Ref: -union55021 +Ref: -difference55459 +Ref: -intersection55871 +Ref: -powerset56303 +Ref: -permutations56513 +Ref: -distinct56809 +Node: Other list operations57183 +Ref: -rotate57408 +Ref: -repeat57761 +Ref: -cons*58040 +Ref: -snoc58456 +Ref: -interpose58866 +Ref: -interleave59160 +Ref: -iota59526 +Ref: -zip-with60009 +Ref: -zip60723 +Ref: -zip-lists61552 +Ref: -zip-fill62250 +Ref: -unzip62572 +Ref: -cycle63314 +Ref: -pad63713 +Ref: -table64032 +Ref: -table-flat64818 +Ref: -first65823 +Ref: -last66309 +Ref: -first-item66643 +Ref: -second-item67042 +Ref: -third-item67306 +Ref: -fourth-item67568 +Ref: -fifth-item67834 +Ref: -last-item68096 +Ref: -butlast68387 +Ref: -sort68632 +Ref: -list69118 +Ref: -fix69687 +Node: Tree operations70176 +Ref: -tree-seq70372 +Ref: -tree-map71227 +Ref: -tree-map-nodes71667 +Ref: -tree-reduce72514 +Ref: -tree-reduce-from73396 +Ref: -tree-mapreduce73996 +Ref: -tree-mapreduce-from74855 +Ref: -clone76140 +Node: Threading macros76467 +Ref: ->76692 +Ref: ->>77180 +Ref: -->77683 +Ref: -as->78239 +Ref: -some->78693 +Ref: -some->>79066 +Ref: -some-->79501 +Ref: -doto80050 +Node: Binding80603 +Ref: -when-let80810 +Ref: -when-let*81265 +Ref: -if-let81788 +Ref: -if-let*82148 +Ref: -let82765 +Ref: -let*88837 +Ref: -lambda89774 +Ref: -setq90580 +Node: Side effects91381 +Ref: -each91575 +Ref: -each-while92096 +Ref: -each-indexed92698 +Ref: -each-r93284 +Ref: -each-r-while93720 +Ref: -dotimes94346 +Node: Destructive operations94899 +Ref: !cons95117 +Ref: !cdr95321 +Node: Function combinators95514 +Ref: -partial95718 +Ref: -rpartial96236 +Ref: -juxt96884 +Ref: -compose97336 +Ref: -applify97943 +Ref: -on98373 +Ref: -flip99145 +Ref: -rotate-args99669 +Ref: -const100298 +Ref: -cut100640 +Ref: -not101120 +Ref: -orfn101646 +Ref: -andfn102408 +Ref: -iteratefn103164 +Ref: -fixfn103866 +Ref: -prodfn105422 +Node: Development106480 +Node: Contribute106769 +Node: Contributors107781 +Node: FDL109874 +Node: GPL135194 +Node: Index172943  End Tag Table diff --git a/elpa/dash-20210105.414/dir b/elpa/dash-20210826.1149/dir similarity index 100% rename from elpa/dash-20210105.414/dir rename to elpa/dash-20210826.1149/dir -- 2.47.3