diff options
author | Sean Whitton <spwhitton@spwhitton.name> | 2016-09-23 08:07:16 -0700 |
---|---|---|
committer | Sean Whitton <spwhitton@spwhitton.name> | 2016-09-23 08:07:16 -0700 |
commit | e44b2fda0c27ae45fa947ca507f1fa829fb21d29 (patch) | |
tree | e1665b2e4cd26f109cb2eb20013013cf8b631457 | |
parent | 4666a18b223dfffded49e2ffd68b9dfad7bc5ca5 (diff) | |
parent | 9b1cb53eea8a9637f7f9db5347ab306dd9bca079 (diff) |
Merge tag '2.16'
Upstream version 2.16
# gpg: Signature made Fri 23 Sep 2016 08:07:09 AM MST
# gpg: using RSA key 0x0F56D0553B6D411B
# gpg: Good signature from "Sean Whitton <spwhitton@spwhitton.name>" [ultimate]
# Primary key fingerprint: 8DC2 487E 51AB DD90 B5C4 753F 0F56 D055 3B6D 411B
-rw-r--r-- | ChangeLog | 142 | ||||
-rw-r--r-- | seq-24.el | 464 | ||||
-rw-r--r-- | seq-25.el | 498 | ||||
-rw-r--r-- | seq-pkg.el | 2 | ||||
-rw-r--r-- | seq.el | 526 | ||||
-rw-r--r-- | tests/seq-tests.el | 30 |
6 files changed, 1140 insertions, 522 deletions
diff --git a/ChangeLog b/ChangeLog new file mode 100644 index 0000000..88f8e8c --- /dev/null +++ b/ChangeLog @@ -0,0 +1,142 @@ +2016-06-12 Nicolas Petton <nicolas@petton.fr> + + Update seq.el to 2.16 + + * packages/seq/seq-24.el: + * packages/seq/seq-25.el: Better implementation of seq-drop for lists. + * packages/seq/seq.el: Bump version number. + +2016-04-22 Stefan Monnier <monnier@iro.umontreal.ca> + + * seq-24.el (seq-concatenate,seq-into,seq--make-bindings): Use _ + + rather than t as catch-all for pcase. + +2016-03-31 Nicolas Petton <nicolas@petton.fr> + + Update seq to version 2.15 + + * packages/seq/seq-25.el: Require cl-lib. + * packages/seq/seq.el: Bump version number. + +2016-03-29 Nicolas Petton <nicolas@petton.fr> + + Update seq.el to version 2.14 + + * packages/seq/seq.el: Bump version number. + * packages/seq/seq-24.el (seq-sort-by): New function. + * packages/seq/seq-25.el (seq-sort-by): New function. + * packages/seq/tests/seq-tests.el: Add a test for seq-sort-by. + +2016-03-25 Nicolas Petton <nicolas@petton.fr> + + * packages/seq/seq-25.el: Better declarations for seq--when-emacs-25-p + +2016-03-25 Nicolas Petton <nicolas@petton.fr> + + Split seq.el into separate files for different versions of Emacs + + All functions in seq-25.el are wrapped in a `seq--when-emacs-25-p' to + make sure that the byte compiler won't emit warnings or errors when the + file is byte compiled in Emacs < 25. + + * packages/seq/seq-24.el: + * packages/seq/seq-25.el: New files. + * packages/seq/seq.el: Load seq-VERSION.el based on the version of + Emacs. + * packages/seq/test/seq.el-test.el: Backport a test from seq.el in Emacs + master. + +2015-11-30 Stefan Monnier <monnier@iro.umontreal.ca> + + * packages/seq: Don't define it as a :core package + + Revert the removal of packages/seq/seq.el since it's different from the + one in lisp/emacs-lisp. + * .gitignore: Remove packages/seq. + * externals-list: Remove "seq" entry. + +2015-11-29 Stefan Monnier <monnier@iro.umontreal.ca> + + * externals-list: Add seq and python as :core packages + + * .gitignore: Add packages/{seq,python}. + * packages/seq: Remove. + +2015-10-20 Nicolas Petton <nicolas@petton.fr> + + Update seq.el to version 1.11 + + * packages/seq/seq.el: + * packages/seq/tests/seq-tests.el: Update. + +2015-09-18 Nicolas Petton <nicolas@petton.fr> + + Update seq.el to version 1.9 + + * packages/seq/seq.el: Update to version 1.9. + * packages/seq/tests/seq-tests.el: Update to version 1.9. + +2015-07-09 Nicolas Petton <nicolas@petton.fr> + + Update seq.el to version 1.8 + + * packages/seq/seq.el: Update to version 1.8. + * packages/seq/tests/seq-tests.el: Update to version 1.8. + +2015-05-15 Nicolas Petton <nicolas@petton.fr> + + Update seq.el to version 1.7 + + * packages/seq/seq.el: Update to version 1.7. + * packages/seq/tests/seq-tests.el: Update to version 1.7. + +2015-04-27 Nicolas Petton <nicolas@petton.fr> + + * packages/seq/seq.el: Update seq.el to version 1.5. + +2015-04-15 Nicolas Petton <nicolas@petton.fr> + + seq.el update + + * packages/seq/seq.el: Update seq.el to version 1.4 + * packages/seq/tests/seq-tests.el: Update seq.el to version 1.4 + +2015-03-25 Nicolas Petton <nicolas@petton.fr> + + Rephrases a comment in seq.el about the order of the arguments + + * packages/seq/seq.el: Better comment about the order of the arguments + +2015-03-09 Nicolas Petton <nicolas@petton.fr> + + Update seq.el to version 1.3 + + * packages/seq/seq.el: update to version 1.3 + * packages/seq/tests/seq-tests.el: update to version 1.3 + +2015-02-11 Nicolas Petton <nicolas@petton.fr> + + Update seq.el to version 1.2 + + * package/seq/seq.el: Update to version 1.2 + * packages/seq/tests/seq-tests.el: Update to version 1.2 + +2015-02-09 Nicolas Petton <nicolas@petton.fr> + + Update seq.el to version 1.1.1 + + * package/seq/seq.el: Update to version 1.1.1 + * packages/seq/tests/seq-tests.el: Update to version 1.1.1 + +2015-02-06 Nicolas Petton <nicolas@petton.fr> + + Update seq.el to version 1.1 + + * packages/seq/seq.el: Update to version 1.1 + * packages/seq/tests/seq-tests.el: Update to version 1.1 + +2015-01-14 Nicolas Petton <nicolas@petton.fr> + + packages/seq: New package + diff --git a/seq-24.el b/seq-24.el new file mode 100644 index 0000000..d0aa618 --- /dev/null +++ b/seq-24.el @@ -0,0 +1,464 @@ +;;; seq-24.el --- seq.el implementation for Emacs 24.x -*- lexical-binding: t -*- + +;; Copyright (C) 2014-2016 Free Software Foundation, Inc. + +;; Author: Nicolas Petton <nicolas@petton.fr> +;; Keywords: sequences + +;; Maintainer: emacs-devel@gnu.org + +;; This file is part of GNU Emacs. + +;; GNU Emacs is free software: you can redistribute it and/or modify +;; it under the terms of the GNU General Public License as published by +;; the Free Software Foundation, either version 3 of the License, or +;; (at your option) any later version. + +;; GNU Emacs is distributed in the hope that it will be useful, +;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +;; GNU General Public License for more details. + +;; You should have received a copy of the GNU General Public License +;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. + +;;; Commentary: + +;; Sequence-manipulation functions that complement basic functions +;; provided by subr.el. +;; +;; All functions are prefixed with "seq-". +;; +;; All provided functions work on lists, strings and vectors. +;; +;; Functions taking a predicate or iterating over a sequence using a +;; function as argument take the function as their first argument and +;; the sequence as their second argument. All other functions take +;; the sequence as their first argument. + +;;; Code: + +(defmacro seq-doseq (spec &rest body) + "Loop over a sequence. +Similar to `dolist' but can be applied to lists, strings, and vectors. + +Evaluate BODY with VAR bound to each element of SEQ, in turn. + +\(fn (VAR SEQ) BODY...)" + (declare (indent 1) (debug ((symbolp form &optional form) body))) + (let ((length (make-symbol "length")) + (seq (make-symbol "seq")) + (index (make-symbol "index"))) + `(let* ((,seq ,(cadr spec)) + (,length (if (listp ,seq) nil (seq-length ,seq))) + (,index (if ,length 0 ,seq))) + (while (if ,length + (< ,index ,length) + (consp ,index)) + (let ((,(car spec) (if ,length + (prog1 (seq-elt ,seq ,index) + (setq ,index (+ ,index 1))) + (pop ,index)))) + ,@body))))) + +;; Implementation of `seq-let' compatible with Emacs<25.1. +(defmacro seq-let (args sequence &rest body) + "Bind the variables in ARGS to the elements of SEQUENCE then evaluate BODY. + +ARGS can also include the `&rest' marker followed by a variable +name to be bound to the rest of SEQUENCE." + (declare (indent 2) (debug t)) + (let ((seq-var (make-symbol "seq"))) + `(let* ((,seq-var ,sequence) + ,@(seq--make-bindings args seq-var)) + ,@body))) + +(defun seq-drop (sequence n) + "Return a subsequence of SEQUENCE without its first N elements. +The result is a sequence of the same type as SEQUENCE. + +If N is a negative integer or zero, SEQUENCE is returned." + (if (<= n 0) + sequence + (if (listp sequence) + (seq--drop-list sequence n) + (let ((length (seq-length sequence))) + (seq-subseq sequence (min n length) length))))) + +(defun seq-take (sequence n) + "Return a subsequence of SEQUENCE with its first N elements. +The result is a sequence of the same type as SEQUENCE. + +If N is a negative integer or zero, an empty sequence is +returned." + (if (listp sequence) + (seq--take-list sequence n) + (seq-subseq sequence 0 (min (max n 0) (seq-length sequence))))) + +(defun seq-drop-while (predicate sequence) + "Return a sequence from the first element for which (PREDICATE element) is nil in SEQUENCE. +The result is a sequence of the same type as SEQUENCE." + (if (listp sequence) + (seq--drop-while-list predicate sequence) + (seq-drop sequence (seq--count-successive predicate sequence)))) + +(defun seq-take-while (predicate sequence) + "Return the successive elements for which (PREDICATE element) is non-nil in SEQUENCE. +The result is a sequence of the same type as SEQUENCE." + (if (listp sequence) + (seq--take-while-list predicate sequence) + (seq-take sequence (seq--count-successive predicate sequence)))) + +(defun seq-filter (predicate sequence) + "Return a list of all the elements for which (PREDICATE element) is non-nil in SEQUENCE." + (let ((exclude (make-symbol "exclude"))) + (delq exclude (seq-map (lambda (elt) + (if (funcall predicate elt) + elt + exclude)) + sequence)))) + +(defun seq-map-indexed (function sequence) + "Return the result of applying FUNCTION to each element of SEQUENCE. +Unlike `seq-map', FUNCTION takes two arguments: the element of +the sequence, and its index within the sequence." + (let ((index 0)) + (seq-map (lambda (elt) + (prog1 + (funcall function elt index) + (setq index (1+ index)))) + sequence))) + +(defun seq-remove (predicate sequence) + "Return a list of all the elements for which (PREDICATE element) is nil in SEQUENCE." + (seq-filter (lambda (elt) (not (funcall predicate elt))) + sequence)) + +(defun seq-reduce (function sequence initial-value) + "Reduce the function FUNCTION across SEQUENCE, starting with INITIAL-VALUE. + +Return the result of calling FUNCTION with INITIAL-VALUE and the +first element of SEQUENCE, then calling FUNCTION with that result and +the second element of SEQUENCE, then with that result and the third +element of SEQUENCE, etc. + +If SEQUENCE is empty, return INITIAL-VALUE and FUNCTION is not called." + (if (seq-empty-p sequence) + initial-value + (let ((acc initial-value)) + (seq-doseq (elt sequence) + (setq acc (funcall function acc elt))) + acc))) + +(defun seq-some (predicate sequence) + "Return the first value for which if (PREDICATE element) is non-nil for in SEQUENCE." + (catch 'seq--break + (seq-doseq (elt sequence) + (let ((result (funcall predicate elt))) + (when result + (throw 'seq--break result)))) + nil)) + +(defun seq-find (predicate sequence &optional default) + "Return the first element for which (PREDICATE element) is non-nil in SEQUENCE. +If no element is found, return DEFAULT. + +Note that `seq-find' has an ambiguity if the found element is +identical to DEFAULT, as it cannot be known if an element was +found or not." + (catch 'seq--break + (seq-doseq (elt sequence) + (when (funcall predicate elt) + (throw 'seq--break elt))) + default)) + +(defun seq-every-p (predicate sequence) + "Return non-nil if (PREDICATE element) is non-nil for all elements of the sequence SEQUENCE." + (catch 'seq--break + (seq-doseq (elt sequence) + (or (funcall predicate elt) + (throw 'seq--break nil))) + t)) + +(defun seq-count (predicate sequence) + "Return the number of elements for which (PREDICATE element) is non-nil in SEQUENCE." + (let ((count 0)) + (seq-doseq (elt sequence) + (when (funcall predicate elt) + (setq count (+ 1 count)))) + count)) + +(defun seq-empty-p (sequence) + "Return non-nil if the sequence SEQUENCE is empty, nil otherwise." + (if (listp sequence) + (null sequence) + (= 0 (seq-length sequence)))) + +(defun seq-sort (predicate sequence) + "Return a sorted sequence comparing using PREDICATE the elements of SEQUENCE. +The result is a sequence of the same type as SEQUENCE." + (if (listp sequence) + (sort (seq-copy sequence) predicate) + (let ((result (seq-sort predicate (append sequence nil)))) + (seq-into result (type-of sequence))))) + +(defun seq-sort-by (function pred sequence) + "Sort SEQUENCE using PRED as a comparison function. +Elements of SEQUENCE are transformed by FUNCTION before being +sorted. FUNCTION must be a function of one argument." + (seq-sort (lambda (a b) + (funcall pred + (funcall function a) + (funcall function b))) + sequence)) + +(defun seq-contains (sequence elt &optional testfn) + "Return the first element in SEQUENCE that equals to ELT. +Equality is defined by TESTFN if non-nil or by `equal' if nil." + (seq-some (lambda (e) + (funcall (or testfn #'equal) elt e)) + sequence)) + +(defun seq-position (sequence elt &optional testfn) + "Return the index of the first element in SEQUENCE that is equal to ELT. +Equality is defined by TESTFN if non-nil or by `equal' if nil." + (let ((index 0)) + (catch 'seq--break + (seq-doseq (e sequence) + (when (funcall (or testfn #'equal) e elt) + (throw 'seq--break index)) + (setq index (1+ index))) + nil))) + +(defun seq-uniq (sequence &optional testfn) + "Return a list of the elements of SEQUENCE with duplicates removed. +TESTFN is used to compare elements, or `equal' if TESTFN is nil." + (let ((result '())) + (seq-doseq (elt sequence) + (unless (seq-contains result elt testfn) + (setq result (cons elt result)))) + (nreverse result))) + +(defun seq-subseq (sequence start &optional end) + "Return the subsequence of SEQUENCE from START to END. +If END is omitted, it defaults to the length of the sequence. +If START or END is negative, it counts from the end." + (cond ((or (stringp sequence) (vectorp sequence)) (substring sequence start end)) + ((listp sequence) + (let (len (errtext (format "Bad bounding indices: %s, %s" start end))) + (and end (< end 0) (setq end (+ end (setq len (seq-length sequence))))) + (if (< start 0) (setq start (+ start (or len (setq len (seq-length sequence)))))) + (when (> start 0) + (setq sequence (nthcdr (1- start) sequence)) + (or sequence (error "%s" errtext)) + (setq sequence (cdr sequence))) + (if end + (let ((res nil)) + (while (and (>= (setq end (1- end)) start) sequence) + (push (pop sequence) res)) + (or (= (1+ end) start) (error "%s" errtext)) + (nreverse res)) + (seq-copy sequence)))) + (t (error "Unsupported sequence: %s" sequence)))) + +(defun seq-concatenate (type &rest seqs) + "Concatenate, into a sequence of type TYPE, the sequences SEQS. +TYPE must be one of following symbols: vector, string or list. + +\n(fn TYPE SEQUENCE...)" + (pcase type + (`vector (apply #'vconcat seqs)) + (`string (apply #'concat seqs)) + (`list (apply #'append (append seqs '(nil)))) + (_ (error "Not a sequence type name: %S" type)))) + +(defun seq-mapcat (function sequence &optional type) + "Concatenate the result of applying FUNCTION to each element of SEQUENCE. +The result is a sequence of type TYPE, or a list if TYPE is nil." + (apply #'seq-concatenate (or type 'list) + (seq-map function sequence))) + +(defun seq-mapn (function sequence &rest seqs) + "Like `seq-map' but FUNCTION is mapped over all SEQS. +The arity of FUNCTION must match the number of SEQS, and the +mapping stops on the shortest sequence. +Return a list of the results. + +\(fn FUNCTION SEQS...)" + (let ((result nil) + (seqs (seq-map (lambda (s) (seq-into s 'list)) + (cons sequence seqs)))) + (while (not (memq nil seqs)) + (push (apply function (seq-map #'car seqs)) result) + (setq seqs (seq-map #'cdr seqs))) + (nreverse result))) + +(defun seq-partition (sequence n) + "Return a list of the elements of SEQUENCE grouped into sub-sequences of length N. +The last sequence may contain less than N elements. If N is a +negative integer or 0, nil is returned." + (unless (< n 1) + (let ((result '())) + (while (not (seq-empty-p sequence)) + (push (seq-take sequence n) result) + (setq sequence (seq-drop sequence n))) + (nreverse result)))) + +(defun seq-intersection (seq1 seq2 &optional testfn) + "Return a list of the elements that appear in both SEQ1 and SEQ2. +Equality is defined by TESTFN if non-nil or by `equal' if nil." + (seq-reduce (lambda (acc elt) + (if (seq-contains seq2 elt testfn) + (cons elt acc) + acc)) + (seq-reverse seq1) + '())) + +(defun seq-difference (seq1 seq2 &optional testfn) + "Return a list of the elements that appear in SEQ1 but not in SEQ2. +Equality is defined by TESTFN if non-nil or by `equal' if nil." + (seq-reduce (lambda (acc elt) + (if (not (seq-contains seq2 elt testfn)) + (cons elt acc) + acc)) + (seq-reverse seq1) + '())) + +(defun seq-group-by (function sequence) + "Apply FUNCTION to each element of SEQUENCE. +Separate the elements of SEQUENCE into an alist using the results as +keys. Keys are compared using `equal'." + (seq-reduce + (lambda (acc elt) + (let* ((key (funcall function elt)) + (cell (assoc key acc))) + (if cell + (setcdr cell (push elt (cdr cell))) + (push (list key elt) acc)) + acc)) + (seq-reverse sequence) + nil)) + +(defalias 'seq-reverse + (if (ignore-errors (reverse [1 2])) + #'reverse + (lambda (sequence) + "Return the reversed copy of list, vector, or string SEQUENCE. +See also the function `nreverse', which is used more often." + (let ((result '())) + (seq-map (lambda (elt) (push elt result)) + sequence) + (if (listp sequence) + result + (seq-into result (type-of sequence))))))) + +(defun seq-into (sequence type) + "Convert the sequence SEQUENCE into a sequence of type TYPE. +TYPE can be one of the following symbols: vector, string or list." + (pcase type + (`vector (vconcat sequence)) + (`string (concat sequence)) + (`list (append sequence nil)) + (_ (error "Not a sequence type name: %S" type)))) + +(defun seq-min (sequence) + "Return the smallest element of SEQUENCE. +SEQUENCE must be a sequence of numbers or markers." + (apply #'min (seq-into sequence 'list))) + +(defun seq-max (sequence) + "Return the largest element of SEQUENCE. +SEQUENCE must be a sequence of numbers or markers." + (apply #'max (seq-into sequence 'list))) + +(defun seq--drop-list (list n) + "Return a list from LIST without its first N elements. +This is an optimization for lists in `seq-drop'." + (nthcdr n list)) + +(defun seq--take-list (list n) + "Return a list from LIST made of its first N elements. +This is an optimization for lists in `seq-take'." + (let ((result '())) + (while (and list (> n 0)) + (setq n (1- n)) + (push (pop list) result)) + (nreverse result))) + +(defun seq--drop-while-list (predicate list) + "Return a list from the first element for which (PREDICATE element) is nil in LIST. +This is an optimization for lists in `seq-drop-while'." + (while (and list (funcall predicate (car list))) + (setq list (cdr list))) + list) + +(defun seq--take-while-list (predicate list) + "Return the successive elements for which (PREDICATE element) is non-nil in LIST. +This is an optimization for lists in `seq-take-while'." + (let ((result '())) + (while (and list (funcall predicate (car list))) + (push (pop list) result)) + (nreverse result))) + +(defun seq--count-successive (predicate sequence) + "Return the number of successive elements for which (PREDICATE element) is non-nil in SEQUENCE." + (let ((n 0) + (len (seq-length sequence))) + (while (and (< n len) + (funcall predicate (seq-elt sequence n))) + (setq n (+ 1 n))) + n)) + +;; Helper function for the Backward-compatible version of `seq-let' +;; for Emacs<25.1. +(defun seq--make-bindings (args sequence &optional bindings) + "Return a list of bindings of the variables in ARGS to the elements of a sequence. +if BINDINGS is non-nil, append new bindings to it, and return +BINDINGS." + (let ((index 0) + (rest-marker nil)) + (seq-doseq (name args) + (unless rest-marker + (pcase name + ((pred seq-p) + (setq bindings (seq--make-bindings (seq--elt-safe args index) + `(seq--elt-safe ,sequence ,index) + bindings))) + (`&rest + (progn (push `(,(seq--elt-safe args (1+ index)) + (seq-drop ,sequence ,index)) + bindings) + (setq rest-marker t))) + (_ + (push `(,name (seq--elt-safe ,sequence ,index)) bindings)))) + (setq index (1+ index))) + bindings)) + +(defun seq--elt-safe (sequence n) + "Return element of SEQUENCE at the index N. +If no element is found, return nil." + (when (or (listp sequence) + (and (sequencep sequence) + (> (seq-length sequence) n))) + (seq-elt sequence n))) + +(defun seq--activate-font-lock-keywords () + "Activate font-lock keywords for some symbols defined in seq." + (font-lock-add-keywords 'emacs-lisp-mode + '("\\<seq-doseq\\>" "\\<seq-let\\>"))) + +(defalias 'seq-copy #'copy-sequence) +(defalias 'seq-elt #'elt) +(defalias 'seq-length #'length) +(defalias 'seq-do #'mapc) +(defalias 'seq-each #'seq-do) +(defalias 'seq-map #'mapcar) +(defalias 'seq-p #'sequencep) + +(unless (fboundp 'elisp--font-lock-flush-elisp-buffers) + ;; In Emacs≥25, (via elisp--font-lock-flush-elisp-buffers and a few others) + ;; we automatically highlight macros. + (add-hook 'emacs-lisp-mode-hook #'seq--activate-font-lock-keywords)) + +(provide 'seq-24) +;;; seq-24.el ends here diff --git a/seq-25.el b/seq-25.el new file mode 100644 index 0000000..b2f5c98 --- /dev/null +++ b/seq-25.el @@ -0,0 +1,498 @@ +;;; seq-25.el --- seq.el implementation for Emacs 25.x -*- lexical-binding: t -*- + +;; Copyright (C) 2014-2016 Free Software Foundation, Inc. + +;; Author: Nicolas Petton <nicolas@petton.fr> +;; Keywords: sequences + +;; Maintainer: emacs-devel@gnu.org + +;; This file is part of GNU Emacs. + +;; GNU Emacs is free software: you can redistribute it and/or modify +;; it under the terms of the GNU General Public License as published by +;; the Free Software Foundation, either version 3 of the License, or +;; (at your option) any later version. + +;; GNU Emacs is distributed in the hope that it will be useful, +;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +;; GNU General Public License for more details. + +;; You should have received a copy of the GNU General Public License +;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. + +;;; Commentary: + +;; Sequence-manipulation functions that complement basic functions +;; provided by subr.el. +;; +;; All functions are prefixed with "seq-". +;; +;; All provided functions work on lists, strings and vectors. +;; +;; Functions taking a predicate or iterating over a sequence using a +;; function as argument take the function as their first argument and +;; the sequence as their second argument. All other functions take +;; the sequence as their first argument. +;; +;; seq.el can be extended to support new type of sequences. Here are +;; the generic functions that must be implemented by new seq types: +;; - `seq-elt' +;; - `seq-length' +;; - `seq-do' +;; - `seqp' +;; - `seq-subseq' +;; - `seq-into-sequence' +;; - `seq-copy' +;; - `seq-into' + +;;; Code: + +;; When loading seq.el in Emacs 24.x, this file gets byte-compiled, even if +;; never used. This takes care of byte-compilation warnings is emitted, by +;; emitting nil in the macro expansion in Emacs 24.x. +(defmacro seq--when-emacs-25-p (&rest body) + "Execute BODY if in Emacs>=25.x." + (declare (indent (lambda (&rest x) 0)) (debug t)) + (when (version<= "25" emacs-version) + `(progn ,@body))) + +(seq--when-emacs-25-p + +(require 'cl-generic) +(require 'cl-lib) ;; for cl-subseq + +(defmacro seq-doseq (spec &rest body) + "Loop over a sequence. +Evaluate BODY with VAR bound to each element of SEQUENCE, in turn. + +Similar to `dolist' but can be applied to lists, strings, and vectors. + +\(fn (VAR SEQUENCE) BODY...)" + (declare (indent 1) (debug ((symbolp form &optional form) body))) + `(seq-do (lambda (,(car spec)) + ,@body) + ,(cadr spec))) + +(pcase-defmacro seq (&rest patterns) + "Build a `pcase' pattern that matches elements of SEQUENCE. + +The `pcase' pattern will match each element of PATTERNS against the +corresponding element of SEQUENCE. + +Extra elements of the sequence are ignored if fewer PATTERNS are +given, and the match does not fail." + `(and (pred seqp) + ,@(seq--make-pcase-bindings patterns))) + +(defmacro seq-let (args sequence &rest body) + "Bind the variables in ARGS to the elements of SEQUENCE, then evaluate BODY. + +ARGS can also include the `&rest' marker followed by a variable +name to be bound to the rest of SEQUENCE." + (declare (indent 2) (debug t)) + `(pcase-let ((,(seq--make-pcase-patterns args) ,sequence)) + ,@body)) + + +;;; Basic seq functions that have to be implemented by new sequence types +(cl-defgeneric seq-elt (sequence n) + "Return Nth element of SEQUENCE." + (elt sequence n)) + +;; Default gv setters for `seq-elt'. +;; It can be a good idea for new sequence implementations to provide a +;; "gv-setter" for `seq-elt'. +(cl-defmethod (setf seq-elt) (store (sequence array) n) + (aset sequence n store)) + +(cl-defmethod (setf seq-elt) (store (sequence cons) n) + (setcar (nthcdr n sequence) store)) + +(cl-defgeneric seq-length (sequence) + "Return the number of elements of SEQUENCE." + (length sequence)) + +(cl-defgeneric seq-do (function sequence) + "Apply FUNCTION to each element of SEQUENCE, presumably for side effects. +Return SEQUENCE." + (mapc function sequence)) + +(defalias 'seq-each #'seq-do) + +(cl-defgeneric seqp (sequence) + "Return non-nil if SEQUENCE is a sequence, nil otherwise." + (sequencep sequence)) + +(cl-defgeneric seq-copy (sequence) + "Return a shallow copy of SEQUENCE." + (copy-sequence sequence)) + +(cl-defgeneric seq-subseq (sequence start &optional end) + "Return the sequence of elements of SEQUENCE from START to END. +END is inclusive. + +If END is omitted, it defaults to the length of the sequence. If +START or END is negative, it counts from the end. Signal an +error if START or END are outside of the sequence (i.e too large +if positive or too small if negative)." + (cl-subseq sequence start end)) + + +(cl-defgeneric seq-map (function sequence) + "Return the result of applying FUNCTION to each element of SEQUENCE." + (let (result) + (seq-do (lambda (elt) + (push (funcall function elt) result)) + sequence) + (nreverse result))) + +(defun seq-map-indexed (function sequence) + "Return the result of applying FUNCTION to each element of SEQUENCE. +Unlike `seq-map', FUNCTION takes two arguments: the element of +the sequence, and its index within the sequence." + (let ((index 0)) + (seq-map (lambda (elt) + (prog1 + (funcall function elt index) + (setq index (1+ index)))) + sequence))) + +;; faster implementation for sequences (sequencep) +(cl-defmethod seq-map (function (sequence sequence)) + (mapcar function sequence)) + +(cl-defgeneric seq-mapn (function sequence &rest sequences) + "Like `seq-map' but FUNCTION is mapped over all SEQUENCES. +The arity of FUNCTION must match the number of SEQUENCES, and the +mapping stops on the shortest sequence. +Return a list of the results. + +\(fn FUNCTION SEQUENCES...)" + (let ((result nil) + (sequences (seq-map (lambda (s) (seq-into s 'list)) + (cons sequence sequences)))) + (while (not (memq nil sequences)) + (push (apply function (seq-map #'car sequences)) result) + (setq sequences (seq-map #'cdr sequences))) + (nreverse result))) + +(cl-defgeneric seq-drop (sequence n) + "Remove the first N elements of SEQUENCE and return the result. +The result is a sequence of the same type as SEQUENCE. + +If N is a negative integer or zero, SEQUENCE is returned." + (if (<= n 0) + sequence + (let ((length (seq-length sequence))) + (seq-subseq sequence (min n length) length)))) + +(cl-defgeneric seq-take (sequence n) + "Take the first N elements of SEQUENCE and return the result. +The result is a sequence of the same type as SEQUENCE. + +If N is a negative integer or zero, an empty sequence is +returned." + (seq-subseq sequence 0 (min (max n 0) (seq-length sequence)))) + +(cl-defgeneric seq-drop-while (pred sequence) + "Remove the successive elements of SEQUENCE for which PRED returns non-nil. +PRED is a function of one argument. The result is a sequence of +the same type as SEQUENCE." + (seq-drop sequence (seq--count-successive pred sequence))) + +(cl-defgeneric seq-take-while (pred sequence) + "Take the successive elements of SEQUENCE for which PRED returns non-nil. +PRED is a function of one argument. The result is a sequence of +the same type as SEQUENCE." + (seq-take sequence (seq--count-successive pred sequence))) + +(cl-defgeneric seq-empty-p (sequence) + "Return non-nil if the SEQUENCE is empty, nil otherwise." + (= 0 (seq-length sequence))) + +(cl-defgeneric seq-sort (pred sequence) + "Sort SEQUENCE using PRED as comparison function. +The result is a sequence of the same type as SEQUENCE." + (let ((result (seq-sort pred (append sequence nil)))) + (seq-into result (type-of sequence)))) + +(defun seq-sort-by (function pred sequence) + "Sort SEQUENCE using PRED as a comparison function. +Elements of SEQUENCE are transformed by FUNCTION before being +sorted. FUNCTION must be a function of one argument." + (seq-sort (lambda (a b) + (funcall pred + (funcall function a) + (funcall function b))) + sequence)) + +(cl-defmethod seq-sort (pred (list list)) + (sort (seq-copy list) pred)) + +(cl-defgeneric seq-reverse (sequence) + "Return a sequence with elements of SEQUENCE in reverse order." + (let ((result '())) + (seq-map (lambda (elt) + (push elt result)) + sequence) + (seq-into result (type-of sequence)))) + +;; faster implementation for sequences (sequencep) +(cl-defmethod seq-reverse ((sequence sequence)) + (reverse sequence)) + +(cl-defgeneric seq-concatenate (type &rest sequences) + "Concatenate SEQUENCES into a single sequence of type TYPE. +TYPE must be one of following symbols: vector, string or list. + +\n(fn TYPE SEQUENCE...)" + (apply #'cl-concatenate type (seq-map #'seq-into-sequence sequences))) + +(cl-defgeneric seq-into-sequence (sequence) + "Convert SEQUENCE into a sequence. + +The default implementation is to signal an error if SEQUENCE is not a +sequence, specific functions should be implemented for new types +of sequence." + (unless (sequencep sequence) + (error "Cannot convert %S into a sequence" sequence)) + sequence) + +(cl-defgeneric seq-into (sequence type) + "Concatenate the elements of SEQUENCE into a sequence of type TYPE. +TYPE can be one of the following symbols: vector, string or +list." + (pcase type + (`vector (vconcat sequence)) + (`string (concat sequence)) + (`list (append sequence nil)) + (_ (error "Not a sequence type name: %S" type)))) + +(cl-defgeneric seq-filter (pred sequence) + "Return a list of all the elements for which (PRED element) is non-nil in SEQUENCE." + (let ((exclude (make-symbol "exclude"))) + (delq exclude (seq-map (lambda (elt) + (if (funcall pred elt) + elt + exclude)) + sequence)))) + +(cl-defgeneric seq-remove (pred sequence) + "Return a list of all the elements for which (PRED element) is nil in SEQUENCE." + (seq-filter (lambda (elt) (not (funcall pred elt))) + sequence)) + +(cl-defgeneric seq-reduce (function sequence initial-value) + "Reduce the function FUNCTION across SEQUENCE, starting with INITIAL-VALUE. + +Return the result of calling FUNCTION with INITIAL-VALUE and the +first element of SEQUENCE, then calling FUNCTION with that result and +the second element of SEQUENCE, then with that result and the third +element of SEQUENCE, etc. + +If SEQUENCE is empty, return INITIAL-VALUE and FUNCTION is not called." + (if (seq-empty-p sequence) + initial-value + (let ((acc initial-value)) + (seq-doseq (elt sequence) + (setq acc (funcall function acc elt))) + acc))) + +(cl-defgeneric seq-every-p (pred sequence) + "Return non-nil if (PRED element) is non-nil for all elements of SEQUENCE." + (catch 'seq--break + (seq-doseq (elt sequence) + (or (funcall pred elt) + (throw 'seq--break nil))) + t)) + +(cl-defgeneric seq-some (pred sequence) + "Return the first value for which if (PRED element) is non-nil for in SEQUENCE." + (catch 'seq--break + (seq-doseq (elt sequence) + (let ((result (funcall pred elt))) + (when result + (throw 'seq--break result)))) + nil)) + +(cl-defgeneric seq-find (pred sequence &optional default) + "Return the first element for which (PRED element) is non-nil in SEQUENCE. +If no element is found, return DEFAULT. + +Note that `seq-find' has an ambiguity if the found element is +identical to DEFAULT, as it cannot be known if an element was +found or not." + (catch 'seq--break + (seq-doseq (elt sequence) + (when (funcall pred elt) + (throw 'seq--break elt))) + default)) + +(cl-defgeneric seq-count (pred sequence) + "Return the number of elements for which (PRED element) is non-nil in SEQUENCE." + (let ((count 0)) + (seq-doseq (elt sequence) + (when (funcall pred elt) + (setq count (+ 1 count)))) + count)) + +(cl-defgeneric seq-contains (sequence elt &optional testfn) + "Return the first element in SEQUENCE that is equal to ELT. +Equality is defined by TESTFN if non-nil or by `equal' if nil." + (seq-some (lambda (e) + (funcall (or testfn #'equal) elt e)) + sequence)) + +(cl-defgeneric seq-position (sequence elt &optional testfn) + "Return the index of the first element in SEQUENCE that is equal to ELT. +Equality is defined by TESTFN if non-nil or by `equal' if nil." + (let ((index 0)) + (catch 'seq--break + (seq-doseq (e sequence) + (when (funcall (or testfn #'equal) e elt) + (throw 'seq--break index)) + (setq index (1+ index))) + nil))) + +(cl-defgeneric seq-uniq (sequence &optional testfn) + "Return a list of the elements of SEQUENCE with duplicates removed. +TESTFN is used to compare elements, or `equal' if TESTFN is nil." + (let ((result '())) + (seq-doseq (elt sequence) + (unless (seq-contains result elt testfn) + (setq result (cons elt result)))) + (nreverse result))) + +(cl-defgeneric seq-mapcat (function sequence &optional type) + "Concatenate the result of applying FUNCTION to each element of SEQUENCE. +The result is a sequence of type TYPE, or a list if TYPE is nil." + (apply #'seq-concatenate (or type 'list) + (seq-map function sequence))) + +(cl-defgeneric seq-partition (sequence n) + "Return a list of the elements of SEQUENCE grouped into sub-sequences of length N. +The last sequence may contain less than N elements. If N is a +negative integer or 0, nil is returned." + (unless (< n 1) + (let ((result '())) + (while (not (seq-empty-p sequence)) + (push (seq-take sequence n) result) + (setq sequence (seq-drop sequence n))) + (nreverse result)))) + +(cl-defgeneric seq-intersection (sequence1 sequence2 &optional testfn) + "Return a list of the elements that appear in both SEQUENCE1 and SEQUENCE2. +Equality is defined by TESTFN if non-nil or by `equal' if nil." + (seq-reduce (lambda (acc elt) + (if (seq-contains sequence2 elt testfn) + (cons elt acc) + acc)) + (seq-reverse sequence1) + '())) + +(cl-defgeneric seq-difference (sequence1 sequence2 &optional testfn) + "Return a list of the elements that appear in SEQUENCE1 but not in SEQUENCE2. +Equality is defined by TESTFN if non-nil or by `equal' if nil." + (seq-reduce (lambda (acc elt) + (if (not (seq-contains sequence2 elt testfn)) + (cons elt acc) + acc)) + (seq-reverse sequence1) + '())) + +(cl-defgeneric seq-group-by (function sequence) + "Apply FUNCTION to each element of SEQUENCE. +Separate the elements of SEQUENCE into an alist using the results as +keys. Keys are compared using `equal'." + (seq-reduce + (lambda (acc elt) + (let* ((key (funcall function elt)) + (cell (assoc key acc))) + (if cell + (setcdr cell (push elt (cdr cell))) + (push (list key elt) acc)) + acc)) + (seq-reverse sequence) + nil)) + +(cl-defgeneric seq-min (sequence) + "Return the smallest element of SEQUENCE. +SEQUENCE must be a sequence of numbers or markers." + (apply #'min (seq-into sequence 'list))) + +(cl-defgeneric seq-max (sequence) + "Return the largest element of SEQUENCE. +SEQUENCE must be a sequence of numbers or markers." + (apply #'max (seq-into sequence 'list))) + +(defun seq--count-successive (pred sequence) + "Return the number of successive elements for which (PRED element) is non-nil in SEQUENCE." + (let ((n 0) + (len (seq-length sequence))) + (while (and (< n len) + (funcall pred (seq-elt sequence n))) + (setq n (+ 1 n))) + n)) + +;;; Optimized implementations for lists + +(cl-defmethod seq-drop ((list list) n) + "Optimized implementation of `seq-drop' for lists." + (nthcdr n list)) + +(cl-defmethod seq-take ((list list) n) + "Optimized implementation of `seq-take' for lists." + (let ((result '())) + (while (and list (> n 0)) + (setq n (1- n)) + (push (pop list) result)) + (nreverse result))) + +(cl-defmethod seq-drop-while (pred (list list)) + "Optimized implementation of `seq-drop-while' for lists." + (while (and list (funcall pred (car list))) + (setq list (cdr list))) + list) + +(cl-defmethod seq-empty-p ((list list)) + "Optimized implementation of `seq-empty-p' for lists." + (null list)) + + +(defun seq--make-pcase-bindings (args) + "Return a list of bindings of the variables in ARGS to the elements of a sequence." + (let ((bindings '()) + (index 0) + (rest-marker nil)) + (seq-doseq (name args) + (unless rest-marker + (pcase name + (`&rest + (progn (push `(app (pcase--flip seq-drop ,index) + ,(seq--elt-safe args (1+ index))) + bindings) + (setq rest-marker t))) + (_ + (push `(app (pcase--flip seq--elt-safe ,index) ,name) bindings)))) + (setq index (1+ index))) + bindings)) + +(defun seq--make-pcase-patterns (args) + "Return a list of `(seq ...)' pcase patterns from the argument list ARGS." + (cons 'seq + (seq-map (lambda (elt) + (if (seqp elt) + (seq--make-pcase-patterns elt) + elt)) + args))) + +;; TODO: make public? +(defun seq--elt-safe (sequence n) + "Return element of SEQUENCE at the index N. +If no element is found, return nil." + (ignore-errors (seq-elt sequence n)))) + +(provide 'seq-25) +;;; seq-25.el ends here diff --git a/seq-pkg.el b/seq-pkg.el new file mode 100644 index 0000000..0a19486 --- /dev/null +++ b/seq-pkg.el @@ -0,0 +1,2 @@ +;; Generated package description from seq.el +(define-package "seq" "2.16" "Sequence manipulation functions" 'nil :url "http://elpa.gnu.org/packages/seq.html" :keywords '("sequences")) @@ -1,10 +1,10 @@ ;;; seq.el --- Sequence manipulation functions -*- lexical-binding: t -*- -;; Copyright (C) 2014-2015 Free Software Foundation, Inc. +;; Copyright (C) 2014-2016 Free Software Foundation, Inc. ;; Author: Nicolas Petton <nicolas@petton.fr> ;; Keywords: sequences -;; Version: 1.11 +;; Version: 2.16 ;; Package: seq ;; Maintainer: emacs-devel@gnu.org @@ -37,528 +37,12 @@ ;; function as argument take the function as their first argument and ;; the sequence as their second argument. All other functions take ;; the sequence as their first argument. -;; -;; All functions are tested in test/automated/seq-tests.el ;;; Code: -(defmacro seq-doseq (spec &rest body) - "Loop over a sequence. -Similar to `dolist' but can be applied to lists, strings, and vectors. - -Evaluate BODY with VAR bound to each element of SEQ, in turn. - -\(fn (VAR SEQ) BODY...)" - (declare (indent 1) (debug ((symbolp form &optional form) body))) - (let ((length (make-symbol "length")) - (seq (make-symbol "seq")) - (index (make-symbol "index"))) - `(let* ((,seq ,(cadr spec)) - (,length (if (listp ,seq) nil (seq-length ,seq))) - (,index (if ,length 0 ,seq))) - (while (if ,length - (< ,index ,length) - (consp ,index)) - (let ((,(car spec) (if ,length - (prog1 (seq-elt ,seq ,index) - (setq ,index (+ ,index 1))) - (pop ,index)))) - ,@body))))) - -(if (fboundp 'pcase-defmacro) - ;; Implementation of `seq-let' based on a `pcase' - ;; pattern. Requires Emacs>=25.1. - (progn - (pcase-defmacro seq (&rest args) - "pcase pattern matching sequence elements. -Matches if the object is a sequence (list, string or vector), and -binds each element of ARGS to the corresponding element of the -sequence." - `(and (pred seq-p) - ,@(seq--make-pcase-bindings args))) - - (defmacro seq-let (args seq &rest body) - "Bind the variables in ARGS to the elements of SEQ then evaluate BODY. - -ARGS can also include the `&rest' marker followed by a variable -name to be bound to the rest of SEQ." - (declare (indent 2) (debug t)) - `(pcase-let ((,(seq--make-pcase-patterns args) ,seq)) - ,@body))) - - ;; Implementation of `seq-let' compatible with Emacs<25.1. - (defmacro seq-let (args seq &rest body) - "Bind the variables in ARGS to the elements of SEQ then evaluate BODY. - -ARGS can also include the `&rest' marker followed by a variable -name to be bound to the rest of SEQ." - (declare (indent 2) (debug t)) - (let ((seq-var (make-symbol "seq"))) - `(let* ((,seq-var ,seq) - ,@(seq--make-bindings args seq-var)) - ,@body)))) - -(defun seq-drop (seq n) - "Return a subsequence of SEQ without its first N elements. -The result is a sequence of the same type as SEQ. - -If N is a negative integer or zero, SEQ is returned." - (if (<= n 0) - seq - (if (listp seq) - (seq--drop-list seq n) - (let ((length (seq-length seq))) - (seq-subseq seq (min n length) length))))) - -(defun seq-take (seq n) - "Return a subsequence of SEQ with its first N elements. -The result is a sequence of the same type as SEQ. - -If N is a negative integer or zero, an empty sequence is -returned." - (if (listp seq) - (seq--take-list seq n) - (seq-subseq seq 0 (min (max n 0) (seq-length seq))))) - -(defun seq-drop-while (pred seq) - "Return a sequence from the first element for which (PRED element) is nil in SEQ. -The result is a sequence of the same type as SEQ." - (if (listp seq) - (seq--drop-while-list pred seq) - (seq-drop seq (seq--count-successive pred seq)))) - -(defun seq-take-while (pred seq) - "Return the successive elements for which (PRED element) is non-nil in SEQ. -The result is a sequence of the same type as SEQ." - (if (listp seq) - (seq--take-while-list pred seq) - (seq-take seq (seq--count-successive pred seq)))) - -(defun seq-filter (pred seq) - "Return a list of all the elements for which (PRED element) is non-nil in SEQ." - (let ((exclude (make-symbol "exclude"))) - (delq exclude (seq-map (lambda (elt) - (if (funcall pred elt) - elt - exclude)) - seq)))) - -(defun seq-remove (pred seq) - "Return a list of all the elements for which (PRED element) is nil in SEQ." - (seq-filter (lambda (elt) (not (funcall pred elt))) - seq)) - -(defun seq-reduce (function seq initial-value) - "Reduce the function FUNCTION across SEQ, starting with INITIAL-VALUE. - -Return the result of calling FUNCTION with INITIAL-VALUE and the -first element of SEQ, then calling FUNCTION with that result and -the second element of SEQ, then with that result and the third -element of SEQ, etc. - -If SEQ is empty, return INITIAL-VALUE and FUNCTION is not called." - (if (seq-empty-p seq) - initial-value - (let ((acc initial-value)) - (seq-doseq (elt seq) - (setq acc (funcall function acc elt))) - acc))) - -(defun seq-some (pred seq) - "Return the first value for which if (PRED element) is non-nil for in SEQ." - (catch 'seq--break - (seq-doseq (elt seq) - (let ((result (funcall pred elt))) - (when result - (throw 'seq--break result)))) - nil)) - -(defun seq-find (pred seq &optional default) - "Return the first element for which (PRED element) is non-nil in SEQ. -If no element is found, return DEFAULT. - -Note that `seq-find' has an ambiguity if the found element is -identical to DEFAULT, as it cannot be known if an element was -found or not." - (catch 'seq--break - (seq-doseq (elt seq) - (when (funcall pred elt) - (throw 'seq--break elt))) - default)) - -(defun seq-every-p (pred seq) - "Return non-nil if (PRED element) is non-nil for all elements of the sequence SEQ." - (catch 'seq--break - (seq-doseq (elt seq) - (or (funcall pred elt) - (throw 'seq--break nil))) - t)) - -(defun seq-count (pred seq) - "Return the number of elements for which (PRED element) is non-nil in SEQ." - (let ((count 0)) - (seq-doseq (elt seq) - (when (funcall pred elt) - (setq count (+ 1 count)))) - count)) - -(defun seq-empty-p (seq) - "Return non-nil if the sequence SEQ is empty, nil otherwise." - (if (listp seq) - (null seq) - (= 0 (seq-length seq)))) - -(defun seq-sort (pred seq) - "Return a sorted sequence comparing using PRED the elements of SEQ. -The result is a sequence of the same type as SEQ." - (if (listp seq) - (sort (seq-copy seq) pred) - (let ((result (seq-sort pred (append seq nil)))) - (seq-into result (type-of seq))))) - -(defun seq-contains (seq elt &optional testfn) - "Return the first element in SEQ that equals to ELT. -Equality is defined by TESTFN if non-nil or by `equal' if nil." - (seq-some (lambda (e) - (funcall (or testfn #'equal) elt e)) - seq)) - -(defun seq-position (seq elt &optional testfn) - "Return the index of the first element in SEQ that is equal to ELT. -Equality is defined by TESTFN if non-nil or by `equal' if nil." - (let ((index 0)) - (catch 'seq--break - (seq-doseq (e seq) - (when (funcall (or testfn #'equal) e elt) - (throw 'seq--break index)) - (setq index (1+ index))) - nil))) - -(defun seq-uniq (seq &optional testfn) - "Return a list of the elements of SEQ with duplicates removed. -TESTFN is used to compare elements, or `equal' if TESTFN is nil." - (let ((result '())) - (seq-doseq (elt seq) - (unless (seq-contains result elt testfn) - (setq result (cons elt result)))) - (nreverse result))) - -(defun seq-subseq (seq start &optional end) - "Return the subsequence of SEQ from START to END. -If END is omitted, it defaults to the length of the sequence. -If START or END is negative, it counts from the end." - (cond ((or (stringp seq) (vectorp seq)) (substring seq start end)) - ((listp seq) - (let (len (errtext (format "Bad bounding indices: %s, %s" start end))) - (and end (< end 0) (setq end (+ end (setq len (seq-length seq))))) - (if (< start 0) (setq start (+ start (or len (setq len (seq-length seq)))))) - (when (> start 0) - (setq seq (nthcdr (1- start) seq)) - (or seq (error "%s" errtext)) - (setq seq (cdr seq))) - (if end - (let ((res nil)) - (while (and (>= (setq end (1- end)) start) seq) - (push (pop seq) res)) - (or (= (1+ end) start) (error "%s" errtext)) - (nreverse res)) - (seq-copy seq)))) - (t (error "Unsupported sequence: %s" seq)))) - -(defun seq-concatenate (type &rest seqs) - "Concatenate, into a sequence of type TYPE, the sequences SEQS. -TYPE must be one of following symbols: vector, string or list. - -\n(fn TYPE SEQUENCE...)" - (pcase type - (`vector (apply #'vconcat seqs)) - (`string (apply #'concat seqs)) - (`list (apply #'append (append seqs '(nil)))) - (t (error "Not a sequence type name: %S" type)))) - -(defun seq-mapcat (function seq &optional type) - "Concatenate the result of applying FUNCTION to each element of SEQ. -The result is a sequence of type TYPE, or a list if TYPE is nil." - (apply #'seq-concatenate (or type 'list) - (seq-map function seq))) - -(defun seq-partition (seq n) - "Return a list of the elements of SEQ grouped into sub-sequences of length N. -The last sequence may contain less than N elements. If N is a -negative integer or 0, nil is returned." - (unless (< n 1) - (let ((result '())) - (while (not (seq-empty-p seq)) - (push (seq-take seq n) result) - (setq seq (seq-drop seq n))) - (nreverse result)))) - -(defun seq-intersection (seq1 seq2 &optional testfn) - "Return a list of the elements that appear in both SEQ1 and SEQ2. -Equality is defined by TESTFN if non-nil or by `equal' if nil." - (seq-reduce (lambda (acc elt) - (if (seq-contains seq2 elt testfn) - (cons elt acc) - acc)) - (seq-reverse seq1) - '())) - -(defun seq-difference (seq1 seq2 &optional testfn) - "Return a list of the elements that appear in SEQ1 but not in SEQ2. -Equality is defined by TESTFN if non-nil or by `equal' if nil." - (seq-reduce (lambda (acc elt) - (if (not (seq-contains seq2 elt testfn)) - (cons elt acc) - acc)) - (seq-reverse seq1) - '())) - -(defun seq-group-by (function seq) - "Apply FUNCTION to each element of SEQ. -Separate the elements of SEQ into an alist using the results as -keys. Keys are compared using `equal'." - (seq-reduce - (lambda (acc elt) - (let* ((key (funcall function elt)) - (cell (assoc key acc))) - (if cell - (setcdr cell (push elt (cdr cell))) - (push (list key elt) acc)) - acc)) - (seq-reverse seq) - nil)) - -(defalias 'seq-reverse - (if (ignore-errors (reverse [1 2])) - #'reverse - (lambda (seq) - "Return the reversed copy of list, vector, or string SEQ. -See also the function `nreverse', which is used more often." - (let ((result '())) - (seq-map (lambda (elt) (push elt result)) - seq) - (if (listp seq) - result - (seq-into result (type-of seq))))))) - -(defun seq-into (seq type) - "Convert the sequence SEQ into a sequence of type TYPE. -TYPE can be one of the following symbols: vector, string or list." - (pcase type - (`vector (vconcat seq)) - (`string (concat seq)) - (`list (append seq nil)) - (t (error "Not a sequence type name: %S" type)))) - -(defun seq-min (seq) - "Return the smallest element of SEQ. -SEQ must be a sequence of numbers or markers." - (apply #'min (seq-into seq 'list))) - -(defun seq-max (seq) - "Return the largest element of SEQ. -SEQ must be a sequence of numbers or markers." - (apply #'max (seq-into seq 'list))) - -(defun seq--drop-list (list n) - "Return a list from LIST without its first N elements. -This is an optimization for lists in `seq-drop'." - (while (and list (> n 0)) - (setq list (cdr list) - n (1- n))) - list) - -(defun seq--take-list (list n) - "Return a list from LIST made of its first N elements. -This is an optimization for lists in `seq-take'." - (let ((result '())) - (while (and list (> n 0)) - (setq n (1- n)) - (push (pop list) result)) - (nreverse result))) - -(defun seq--drop-while-list (pred list) - "Return a list from the first element for which (PRED element) is nil in LIST. -This is an optimization for lists in `seq-drop-while'." - (while (and list (funcall pred (car list))) - (setq list (cdr list))) - list) - -(defun seq--take-while-list (pred list) - "Return the successive elements for which (PRED element) is non-nil in LIST. -This is an optimization for lists in `seq-take-while'." - (let ((result '())) - (while (and list (funcall pred (car list))) - (push (pop list) result)) - (nreverse result))) - -(defun seq--count-successive (pred seq) - "Return the number of successive elements for which (PRED element) is non-nil in SEQ." - (let ((n 0) - (len (seq-length seq))) - (while (and (< n len) - (funcall pred (seq-elt seq n))) - (setq n (+ 1 n))) - n)) - -(defun seq--make-pcase-bindings (args) - "Return a list of bindings of the variables in ARGS to the elements of a sequence." - (let ((bindings '()) - (index 0) - (rest-marker nil)) - (seq-doseq (name args) - (unless rest-marker - (pcase name - (`&rest - (progn (push `(app (pcase--flip seq-drop ,index) - ,(seq--elt-safe args (1+ index))) - bindings) - (setq rest-marker t))) - (t - (push `(app (pcase--flip seq--elt-safe ,index) ,name) bindings)))) - (setq index (1+ index))) - bindings)) - -(defun seq--make-pcase-patterns (args) - "Return a list of `(seq ...)' pcase patterns from the argument list ARGS." - (cons 'seq - (seq-map (lambda (elt) - (if (seq-p elt) - (seq--make-pcase-patterns elt) - elt)) - args))) - -;; Helper function for the Backward-compatible version of `seq-let' -;; for Emacs<25.1. -(defun seq--make-bindings (args seq &optional bindings) - "Return a list of bindings of the variables in ARGS to the elements of a sequence. -if BINDINGS is non-nil, append new bindings to it, and return -BINDINGS." - (let ((index 0) - (rest-marker nil)) - (seq-doseq (name args) - (unless rest-marker - (pcase name - ((pred seq-p) - (setq bindings (seq--make-bindings (seq--elt-safe args index) - `(seq--elt-safe ,seq ,index) - bindings))) - (`&rest - (progn (push `(,(seq--elt-safe args (1+ index)) - (seq-drop ,seq ,index)) - bindings) - (setq rest-marker t))) - (t - (push `(,name (seq--elt-safe ,seq ,index)) bindings)))) - (setq index (1+ index))) - bindings)) - -(defun seq--elt-safe (seq n) - "Return element of SEQ at the index N. -If no element is found, return nil." - (when (or (listp seq) - (and (sequencep seq) - (> (seq-length seq) n))) - (seq-elt seq n))) - -(defun seq--activate-font-lock-keywords () - "Activate font-lock keywords for some symbols defined in seq." - (font-lock-add-keywords 'emacs-lisp-mode - '("\\<seq-doseq\\>" "\\<seq-let\\>"))) - -(defalias 'seq-copy #'copy-sequence) -(defalias 'seq-elt #'elt) -(defalias 'seq-length #'length) -(defalias 'seq-do #'mapc) -(defalias 'seq-each #'seq-do) -(defalias 'seq-map #'mapcar) -(defalias 'seq-p #'sequencep) - -(unless (fboundp 'elisp--font-lock-flush-elisp-buffers) - ;; In Emacs≥25, (via elisp--font-lock-flush-elisp-buffers and a few others) - ;; we automatically highlight macros. - (add-hook 'emacs-lisp-mode-hook #'seq--activate-font-lock-keywords)) - -;;;; ChangeLog: - -;; 2015-10-20 Nicolas Petton <nicolas@petton.fr> -;; -;; Update seq.el to version 1.11 -;; -;; * packages/seq/seq.el: -;; * packages/seq/tests/seq-tests.el: Update. -;; -;; 2015-09-18 Nicolas Petton <nicolas@petton.fr> -;; -;; Update seq.el to version 1.9 -;; -;; * packages/seq/seq.el: Update to version 1.9. -;; * packages/seq/tests/seq-tests.el: Update to version 1.9. -;; -;; 2015-07-09 Nicolas Petton <nicolas@petton.fr> -;; -;; Update seq.el to version 1.8 -;; -;; * packages/seq/seq.el: Update to version 1.8. -;; * packages/seq/tests/seq-tests.el: Update to version 1.8. -;; -;; 2015-05-15 Nicolas Petton <nicolas@petton.fr> -;; -;; Update seq.el to version 1.7 -;; -;; * packages/seq/seq.el: Update to version 1.7. -;; * packages/seq/tests/seq-tests.el: Update to version 1.7. -;; -;; 2015-04-27 Nicolas Petton <nicolas@petton.fr> -;; -;; * packages/seq/seq.el: Update seq.el to version 1.5. -;; -;; 2015-04-15 Nicolas Petton <nicolas@petton.fr> -;; -;; seq.el update -;; -;; * packages/seq/seq.el: Update seq.el to version 1.4 -;; * packages/seq/tests/seq-tests.el: Update seq.el to version 1.4 -;; -;; 2015-03-25 Nicolas Petton <nicolas@petton.fr> -;; -;; Rephrases a comment in seq.el about the order of the arguments -;; -;; * packages/seq/seq.el: Better comment about the order of the arguments -;; -;; 2015-03-09 Nicolas Petton <nicolas@petton.fr> -;; -;; Update seq.el to version 1.3 -;; -;; * packages/seq/seq.el: update to version 1.3 -;; * packages/seq/tests/seq-tests.el: update to version 1.3 -;; -;; 2015-02-11 Nicolas Petton <nicolas@petton.fr> -;; -;; Update seq.el to version 1.2 -;; -;; * package/seq/seq.el: Update to version 1.2 -;; * packages/seq/tests/seq-tests.el: Update to version 1.2 -;; -;; 2015-02-09 Nicolas Petton <nicolas@petton.fr> -;; -;; Update seq.el to version 1.1.1 -;; -;; * package/seq/seq.el: Update to version 1.1.1 -;; * packages/seq/tests/seq-tests.el: Update to version 1.1.1 -;; -;; 2015-02-06 Nicolas Petton <nicolas@petton.fr> -;; -;; Update seq.el to version 1.1 -;; -;; * packages/seq/seq.el: Update to version 1.1 -;; * packages/seq/tests/seq-tests.el: Update to version 1.1 -;; -;; 2015-01-14 Nicolas Petton <nicolas@petton.fr> -;; -;; packages/seq: New package -;; - +(if (version< emacs-version "25") + (require 'seq-24) + (require 'seq-25)) (provide 'seq) ;;; seq.el ends here diff --git a/tests/seq-tests.el b/tests/seq-tests.el index 8f2dfbb..cf3da78 100644 --- a/tests/seq-tests.el +++ b/tests/seq-tests.el @@ -22,7 +22,7 @@ ;;; Commentary: -;; Tests for sequences.el +;; Tests for seq.el ;;; Code: @@ -92,6 +92,16 @@ Evaluate BODY for each created sequence. (with-test-sequences (seq '()) (should (seq-empty-p (seq-take-while #'test-sequences-oddp seq))))) +(ert-deftest test-seq-map-indexed () + (should (equal (seq-map-indexed (lambda (elt i) + (list elt i)) + nil) + nil)) + (should (equal (seq-map-indexed (lambda (elt i) + (list elt i)) + '(a b c d)) + '((a 0) (b 1) (c 2) (d 3))))) + (ert-deftest test-seq-filter () (with-test-sequences (seq '(6 7 8 9 10)) (should (equal (seq-filter #'test-sequences-evenp seq) '(6 8 10))) @@ -322,5 +332,23 @@ Evaluate BODY for each created sequence. (should (= (seq-position seq 'a #'eq) 0)) (should (null (seq-position seq (make-symbol "a") #'eq))))) +(ert-deftest test-seq-mapn () + (should-error (seq-mapn #'identity)) + (with-test-sequences (seq '(1 2 3 4 5 6 7)) + (should (equal (append seq nil) + (seq-mapn #'identity seq))) + (should (equal (seq-mapn #'1+ seq) + (seq-map #'1+ seq))) + + (with-test-sequences (seq-2 '(10 20 30 40 50)) + (should (equal (seq-mapn #'+ seq seq-2) + '(11 22 33 44 55))) + (should (equal (seq-mapn #'+ seq seq-2 nil) nil))))) + +(ert-deftest test-seq-sort-by () + (let ((seq ["x" "xx" "xxx"])) + (should (equal (seq-sort-by #'seq-length #'> seq) + ["xxx" "xx" "x"])))) + (provide 'seq-tests) ;;; seq-tests.el ends here |