From: Michael Heerdegen <michael_heerdegen@web.de>
To: Stefan Monnier <monnier@IRO.UMontreal.CA>
Cc: Mark Oteiza <mvoteiza@udel.edu>,
emacs-devel@gnu.org, npostavs@users.sourceforge.net
Subject: Re: if-let/if-let*/and-let/..
Date: Sat, 03 Mar 2018 15:12:53 +0100 [thread overview]
Message-ID: <874llx9riy.fsf@web.de> (raw)
In-Reply-To: <877er5e9vx.fsf@web.de> (Michael Heerdegen's message of "Thu, 22 Feb 2018 08:55:30 +0100")
[-- Attachment #1: Type: text/plain, Size: 530 bytes --]
Michael Heerdegen <michael_heerdegen@web.de> writes:
> Hmm - maybe it would be even better to make `foo-let*' just do what
> `foo-let' does currently - only handle a SPEC (SYMBOL EXPR) specially,
> and don't signal any errors.
Sorry for the delay. I've done that now - the new patch is attached.
In a subsequent commit we need to add to the documentation that an
element of the VARLIST can also be a symbol - that case is currently
undocumented. This is independent from this issue here, so I'll do it
in a separate commit.
[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2: 0001-Define-if-let-and-derivatives-as-aliases-of-if-let.patch --]
[-- Type: text/x-diff, Size: 24989 bytes --]
From 69d1375dd100f46100c0bbf2cff42846a8cdd139 Mon Sep 17 00:00:00 2001
From: Michael Heerdegen <michael_heerdegen@web.de>
Date: Wed, 21 Feb 2018 11:15:37 +0100
Subject: [PATCH] Define if-let* and derivatives as aliases of if-let
This commit reverts declaring `if-let' and `when-let' obsolete in
favor of the new `if-let* and `when-let*' versions because of the
compiler warning mess (Bug#30039). Instead we make foo-let and
foo-let* aliases. The old single-tuple variable spec case is still
supported for backward compatibility.
* lisp/emacs-lisp/subr-x.el (if-let, when-let): Don't declare
obsolete. Tweak edebug specs.
(and-let): Renamed from `and-let*' for compatibility with the names
`if-let' and `when-let'.
(if-let*, when-let*, and-let*): Define as aliases of `if-let',
`when-let' and `and-let'.
* test/lisp/emacs-lisp/subr-x-tests.el (if-let-single-tuple-case-test)
(when-let-single-tuple-case-test): New tests for the single-binding
tuple case.
In the whole file, prefer the names without "*".
---
etc/NEWS | 10 +-
lisp/emacs-lisp/subr-x.el | 55 ++++-----
test/lisp/emacs-lisp/subr-x-tests.el | 232 ++++++++++++++++++-----------------
3 files changed, 148 insertions(+), 149 deletions(-)
diff --git a/etc/NEWS b/etc/NEWS
index eded00e655..c88bec5a56 100644
--- a/etc/NEWS
+++ b/etc/NEWS
@@ -1301,12 +1301,10 @@ current buffer or the self-insertion takes place within a comment.
** The alist 'ucs-names' is now a hash table.
---
-** 'if-let' and 'when-let' are subsumed by 'if-let*' and 'when-let*'.
-The incumbent 'if-let' and 'when-let' are now marked obsolete.
-'if-let*' and 'when-let*' do not accept the single tuple special case.
-New macro 'and-let*' is an implementation of the Scheme SRFI-2 syntax
-of the same name. 'if-let*' and 'when-let*' now accept the same
-binding syntax as 'and-let*'.
+** The new macro 'and-let' is an implementation of the Scheme SRFI-2
+syntax. 'if-let' and 'when-let' now also accept the same binding
+syntax as 'and-let'. 'if-let*', 'when-let*' and 'and-let*' are new
+aliases for 'if-let', 'when-let' and 'and-let'.
---
** 'C-up', 'C-down', 'C-left' and 'C-right' are now defined in term
diff --git a/lisp/emacs-lisp/subr-x.el b/lisp/emacs-lisp/subr-x.el
index 21dba377bf..b2d7f0dec4 100644
--- a/lisp/emacs-lisp/subr-x.el
+++ b/lisp/emacs-lisp/subr-x.el
@@ -121,7 +121,7 @@ internal--build-bindings
binding))
bindings)))
-(defmacro if-let* (varlist then &rest else)
+(defmacro if-let (varlist then &rest else)
"Bind variables according to VARLIST and eval THEN or ELSE.
Each binding is evaluated in turn, and evaluation stops if a
binding value is nil. If all are non-nil, the value of THEN is
@@ -131,10 +131,18 @@ if-let*
SYMBOL to the value of VALUEFORM. An element can additionally
be of the form (VALUEFORM), which is evaluated and checked for
nil; i.e. SYMBOL can be omitted if only the test result is of
-interest."
+interest.
+
+As a special case, a VARLIST of the form (SYMBOL SOMETHING) is
+treated like ((SYMBOL SOMETHING))."
(declare (indent 2)
- (debug ((&rest [&or symbolp (symbolp form) (form)])
+ (debug ([&or (symbolp form)
+ (&rest [&or symbolp (symbolp form) (form)])]
form body)))
+ (pcase varlist
+ (`(,(pred symbolp) ,_)
+ ;; the single-tuple syntax case, for backward compatibility
+ (cl-callf list varlist)))
(if varlist
`(let* ,(setq varlist (internal--build-bindings varlist))
(if ,(caar (last varlist))
@@ -142,23 +150,23 @@ if-let*
,@else))
`(let* () ,then)))
-(defmacro when-let* (varlist &rest body)
+(defmacro when-let (varlist &rest body)
"Bind variables according to VARLIST and conditionally eval BODY.
Each binding is evaluated in turn, and evaluation stops if a
binding value is nil. If all are non-nil, the value of the last
form in BODY is returned.
-VARLIST is the same as in `if-let*'."
- (declare (indent 1) (debug if-let*))
- (list 'if-let* varlist (macroexp-progn body)))
+VARLIST is the same as in `if-let'."
+ (declare (indent 1) (debug ([&or (symbolp form)
+ (&rest [&or symbolp (symbolp form) (form)])]
+ body)))
+ (list 'if-let varlist (macroexp-progn body)))
-(defmacro and-let* (varlist &rest body)
+(defmacro and-let (varlist &rest body)
"Bind variables according to VARLIST and conditionally eval BODY.
-Like `when-let*', except if BODY is empty and all the bindings
+Like `when-let', except if BODY is empty and all the bindings
are non-nil, then the result is non-nil."
- (declare (indent 1)
- (debug ((&rest [&or symbolp (symbolp form) (form)])
- body)))
+ (declare (indent 1) (debug when-let))
(let (res)
(if varlist
`(let* ,(setq varlist (internal--build-bindings varlist))
@@ -166,26 +174,9 @@ and-let*
,@(or body `(,res))))
`(let* () ,@(or body '(t))))))
-(defmacro if-let (spec then &rest else)
- "Bind variables according to SPEC and eval THEN or ELSE.
-Like `if-let*' except SPEC can have the form (SYMBOL VALUEFORM)."
- (declare (indent 2)
- (debug ([&or (&rest [&or symbolp (symbolp form) (form)])
- (symbolp form)]
- form body))
- (obsolete "use `if-let*' instead." "26.1"))
- (when (and (<= (length spec) 2)
- (not (listp (car spec))))
- ;; Adjust the single binding case
- (setq spec (list spec)))
- (list 'if-let* spec then (macroexp-progn else)))
-
-(defmacro when-let (spec &rest body)
- "Bind variables according to SPEC and conditionally eval BODY.
-Like `when-let*' except SPEC can have the form (SYMBOL VALUEFORM)."
- (declare (indent 1) (debug if-let)
- (obsolete "use `when-let*' instead." "26.1"))
- (list 'if-let spec (macroexp-progn body)))
+(defalias 'if-let* #'if-let)
+(defalias 'when-let* #'when-let)
+(defalias 'and-let* #'and-let)
(defsubst hash-table-empty-p (hash-table)
"Check whether HASH-TABLE is empty (has 0 elements)."
diff --git a/test/lisp/emacs-lisp/subr-x-tests.el b/test/lisp/emacs-lisp/subr-x-tests.el
index c9618f3c37..a361718c9e 100644
--- a/test/lisp/emacs-lisp/subr-x-tests.el
+++ b/test/lisp/emacs-lisp/subr-x-tests.el
@@ -28,13 +28,13 @@
(require 'subr-x)
\f
-;; `if-let*' tests
+;; `if-let' tests
-(ert-deftest subr-x-test-if-let*-single-binding-expansion ()
+(ert-deftest subr-x-test-if-let-single-binding-expansion ()
"Test single bindings are expanded properly."
(should (equal
(macroexpand
- '(if-let* ((a 1))
+ '(if-let ((a 1))
(- a)
"no"))
'(let* ((a (and t 1)))
@@ -43,7 +43,7 @@
"no"))))
(should (equal
(macroexpand
- '(if-let* (a)
+ '(if-let (a)
(- a)
"no"))
'(let* ((a (and t a)))
@@ -51,11 +51,11 @@
(- a)
"no")))))
-(ert-deftest subr-x-test-if-let*-single-symbol-expansion ()
+(ert-deftest subr-x-test-if-let-single-symbol-expansion ()
"Test single symbol bindings are expanded properly."
(should (equal
(macroexpand
- '(if-let* (a)
+ '(if-let (a)
(- a)
"no"))
'(let* ((a (and t a)))
@@ -64,7 +64,7 @@
"no"))))
(should (equal
(macroexpand
- '(if-let* (a b c)
+ '(if-let (a b c)
(- a)
"no"))
'(let* ((a (and t a))
@@ -75,7 +75,7 @@
"no"))))
(should (equal
(macroexpand
- '(if-let* (a (b 2) c)
+ '(if-let (a (b 2) c)
(- a)
"no"))
'(let* ((a (and t a))
@@ -85,11 +85,11 @@
(- a)
"no")))))
-(ert-deftest subr-x-test-if-let*-nil-related-expansion ()
+(ert-deftest subr-x-test-if-let-nil-related-expansion ()
"Test nil is processed properly."
(should (equal
(macroexpand
- '(if-let* (nil)
+ '(if-let (nil)
(- a)
"no"))
'(let* ((nil (and t nil)))
@@ -98,7 +98,7 @@
"no"))))
(should (equal
(macroexpand
- '(if-let* ((a 1) nil (b 2))
+ '(if-let ((a 1) nil (b 2))
(- a)
"no"))
'(let* ((a (and t 1))
@@ -108,106 +108,106 @@
(- a)
"no")))))
-(ert-deftest subr-x-test-if-let*-malformed-binding ()
+(ert-deftest subr-x-test-if-let-malformed-binding ()
"Test malformed bindings trigger errors."
(should-error (macroexpand
- '(if-let* (_ (a 1 1) (b 2) (c 3) d)
+ '(if-let (_ (a 1 1) (b 2) (c 3) d)
(- a)
"no"))
:type 'error)
(should-error (macroexpand
- '(if-let* (_ (a 1) (b 2 2) (c 3) d)
+ '(if-let (_ (a 1) (b 2 2) (c 3) d)
(- a)
"no"))
:type 'error)
(should-error (macroexpand
- '(if-let* (_ (a 1) (b 2) (c 3 3) d)
+ '(if-let (_ (a 1) (b 2) (c 3 3) d)
(- a)
"no"))
:type 'error)
(should-error (macroexpand
- '(if-let* ((a 1 1))
+ '(if-let ((a 1 1))
(- a)
"no"))
:type 'error))
-(ert-deftest subr-x-test-if-let*-true ()
+(ert-deftest subr-x-test-if-let-true ()
"Test `if-let' with truthy bindings."
(should (equal
- (if-let* ((a 1))
+ (if-let ((a 1))
a
"no")
1))
(should (equal
- (if-let* ((a 1) (b 2) (c 3))
+ (if-let ((a 1) (b 2) (c 3))
(list a b c)
"no")
(list 1 2 3))))
-(ert-deftest subr-x-test-if-let*-false ()
+(ert-deftest subr-x-test-if-let-false ()
"Test `if-let' with falsie bindings."
(should (equal
- (if-let* ((a nil))
+ (if-let ((a nil))
(list a b c)
"no")
"no"))
(should (equal
- (if-let* ((a nil) (b 2) (c 3))
+ (if-let ((a nil) (b 2) (c 3))
(list a b c)
"no")
"no"))
(should (equal
- (if-let* ((a 1) (b nil) (c 3))
+ (if-let ((a 1) (b nil) (c 3))
(list a b c)
"no")
"no"))
(should (equal
- (if-let* ((a 1) (b 2) (c nil))
+ (if-let ((a 1) (b 2) (c nil))
(list a b c)
"no")
"no"))
(should (equal
(let (z)
- (if-let* (z (a 1) (b 2) (c 3))
+ (if-let (z (a 1) (b 2) (c 3))
(list a b c)
"no"))
"no"))
(should (equal
(let (d)
- (if-let* ((a 1) (b 2) (c 3) d)
+ (if-let ((a 1) (b 2) (c 3) d)
(list a b c)
"no"))
"no")))
-(ert-deftest subr-x-test-if-let*-bound-references ()
+(ert-deftest subr-x-test-if-let-bound-references ()
"Test `if-let' bindings can refer to already bound symbols."
(should (equal
- (if-let* ((a (1+ 0)) (b (1+ a)) (c (1+ b)))
+ (if-let ((a (1+ 0)) (b (1+ a)) (c (1+ b)))
(list a b c)
"no")
(list 1 2 3))))
-(ert-deftest subr-x-test-if-let*-and-laziness-is-preserved ()
+(ert-deftest subr-x-test-if-let-and-laziness-is-preserved ()
"Test `if-let' respects `and' laziness."
(let (a-called b-called c-called)
(should (equal
- (if-let* ((a nil)
- (b (setq b-called t))
- (c (setq c-called t)))
+ (if-let ((a nil)
+ (b (setq b-called t))
+ (c (setq c-called t)))
"yes"
(list a-called b-called c-called))
(list nil nil nil))))
(let (a-called b-called c-called)
(should (equal
- (if-let* ((a (setq a-called t))
- (b nil)
- (c (setq c-called t)))
+ (if-let ((a (setq a-called t))
+ (b nil)
+ (c (setq c-called t)))
"yes"
(list a-called b-called c-called))
(list t nil nil))))
(let (a-called b-called c-called)
(should (equal
- (if-let* ((a (setq a-called t))
+ (if-let ((a (setq a-called t))
(b (setq b-called t))
(c nil)
(d (setq c-called t)))
@@ -215,14 +215,19 @@
(list a-called b-called c-called))
(list t t nil)))))
+(defun if-let-single-tuple-case-test ()
+ "Test the BINDING-SPEC == (SYMBOL SOMETHING) case."
+ (should (equal (if-let (a 1) (1+ a)) 2))
+ (should (equal (let ((b 2)) (if-let (a b) a)) 2)))
+
\f
-;; `when-let*' tests
+;; `when-let' tests
-(ert-deftest subr-x-test-when-let*-body-expansion ()
+(ert-deftest subr-x-test-when-let-body-expansion ()
"Test body allows for multiple sexps wrapping with progn."
(should (equal
(macroexpand
- '(when-let* ((a 1))
+ '(when-let ((a 1))
(message "opposite")
(- a)))
'(let* ((a (and t 1)))
@@ -231,18 +236,18 @@
(message "opposite")
(- a)))))))
-(ert-deftest subr-x-test-when-let*-single-symbol-expansion ()
+(ert-deftest subr-x-test-when-let-single-symbol-expansion ()
"Test single symbol bindings are expanded properly."
(should (equal
(macroexpand
- '(when-let* (a)
+ '(when-let (a)
(- a)))
'(let* ((a (and t a)))
(if a
(- a)))))
(should (equal
(macroexpand
- '(when-let* (a b c)
+ '(when-let (a b c)
(- a)))
'(let* ((a (and t a))
(b (and a b))
@@ -251,7 +256,7 @@
(- a)))))
(should (equal
(macroexpand
- '(when-let* (a (b 2) c)
+ '(when-let (a (b 2) c)
(- a)))
'(let* ((a (and t a))
(b (and a 2))
@@ -259,18 +264,18 @@
(if c
(- a))))))
-(ert-deftest subr-x-test-when-let*-nil-related-expansion ()
+(ert-deftest subr-x-test-when-let-nil-related-expansion ()
"Test nil is processed properly."
(should (equal
(macroexpand
- '(when-let* (nil)
+ '(when-let (nil)
(- a)))
'(let* ((nil (and t nil)))
(if nil
(- a)))))
(should (equal
(macroexpand
- '(when-let* ((a 1) nil (b 2))
+ '(when-let ((a 1) nil (b 2))
(- a)))
'(let* ((a (and t 1))
(nil (and a nil))
@@ -278,173 +283,178 @@
(if b
(- a))))))
-(ert-deftest subr-x-test-when-let*-malformed-binding ()
+(ert-deftest subr-x-test-when-let-malformed-binding ()
"Test malformed bindings trigger errors."
(should-error (macroexpand
- '(when-let* (_ (a 1 1) (b 2) (c 3) d)
+ '(when-let (_ (a 1 1) (b 2) (c 3) d)
(- a)))
:type 'error)
(should-error (macroexpand
- '(when-let* (_ (a 1) (b 2 2) (c 3) d)
+ '(when-let (_ (a 1) (b 2 2) (c 3) d)
(- a)))
:type 'error)
(should-error (macroexpand
- '(when-let* (_ (a 1) (b 2) (c 3 3) d)
+ '(when-let (_ (a 1) (b 2) (c 3 3) d)
(- a)))
:type 'error)
(should-error (macroexpand
- '(when-let* ((a 1 1))
+ '(when-let ((a 1 1))
(- a)))
:type 'error))
-(ert-deftest subr-x-test-when-let*-true ()
+(ert-deftest subr-x-test-when-let-true ()
"Test `when-let' with truthy bindings."
(should (equal
- (when-let* ((a 1))
+ (when-let ((a 1))
a)
1))
(should (equal
- (when-let* ((a 1) (b 2) (c 3))
+ (when-let ((a 1) (b 2) (c 3))
(list a b c))
(list 1 2 3))))
-(ert-deftest subr-x-test-when-let*-false ()
+(ert-deftest subr-x-test-when-let-false ()
"Test `when-let' with falsie bindings."
(should (equal
- (when-let* ((a nil))
+ (when-let ((a nil))
(list a b c)
"no")
nil))
(should (equal
- (when-let* ((a nil) (b 2) (c 3))
+ (when-let ((a nil) (b 2) (c 3))
(list a b c)
"no")
nil))
(should (equal
- (when-let* ((a 1) (b nil) (c 3))
+ (when-let ((a 1) (b nil) (c 3))
(list a b c)
"no")
nil))
(should (equal
- (when-let* ((a 1) (b 2) (c nil))
+ (when-let ((a 1) (b 2) (c nil))
(list a b c)
"no")
nil))
(should (equal
(let (z)
- (when-let* (z (a 1) (b 2) (c 3))
+ (when-let (z (a 1) (b 2) (c 3))
(list a b c)
"no"))
nil))
(should (equal
(let (d)
- (when-let* ((a 1) (b 2) (c 3) d)
+ (when-let ((a 1) (b 2) (c 3) d)
(list a b c)
"no"))
nil)))
-(ert-deftest subr-x-test-when-let*-bound-references ()
+(ert-deftest subr-x-test-when-let-bound-references ()
"Test `when-let' bindings can refer to already bound symbols."
(should (equal
- (when-let* ((a (1+ 0)) (b (1+ a)) (c (1+ b)))
+ (when-let ((a (1+ 0)) (b (1+ a)) (c (1+ b)))
(list a b c))
(list 1 2 3))))
-(ert-deftest subr-x-test-when-let*-and-laziness-is-preserved ()
+(ert-deftest subr-x-test-when-let-and-laziness-is-preserved ()
"Test `when-let' respects `and' laziness."
(let (a-called b-called c-called)
(should (equal
(progn
- (when-let* ((a nil)
- (b (setq b-called t))
- (c (setq c-called t)))
+ (when-let ((a nil)
+ (b (setq b-called t))
+ (c (setq c-called t)))
"yes")
(list a-called b-called c-called))
(list nil nil nil))))
(let (a-called b-called c-called)
(should (equal
(progn
- (when-let* ((a (setq a-called t))
- (b nil)
- (c (setq c-called t)))
+ (when-let ((a (setq a-called t))
+ (b nil)
+ (c (setq c-called t)))
"yes")
(list a-called b-called c-called))
(list t nil nil))))
(let (a-called b-called c-called)
(should (equal
(progn
- (when-let* ((a (setq a-called t))
- (b (setq b-called t))
- (c nil)
- (d (setq c-called t)))
+ (when-let ((a (setq a-called t))
+ (b (setq b-called t))
+ (c nil)
+ (d (setq c-called t)))
"yes")
(list a-called b-called c-called))
(list t t nil)))))
+(defun when-let-single-tuple-case-test ()
+ "Test the BINDING-SPEC == (SYMBOL SOMETHING) case."
+ (should (equal (when-let (a 1) (1+ a)) 2))
+ (should (equal (let ((b 2)) (when-let (a b) a)) 2)))
+
\f
-;; `and-let*' tests
+;; `and-let' tests
;; Adapted from the Guile tests
;; https://git.savannah.gnu.org/cgit/guile.git/tree/test-suite/tests/srfi-2.test
-(ert-deftest subr-x-and-let*-test-empty-varlist ()
- (should (equal 1 (and-let* () 1)))
- (should (equal 2 (and-let* () 1 2)))
- (should (equal t (and-let* ()))))
+(ert-deftest subr-x-and-let-test-empty-varlist ()
+ (should (equal 1 (and-let () 1)))
+ (should (equal 2 (and-let () 1 2)))
+ (should (equal t (and-let ()))))
-(ert-deftest subr-x-and-let*-test-group-1 ()
- (should (equal nil (let ((x nil)) (and-let* (x)))))
- (should (equal 1 (let ((x 1)) (and-let* (x)))))
- (should (equal nil (and-let* ((x nil)))))
- (should (equal 1 (and-let* ((x 1)))))
+(ert-deftest subr-x-and-let-test-group-1 ()
+ (should (equal nil (let ((x nil)) (and-let (x)))))
+ (should (equal 1 (let ((x 1)) (and-let (x)))))
+ (should (equal nil (and-let ((x nil)))))
+ (should (equal 1 (and-let ((x 1)))))
;; The error doesn't trigger when compiled: the compiler will give
;; a warning and then drop the erroneous code. Therefore, use
;; `eval' to avoid compilation.
- (should-error (eval '(and-let* (nil (x 1))) lexical-binding)
+ (should-error (eval '(and-let (nil (x 1))) lexical-binding)
:type 'setting-constant)
- (should (equal nil (and-let* ((nil) (x 1)))))
- (should-error (eval '(and-let* (2 (x 1))) lexical-binding)
+ (should (equal nil (and-let ((nil) (x 1)))))
+ (should-error (eval '(and-let (2 (x 1))) lexical-binding)
:type 'wrong-type-argument)
- (should (equal 1 (and-let* ((2) (x 1)))))
- (should (equal 2 (and-let* ((x 1) (2)))))
- (should (equal nil (let ((x nil)) (and-let* (x) x))))
- (should (equal "" (let ((x "")) (and-let* (x) x))))
- (should (equal "" (let ((x "")) (and-let* (x)))))
- (should (equal 2 (let ((x 1)) (and-let* (x) (+ x 1)))))
- (should (equal nil (let ((x nil)) (and-let* (x) (+ x 1)))))
- (should (equal 2 (let ((x 1)) (and-let* (((> x 0))) (+ x 1)))))
- (should (equal t (let ((x 1)) (and-let* (((> x 0)))))))
- (should (equal nil (let ((x 0)) (and-let* (((> x 0))) (+ x 1)))))
+ (should (equal 1 (and-let ((2) (x 1)))))
+ (should (equal 2 (and-let ((x 1) (2)))))
+ (should (equal nil (let ((x nil)) (and-let (x) x))))
+ (should (equal "" (let ((x "")) (and-let (x) x))))
+ (should (equal "" (let ((x "")) (and-let (x)))))
+ (should (equal 2 (let ((x 1)) (and-let (x) (+ x 1)))))
+ (should (equal nil (let ((x nil)) (and-let (x) (+ x 1)))))
+ (should (equal 2 (let ((x 1)) (and-let (((> x 0))) (+ x 1)))))
+ (should (equal t (let ((x 1)) (and-let (((> x 0)))))))
+ (should (equal nil (let ((x 0)) (and-let (((> x 0))) (+ x 1)))))
(should (equal 3
- (let ((x 1)) (and-let* (((> x 0)) (x (+ x 1))) (+ x 1))))))
+ (let ((x 1)) (and-let (((> x 0)) (x (+ x 1))) (+ x 1))))))
-(ert-deftest subr-x-and-let*-test-rebind ()
+(ert-deftest subr-x-and-let-test-rebind ()
(should
(equal 4
(let ((x 1))
- (and-let* (((> x 0)) (x (+ x 1)) (x (+ x 1))) (+ x 1))))))
+ (and-let (((> x 0)) (x (+ x 1)) (x (+ x 1))) (+ x 1))))))
-(ert-deftest subr-x-and-let*-test-group-2 ()
+(ert-deftest subr-x-and-let-test-group-2 ()
(should
- (equal 2 (let ((x 1)) (and-let* (x ((> x 0))) (+ x 1)))))
+ (equal 2 (let ((x 1)) (and-let (x ((> x 0))) (+ x 1)))))
(should
- (equal 2 (let ((x 1)) (and-let* (((progn x)) ((> x 0))) (+ x 1)))))
- (should (equal nil (let ((x 0)) (and-let* (x ((> x 0))) (+ x 1)))))
- (should (equal nil (let ((x nil)) (and-let* (x ((> x 0))) (+ x 1)))))
+ (equal 2 (let ((x 1)) (and-let (((progn x)) ((> x 0))) (+ x 1)))))
+ (should (equal nil (let ((x 0)) (and-let (x ((> x 0))) (+ x 1)))))
+ (should (equal nil (let ((x nil)) (and-let (x ((> x 0))) (+ x 1)))))
(should
- (equal nil (let ((x nil)) (and-let* (((progn x)) ((> x 0))) (+ x 1))))))
+ (equal nil (let ((x nil)) (and-let (((progn x)) ((> x 0))) (+ x 1))))))
-(ert-deftest subr-x-and-let*-test-group-3 ()
+(ert-deftest subr-x-and-let-test-group-3 ()
(should
- (equal nil (let ((x 1)) (and-let* (x (y (- x 1)) ((> y 0))) (/ x y)))))
+ (equal nil (let ((x 1)) (and-let (x (y (- x 1)) ((> y 0))) (/ x y)))))
(should
- (equal nil (let ((x 0)) (and-let* (x (y (- x 1)) ((> y 0))) (/ x y)))))
+ (equal nil (let ((x 0)) (and-let (x (y (- x 1)) ((> y 0))) (/ x y)))))
(should
(equal nil
- (let ((x nil)) (and-let* (x (y (- x 1)) ((> y 0))) (/ x y)))))
+ (let ((x nil)) (and-let (x (y (- x 1)) ((> y 0))) (/ x y)))))
(should
(equal (/ 3.0 2)
- (let ((x 3.0)) (and-let* (x (y (- x 1)) ((> y 0))) (/ x y))))))
+ (let ((x 3.0)) (and-let (x (y (- x 1)) ((> y 0))) (/ x y))))))
\f
--
2.16.1
[-- Attachment #3: Type: text/plain, Size: 21 bytes --]
Regards,
Michael.
next prev parent reply other threads:[~2018-03-03 14:12 UTC|newest]
Thread overview: 47+ messages / expand[flat|nested] mbox.gz Atom feed top
2018-02-11 23:51 if-let/if-let*/and-let/ Stefan Monnier
[not found] ` <87wozijhpk.fsf@web.de>
[not found] ` <jwv8tbyyx4x.fsf-monnier+emacs@gnu.org>
2018-02-12 17:32 ` if-let/if-let*/and-let/ Stefan Monnier
2018-02-13 18:23 ` if-let/if-let*/and-let/ Michael Heerdegen
2018-02-13 19:24 ` if-let/if-let*/and-let/ Stefan Monnier
2018-02-13 20:52 ` if-let/if-let*/and-let/ John Wiegley
2018-02-13 19:31 ` if-let/if-let*/and-let/ Mark Oteiza
2018-02-13 20:49 ` if-let/if-let*/and-let/ Stefan Monnier
2018-02-14 0:07 ` if-let/if-let*/and-let/ Mark Oteiza
2018-02-14 23:07 ` if-let/if-let*/and-let/ Michael Heerdegen
2018-02-15 3:37 ` if-let/if-let*/and-let/ Stefan Monnier
2018-02-21 4:26 ` if-let/if-let*/and-let/ Michael Heerdegen
2018-02-22 1:08 ` if-let/if-let*/and-let/ Michael Heerdegen
2018-02-22 5:10 ` if-let/if-let*/and-let/ Stefan Monnier
2018-02-22 7:55 ` if-let/if-let*/and-let/ Michael Heerdegen
2018-03-03 14:12 ` Michael Heerdegen [this message]
2018-03-06 15:03 ` if-let/if-let*/and-let/ Michael Heerdegen
2018-03-06 15:31 ` if-let/if-let*/and-let/ Michael Heerdegen
2018-03-06 15:34 ` if-let/if-let*/and-let/ John Wiegley
2018-03-06 16:03 ` if-let/if-let*/and-let/ Stefan Monnier
2018-03-06 17:40 ` if-let/if-let*/and-let/ Michael Heerdegen
2018-03-06 19:12 ` if-let/if-let*/and-let/ Radon Rosborough
2018-03-07 2:13 ` if-let/if-let*/and-let/ James Nguyen
2018-03-07 3:42 ` if-let/if-let*/and-let/ Kaushal Modi
2018-03-06 17:40 ` if-let/if-let*/and-let/ Eli Zaretskii
2018-03-07 14:15 ` if-let/if-let*/and-let/ Michael Heerdegen
2018-03-07 15:13 ` if-let/if-let*/and-let/ Nicolas Petton
2018-03-07 20:43 ` if-let/if-let*/and-let/ John Wiegley
2018-03-08 13:53 ` if-let/if-let*/and-let/ Eli Zaretskii
2018-03-09 15:16 ` if-let/if-let*/and-let/ Michael Heerdegen
2018-03-09 15:32 ` if-let/if-let*/and-let/ Eli Zaretskii
2018-03-09 16:07 ` if-let/if-let*/and-let/ Michael Heerdegen
2018-03-09 16:24 ` if-let/if-let*/and-let/ Eli Zaretskii
2018-03-09 16:33 ` if-let/if-let*/and-let/ Michael Heerdegen
2018-03-09 18:22 ` if-let/if-let*/and-let/ Eli Zaretskii
2018-03-09 22:24 ` if-let/if-let*/and-let/ Michael Heerdegen
2018-03-10 8:02 ` if-let/if-let*/and-let/ Eli Zaretskii
2018-03-10 15:54 ` if-let/if-let*/and-let/ Stefan Monnier
2018-03-10 16:07 ` if-let/if-let*/and-let/ Michael Heerdegen
2018-03-10 16:29 ` if-let/if-let*/and-let/ Eli Zaretskii
2018-03-10 17:16 ` if-let/if-let*/and-let/ Michael Heerdegen
2018-03-10 17:29 ` if-let/if-let*/and-let/ Eli Zaretskii
2018-03-06 16:04 ` if-let/if-let*/and-let/ Eli Zaretskii
2018-03-06 17:35 ` if-let/if-let*/and-let/ Michael Heerdegen
2018-02-13 20:54 ` if-let/if-let*/and-let/ Michael Heerdegen
2018-02-13 21:57 ` if-let/if-let*/and-let/ Eric Abrahamsen
2018-02-13 22:39 ` if-let/if-let*/and-let/ Michael Heerdegen
2018-02-13 22:51 ` if-let/if-let*/and-let/ Eric Abrahamsen
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=874llx9riy.fsf@web.de \
--to=michael_heerdegen@web.de \
--cc=emacs-devel@gnu.org \
--cc=monnier@IRO.UMontreal.CA \
--cc=mvoteiza@udel.edu \
--cc=npostavs@users.sourceforge.net \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
Code repositories for project(s) associated with this external index
https://git.savannah.gnu.org/cgit/emacs.git
https://git.savannah.gnu.org/cgit/emacs/org-mode.git
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.