bug#28254: 26.0.50; SRFI-2 and-let*

[Mark Oteiza]

On 03/09/17 at 07:48pm, Michael Heerdegen wrote:
> Noam Postavsky <npostavs@users.sourceforge.net> writes:
>
> > I think I'd be okay with dropping support for the S = (S nil) thing in
> > foo-let macros, so that all of the above would give (void-variable x).
> > Although perhaps the incompatibility with plain let would be annoying?
> > To be honest I hardly ever make use of S = (S nil) in plain let either
> > so it wouldn't hit me at all.
>
> I think the main use case is to declare a local variable when you don't
> care about the init value.  In the case of if-let, S = (S nil) is not
> useful, since you can't use that binding neither in the "then" clause
> (because it won't be executed) nor in the "else" clauses (which ignore
> all bindings).
>
> Even if an `if-let' form is the result of a macro expansion, the S = (S
> nil) case isn't of any value.  So I see no reasons to not drop support
> for it.

If I'm understanding correctly,  it is being agreed that

 (let ((x 1)) (and-let* (x) x)) ;; => 1

because the macro expands to

 (let* ((x (and t x)))
   (if x x))

The following patch achieves this, though it breaks some existing subr-x
tests which I haven't yet looked at carefully.


diff --git a/lisp/emacs-lisp/subr-x.el b/lisp/emacs-lisp/subr-x.el
index 849ac19d6a..ec1990110a 100644
--- a/lisp/emacs-lisp/subr-x.el
+++ b/lisp/emacs-lisp/subr-x.el
@@ -83,10 +83,22 @@ thread-last
  `(internal--thread-argument nil ,@forms))

(defsubst internal--listify (elt)
-  "Wrap ELT in a list if it is not one."
-  (if (not (listp elt))
-      (list elt)
-    elt))
+  "Wrap ELT in a list if it is not one.
+If ELT is of the form ((EXPR)), listify (EXPR) with a dummy symbol."
+  (message "%S" elt)
+  (cond
+   ;; could this be cleaner?
+   ((null elt) (list elt))
+   ((symbolp elt) (list elt elt))
+   ((nlistp elt) (list elt))
+   ((and (null (cdr elt))
+         (atom (car elt)))
+    (list (cl-gensym) (car elt)))
+   ((and (null (cdr elt))
+         (let ((form (car elt)))
+           (or (listp form) (atom form))))
+    (list (cl-gensym) (car elt)))
+   (t elt)))

(defsubst internal--check-binding (binding)
  "Check BINDING is properly formed."
@@ -98,7 +110,10 @@ internal--check-binding

(defsubst internal--build-binding-value-form (binding prev-var)
  "Build the conditional value form for BINDING using PREV-VAR."
-  `(,(car binding) (and ,prev-var ,(cadr binding))))
+  (let ((var (car binding)))
+    (if (and (null (cdr binding)) (atom (car binding)) (not (symbolp (car 
binding))))
+        `(,var (and ,prev-var ,var))
+      `(,var (and ,prev-var ,(cadr binding))))))

(defun internal--build-binding (binding prev-var)
  "Check and build a single BINDING with PREV-VAR."
@@ -122,8 +137,11 @@ if-let*
Each binding is evaluated in turn with `let*', and evaluation
stops if a binding value is nil.  If all are non-nil, the value
of THEN is returned, or the last form in ELSE is returned.
+
Each element of VARLIST is a symbol (which is bound to nil)
or a list (SYMBOL VALUEFORM) (which binds SYMBOL to the value of VALUEFORM).
+An element can additionally be of the form (EXPR), which is
+evaluated and checked for nil.
In the special case you only want to bind a single value,
VARLIST can just be a plain tuple.
\n(fn VARLIST THEN ELSE...)"
@@ -134,27 +152,43 @@ if-let*
             (not (listp (car bindings))))
    ;; Adjust the single binding case
    (setq bindings (list bindings)))
-  `(let* ,(internal--build-bindings bindings)
-     (if ,(car (internal--listify (car (last bindings))))
-         ,then
-       ,@else)))
+  (if bindings
+      `(let* ,(setq bindings (internal--build-bindings bindings))
+         (if ,(caar (last bindings))
+             ,then
+           ,@else))
+    `(let* () ,then)))

(defmacro when-let* (bindings &rest body)
  "Bind variables according to VARLIST and conditionally eval BODY.
Each binding is evaluated in turn with `let*', and evaluation
stops if a binding value is nil.  If all are non-nil, the value
of the last form in BODY is returned.
+
Each element of VARLIST is a symbol (which is bound to nil)
or a list (SYMBOL VALUEFORM) (which binds SYMBOL to the value of VALUEFORM).
+An element can additionally be of the form (EXPR), which is
+evaluated and checked for nil.
In the special case you only want to bind a single value,
VARLIST can just be a plain tuple.
\n(fn VARLIST BODY...)"
-  (declare (indent 1) (debug if-let))
+  (declare (indent 1) (debug if-let*))
  (list 'if-let bindings (macroexp-progn body)))

(defalias 'if-let 'if-let*)
(defalias 'when-let 'when-let*)
-(defalias 'and-let* 'when-let*)
+
+(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
+are non-nil, then the result is non-nil."
+  (declare (indent 1) (debug when-let*))
+  ;; `(when-let* ,varlist ,@(or body '(t)))
+  (if varlist
+      `(let* ,(setq varlist (internal--build-bindings varlist))
+         (if ,(caar (last varlist))
+             ,@(or body `(,(caar (last varlist))))))
+    `(let* () ,@(or body '(t)))))

(defsubst hash-table-empty-p (hash-table)
  "Check whether HASH-TABLE is empty (has 0 elements)."