Sv: [External] : Re: Is this a bug in while-let or do I missunderstand it?

[arthur miller <arthur.miller@live.com>]

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

>IMHO, this is a problem with all of the
>if/and/when/while-let[*] thingies.

Only while-let.

>uses them a lot then she probably knows what
>goes on, in what sequence.  But a priori it's
>not so clear.
>
>This may just mean that the doc needs to take
>pains to be very clear, maybe even with examples
>or by showing a macro expansion explicitly.
>
>Using catch/throw, let[*], and/if/when/while
>together is always _clearer_, IMO.  And it's
>often no more verbose.  Witness all of the

I don't think so. As much as I have understood
if-let, when-let and unique for elisp while-let,
are an "informal formalization", or just a shorthand
for following idiom:

(let ((some-var init-form))
  (if some-var than-form else-form))

Similar for when-let. Consider also a bigger piece
of code, where you have longer let-form, and want
to do some loop:

(let ((var1 init1)
      ...
      (varN initN)
      (loop-invarant init-loop-invariang))

  ....
  (while loop-invariant
    ...)

 ...)

In this context you are leaking loop-invariant in the
entire scope of enclosing let-form, whereas

(let ((var1 init1)
      ...
      (varN initN))

  ....
  (while ((loop-invariant init-loop-invariant))
    ...)

 ...)

limits 'loop-invariant' to the lexical environment
of while loop. You can compare this to pre- C++11
standards where compilers would leak loop invariants
after the scope of the loop:

   for (int i=0; i<10; i++) {
      ...
   }

   i = 2; <-- i visible outside of the for-loop scope

Limiting scope of variables to the lexical scope
where they matter helps to minimize accidental
usages, and also make code easier to read and understand.
________________________________
Från: Drew Adams <drew.adams@oracle.com>
Skickat: den 9 november 2024 19:07
Till: Eli Zaretskii <eliz@gnu.org>; Alfred M. Szmidt <ams@gnu.org>
Kopia: yuri.v.khan@gmail.com <yuri.v.khan@gmail.com>; arthur.miller@live.com <arthur.miller@live.com>; emacs-devel@gnu.org <emacs-devel@gnu.org>
Ämne: RE: [External] : Re: Is this a bug in while-let or do I missunderstand it?

IMHO, this is a problem with all of the
if/and/when/while-let[*] thingies.  If someone
uses them a lot then she probably knows what
goes on, in what sequence.  But a priori it's
not so clear.

This may just mean that the doc needs to take
pains to be very clear, maybe even with examples
or by showing a macro expansion explicitly.

Using catch/throw, let[*], and/if/when/while
together is always _clearer_, IMO.  And it's
often no more verbose.  Witness all of the
discussion about <X>-let* versus <X>-let names
and this current discussion.  The name itself
doesn't clearly tell you what it does... which
is OK, but only if the doc tells you that
clearly.

I'm not saying no one should use, or Elisp
shouldn't provide, if/and/when/while-let[*]
thingies.  I'm just saying (1) I don't find
them helpful, personally (I don't use them),
and (more importantly) (2) if we provide them
then their doc needs to be very specific about
what _exactly_ they do, and when (if not also
how).

[-- Attachment #2: Type: text/html, Size: 11262 bytes --]