]> git.eshelyaron.com Git - emacs.git/commitdiff
New macro seq-let, providing destructuring support to seq.el
authorNicolas Petton <nicolas@petton.fr>
Fri, 1 May 2015 17:30:56 +0000 (19:30 +0200)
committerNicolas Petton <nicolas@petton.fr>
Fri, 1 May 2015 17:33:40 +0000 (19:33 +0200)
* lisp/emacs-lisp/seq.el (seq-let): New macro.  `seq-let' is similar
to `cl-destructuring-bind' but works on all sequence types supported
by `seq.el'.  Bump version number to 1.6.
* test/automated/seq-tests.el: Add tests for seq-let.
* doc/lispref/sequences.texi: Add documentation for seq-let.

doc/lispref/sequences.texi
lisp/emacs-lisp/seq.el
test/automated/seq-tests.el

index b48fae4741f0706d307ff20e674df777d19e6bfc..e58f0390a45048463b5dd2f5bb24261a50935cee 100644 (file)
@@ -797,6 +797,33 @@ vector or string (@pxref{Iteration} for more information about the
 @code{dolist} macro).  This is primarily useful for side-effects.
 @end defmac
 
+@defmac seq-let arguments sequense body@dots{}
+@cindex sequence destructuring
+  This macro binds the variables in defined in the sequence
+@var{arguments} to the elements of the sequence @var{sequence}.
+@var{arguments} can itself include sequences allowing for nested
+destructuring.
+
+@example
+@group
+(seq-let [first second] [1 2 3 4]
+  (list first second))
+@result{} (1 2)
+@end group
+@group
+(seq-let (_ a _ b) '(1 2 3 4)
+  (list a b))
+@result{} (2 4)
+@end group
+@group
+(seq-let [a [b [c]]] [1 [2 [3]]]
+  (list a b c))
+@result{} (1 2 3)
+@end group
+@end example
+@end defmac
+
+
 @node Arrays
 @section Arrays
 @cindex array
index 2f3f519e986851d8f09ed7b66be4a61fd26033d0..d22bbc578175158f5b67f6d117a960a5be57f915 100644 (file)
@@ -4,7 +4,7 @@
 
 ;; Author: Nicolas Petton <nicolas@petton.fr>
 ;; Keywords: sequences
-;; Version: 1.5
+;; Version: 1.6
 ;; Package: seq
 
 ;; Maintainer: emacs-devel@gnu.org
 ;;
 ;; All functions are tested in test/automated/seq-tests.el
 
+;;; TODO:
+
+;; - Add support for &rest in the argument list of seq-let
+
 ;;; Code:
 
 (defmacro seq-doseq (spec &rest body)
@@ -65,6 +69,14 @@ Evaluate BODY with VAR bound to each element of SEQ, in turn.
                               (pop ,index))))
            ,@body)))))
 
+(defmacro seq-let (args seq &rest body)
+  "Bind the variables in ARGS to the elements of SEQ then evaluate BODY."
+  (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.
@@ -336,7 +348,30 @@ This is an optimization for lists in `seq-take-while'."
 (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-doseq\\>" "\\<seq-let\\>")))
+
+(defun seq--make-bindings (args seq &optional initial-bindings)
+  "Return an alist of the bindings the variables in ARGS to the elements of SEQ.
+if INITIAL-BINDINGS is non-nil, append new bindings to it, and
+return INITIAL-BINDINGS."
+  (let ((index 0))
+    (seq-doseq (name args)
+      (if (sequencep name)
+          (setq initial-bindings (seq--make-bindings
+                                  (seq--elt-safe args index)
+                                  `(seq--elt-safe ,seq ,index)
+                                  initial-bindings))
+        (push `(,name (seq--elt-safe ,seq ,index)) initial-bindings))
+      (setq index (1+ index)))
+    initial-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)))
 
 (defalias 'seq-copy #'copy-sequence)
 (defalias 'seq-elt #'elt)
index 7f6e06cc4b6edd248b11bf8b0d22d550b62496b5..e1e8ae002d07d957659681c6ea46487a24b0031d 100644 (file)
@@ -276,5 +276,22 @@ Evaluate BODY for each created sequence.
         (v2 [2 4 6]))
     (should (seq-empty-p (seq-difference v1 v2)))))
 
+(ert-deftest test-seq-let ()
+  (with-test-sequences (seq '(1 2 3 4))
+    (seq-let (a b c d e) seq
+      (should (= a 1))
+      (should (= b 2))
+      (should (= c 3))
+      (should (= d 4))
+      (should (null e))))
+  (let ((seq '(1 (2 (3 (4))))))
+    (seq-let (_ (_ (_ (a)))) seq
+      (should (= a 4))))
+  (let (seq)
+    (seq-let (a b c) seq
+      (should (null a))
+      (should (null b))
+      (should (null c)))))
+
 (provide 'seq-tests)
 ;;; seq-tests.el ends here