Re: Code for cond* - cond*-match, cond*-subpat and backtrack-aliases

[JD Smith <jdtsmith@gmail.com>]

[-- Attachment #1: Type: text/plain, Size: 2361 bytes --]

>>>>  (my-cond
>>>>   (:let var value)
>>>>   (:let dvar (derived-from var))
>>>>   ((has-the-right-stuff-p dvar)
>>>>    (cons 'correct dvar))
>>>> 
>>>>   (:let foo value2)
>>>>   (:let bar (1- foo))
>>>>   ((< bar 0)
>>>>    (cons 'incorrect bar))
>>>> 
>>>>   (t nil))
> 
> On Friday I started looking at something along the same lines.  I sent
> two messages about it.  It has the same features as cond*, using a
> syntax something like the above.

In a separate subthread (and offline) I've been discussing a simple `cond-let', envisioned as part of the if/when-let family (it has no pattern matching capabilities).  It does, as you'd expect, offer local bindings for each clause.

> On Jan 28, 2024, at 10:19 PM, Richard Stallman <rms@gnu.org> wrote:
> 
> Here is the new version.  I made a test framework for it
> and have used that to verify a number of test cases.
> ...
> 
> `(bind* BINDINGS...)' means to bind BINDINGS (as if they were in `let*')
> for the body of the clause.  As a condition, it counts as true
> if the first binding's value is non-nil.  All the bindings are made
> unconditionally for whatever scope they cover.


I wonder why (bind*) evaluates only its first value to determine if the binding condition is true?  We already have macros which evaluate the "truth of a set of bindings": the members of the if-let family.  And they 

"Evaluate each binding in turn, as in ‘let*’, stopping if a binding value is nil.  If all are non-nil return the [final] value."

I would personally find this behavior for variables bound locally within clauses easier to remember and more useful.  Users will already be familiar with it (from if-let), and it supports plain (VALUE) "bindings" for when you'd like to mix actual variable bindings and other tests in a given clause's CONDITION.

Attached is a simple cond-let design (again, just a simple extension of if/when-let, no pattern matching).  You notice that rather than using any particular keyword sigil like :let or bind*, it simply checks if the CONDITION of a clause is a list-of-lists, in which case it is interpreted as a binding spec.  The only small addition to if/when-let's binding handling is for plain (CONDITION-BINDING-SPEC) clauses; in that case, if all binding values are non-nil, the final value is returned from cond-let.



[-- Attachment #2.1: Type: text/html, Size: 6802 bytes --]

[-- Attachment #2.2: cond-let.el --]
[-- Type: application/octet-stream, Size: 2876 bytes --]

;;; cond-let.el --- cond with bindings -*- lexical-binding: t; -*-
;; Copyright (C) 2024 J.D. Smith

;;; Commentary:
;; cond-let is a macro which combines the capabilities of cond with
;; those of if-let.  The structure is the same as a cond: a sequence
;; of (condition body) forms is evaluated one by one, with the first
;; non-nil condition causing the result of its associated body to be
;; returned.  In addition to normal cond-like conditions, cond-let
;; accepts binding-spec conditions which bind variables and test their
;; values, identical to the SPEC lists in if-let.  Example:
;;
;;     (cond-let
;;       ((> x 12) (transform-it x))
;; 
;;       (((var  (other-info x))
;;         (pval (plist-get val :prop))
;;         (     (< pval 99)))
;;        (+ pval x))
;; 
;;       (t 1))
;;
;; Thanks to Stefan Monnier for valuable feedback.
;;; Code:
(require 'seq)
(eval-when-compile 'cl-lib)

(defmacro cond-let (&rest clauses)
  "Try each clause until one succeeds, possibly binding variables within them.
Each of the CLAUSES looks like (CONDITION BODY...), where
CONDITION can be a normal expression, as in `cond', or a binding
spec of the type accepted by `if-let'.  A binding spec is simply
a list of lists of the form:

   ((SYMBOL VALUEFORM) (VALUEFORM) ...)

Note that, just as in `if-let', each element of a binding spec
can take either the form (SYMBOL VALUEFORM) or just (VALUEFORM),
if only the result is of interest.  A binding spec's value is the
value of its last evaluated VALUEFORM, which means that all
values in a binding spec must be non-nil for the associated
clause to succeed.  Each SYMBOL is bound inside subsequent
VALUEFORMs within the same binding spec, as well as in the
associated clause's body (and no other clauses).

The first clause for which CONDITION evaluates to non-nil
succeeds: the expressions in its BODY are evaluated and the last
one's value becomes the value of the `cond-let' form.

If a clause has only one element, as in (CONDITION), then as a
special case `cond-let' returns CONDITION’s value, if that is
non-nil.

If no clause succeeds, `cond-let' returns nil."
  (declare (indent defun)
	   (debug (&rest [&or ((&rest [&or symbolp (symbolp form) (form)]) body)
			      (form body)])))
  (let ((cond-let (gensym "cond-let")))
    `(catch ',cond-let
       ,@(cl-loop
	  for (condition . body) in clauses
	  for clol = (and (consp condition) (consp (cdr condition))
			  (seq-every-p #'consp condition)) ; list-o-lists
	  if body collect
	  `(,(if clol 'when-let* 'when) ,condition
	    (throw ',cond-let ,(macroexp-progn body)))
	  else collect
	  (let ((clc (gensym "cond-let-cond")))
	    `(when-let* ((,clc ,(if clol `(and-let* ,condition) condition)))
	       (throw ',cond-let ,clc)))))))

(provide 'cond-let)
;;; cond-let.el ends here

[-- Attachment #2.3: Type: text/html, Size: 212 bytes --]