bug#66756: 30.0.50; [PATCH] Improve discussion of 'let' in Elisp Introduction manual

[Jim Porter]

Thanks for taking a look, Eli. Just a few questions/thoughts on some of 
your comments. (I trimmed the others since I'll probably rework the 
other sections based on how we handle the second part below.)

On 11/23/2023 11:06 PM, Eli Zaretskii wrote:
> FWIW, I find the use of "overshadows" in the original text to be
> better than the "overrides" in the new text.  This is partly because
> the meaning of "override" is not clear when talking about the use of a
> name, and partly because "override" is really inaccurate here.  If we
> are not happy with the original text, then we need to find something
> else, IMO, perhaps a more detailed description.

Maybe we should just leave it as is for now? I don't think it's strictly 
necessary to change that sentence for the rest of the patch to make 
sense. We could always improve it in a follow up.

(Or if someone has the perfect phrase to use here, I'll happily make the 
change. I just don't want the patch to get bogged down by changes that 
are merely *near* the parts I'm working on.)

> > +As we discussed before, under lexical binding, @code{let} defines a
> > +@emph{place} in your code where the variables have their own local
> > +meaning.  Under dynamic binding, the rules are different: instead, you
> > +are defining a @emph{time} in your code when the variables have their
> > +own local meaning.
>
> If this wants to explain the difference between compile-time and
> run-time binding, then perhaps it should say so, instead of talking
> about the confusing "place where" vs "time when" the value changes?
> And if compile-time is problematic (Emacs being an interpreter), then
> we should find another description, one that doesn't use confusing
> concept of "place".

I'm open to other wordings, but I wanted to describe what's going on 
without getting into the details of the interpreter or how it evaluates 
the code. The "place" is supposed to refer to the actual body of the 
'let' form. That's described in the first part I changed. However, the 
"time" description could probably be expanded.

Maybe we could contrast "within the body of the let expression" vs 
"during execution of the let expression"? That gets across the idea to 
me that the former is about compile-time ("body" refers to the actual 
Lisp form), while the latter is about run-time ("execution").