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

[JD Smith]

 (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.

cond-let.el
Description: Binary data