unofficial mirror of emacs-devel@gnu.org 
 help / color / mirror / code / Atom feed
* Re: master 8f0f851: * lisp/autoarg.el: Use lexical binding.
       [not found] ` <20200419004504.C65772049B@vcs0.savannah.gnu.org>
@ 2020-04-19  6:18   ` Juanma Barranquero
  2020-04-20  5:10     ` Stefan Kangas
  0 siblings, 1 reply; 23+ messages in thread
From: Juanma Barranquero @ 2020-04-19  6:18 UTC (permalink / raw)
  To: Emacs developers, Stefan Kangas; +Cc: emacs-diffs

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

On Sun, Apr 19, 2020 at 2:45 AM Stefan Kangas <stefankangas@gmail.com>
wrote:
>
> branch: master
> commit 8f0f8516501e64348994334cdab8b211f1cfd731
> Author: Stefan Kangas <stefankangas@gmail.com>
> Commit: Stefan Kangas <stefankangas@gmail.com>
>
>     * lisp/autoarg.el: Use lexical binding.

Compiling file [...]/trunk/lisp/autoarg.el at Sun Apr 19 08:16:38 2020
autoarg.el:61:1: Warning: Unused lexical variable ‘i’

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

^ permalink raw reply	[flat|nested] 23+ messages in thread

* Re: master 8f0f851: * lisp/autoarg.el: Use lexical binding.
  2020-04-19  6:18   ` master 8f0f851: * lisp/autoarg.el: Use lexical binding Juanma Barranquero
@ 2020-04-20  5:10     ` Stefan Kangas
  2020-04-20  5:34       ` Michael Heerdegen
  2020-04-20 13:52       ` Stefan Monnier
  0 siblings, 2 replies; 23+ messages in thread
From: Stefan Kangas @ 2020-04-20  5:10 UTC (permalink / raw)
  To: Juanma Barranquero; +Cc: Emacs developers

Juanma Barranquero <lekktu@gmail.com> writes:

> >     * lisp/autoarg.el: Use lexical binding.
>
> Compiling file [...]/trunk/lisp/autoarg.el at Sun Apr 19 08:16:38 2020
> autoarg.el:61:1: Warning: Unused lexical variable ‘i’

Thanks, should be fixed now.

I don't think I understand the original warning though.  This
minimized code example gives me "Unused lexical variable 'i'" when
byte-compiled:

(let (alist)
  (dotimes (i 10 alist)
    (push i alist)))

Best regards,
Stefan Kangas



^ permalink raw reply	[flat|nested] 23+ messages in thread

* Re: master 8f0f851: * lisp/autoarg.el: Use lexical binding.
  2020-04-20  5:10     ` Stefan Kangas
@ 2020-04-20  5:34       ` Michael Heerdegen
  2020-04-20 11:06         ` Noam Postavsky
  2020-04-20 13:52       ` Stefan Monnier
  1 sibling, 1 reply; 23+ messages in thread
From: Michael Heerdegen @ 2020-04-20  5:34 UTC (permalink / raw)
  To: Stefan Kangas; +Cc: Juanma Barranquero, Emacs developers

Stefan Kangas <stefankangas@gmail.com> writes:

> I don't think I understand the original warning though.  This
> minimized code example gives me "Unused lexical variable 'i'" when
> byte-compiled:
>
> (let (alist)
>   (dotimes (i 10 alist)
>     (push i alist)))

See the FIXME in the implementation.  This exact issue had been
discussed the last time not long ago.

Michael.



^ permalink raw reply	[flat|nested] 23+ messages in thread

* Re: master 8f0f851: * lisp/autoarg.el: Use lexical binding.
  2020-04-20  5:34       ` Michael Heerdegen
@ 2020-04-20 11:06         ` Noam Postavsky
  0 siblings, 0 replies; 23+ messages in thread
From: Noam Postavsky @ 2020-04-20 11:06 UTC (permalink / raw)
  To: Michael Heerdegen; +Cc: Juanma Barranquero, Stefan Kangas, Emacs developers

On Mon, 20 Apr 2020 at 01:35, Michael Heerdegen
<michael_heerdegen@web.de> wrote:
>
> Stefan Kangas <stefankangas@gmail.com> writes:
>
> > I don't think I understand the original warning though.  This
> > minimized code example gives me "Unused lexical variable 'i'" when
> > byte-compiled:
> >
> > (let (alist)
> >   (dotimes (i 10 alist)
> >     (push i alist)))
>
> See the FIXME in the implementation.  This exact issue had been
> discussed the last time not long ago.

Also https://debbugs.gnu.org/39919



^ permalink raw reply	[flat|nested] 23+ messages in thread

* Re: master 8f0f851: * lisp/autoarg.el: Use lexical binding.
  2020-04-20  5:10     ` Stefan Kangas
  2020-04-20  5:34       ` Michael Heerdegen
@ 2020-04-20 13:52       ` Stefan Monnier
  2020-04-20 14:55         ` Drew Adams
  1 sibling, 1 reply; 23+ messages in thread
From: Stefan Monnier @ 2020-04-20 13:52 UTC (permalink / raw)
  To: Stefan Kangas; +Cc: Juanma Barranquero, Emacs developers

> I don't think I understand the original warning though.  This
> minimized code example gives me "Unused lexical variable 'i'" when
> byte-compiled:
>
> (let (alist)
>   (dotimes (i 10 alist)
>     (push i alist)))

It's unused in the expression `alist`.  If you don't use `i` there, then
you should do:

    (let (alist)
      (dotimes (i 10)
        (push i alist))
      alist)


-- Stefan




^ permalink raw reply	[flat|nested] 23+ messages in thread

* RE: master 8f0f851: * lisp/autoarg.el: Use lexical binding.
  2020-04-20 13:52       ` Stefan Monnier
@ 2020-04-20 14:55         ` Drew Adams
  2020-04-20 16:32           ` Stefan Monnier
  0 siblings, 1 reply; 23+ messages in thread
From: Drew Adams @ 2020-04-20 14:55 UTC (permalink / raw)
  To: Stefan Monnier, Stefan Kangas; +Cc: Juanma Barranquero, Emacs developers

> > I don't think I understand the original warning though.

Same here.

> > This minimized code example gives me "Unused lexical
> > variable 'i'" when byte-compiled:
> >
> > (let (alist)
> >   (dotimes (i 10 alist) (push i alist)))
> 
> It's unused in the expression `alist`.

So?  (defun foo (a) (message "%s" a) 42) doesn't use
`a' in the value returned.  We don't warn about that,
do we?

> If you don't use `i` there, then you should do:
> (let (alist)
>   (dotimes (i 10) (push i alist))
>   alist)

Doesn't seem right to have such a distinction.  Is
this just an implementation artifact (essentially a
bug), or is there a good reason for the warning in
the first case (and not in the second)?

FWIW, all that Common Lisp says about its `dotimes'
in this regard is this:

"At the time result-form is processed, VAR is bound
to the number of times the body was executed."

Why should we warn, if the result form doesn't use
the variable?



^ permalink raw reply	[flat|nested] 23+ messages in thread

* Re: master 8f0f851: * lisp/autoarg.el: Use lexical binding.
  2020-04-20 14:55         ` Drew Adams
@ 2020-04-20 16:32           ` Stefan Monnier
  2020-04-28  2:14             ` Michael Heerdegen
  0 siblings, 1 reply; 23+ messages in thread
From: Stefan Monnier @ 2020-04-20 16:32 UTC (permalink / raw)
  To: Drew Adams; +Cc: Juanma Barranquero, Stefan Kangas, Emacs developers

>> If you don't use `i` there, then you should do:
>> (let (alist)
>>   (dotimes (i 10) (push i alist))
>>   alist)
>
> Doesn't seem right to have such a distinction.

It does seem right to me (probably because I find hiding the return
value inside the first arg to `dotimes` to be a bad practice).

> Is this just an implementation artifact

It's mostly an implementation artifact, but one which I think happens to
be good.


        Stefan




^ permalink raw reply	[flat|nested] 23+ messages in thread

* Re: master 8f0f851: * lisp/autoarg.el: Use lexical binding.
  2020-04-20 16:32           ` Stefan Monnier
@ 2020-04-28  2:14             ` Michael Heerdegen
  2020-04-28  2:59               ` Strange compiler warning in `dotimes' (was: master 8f0f851: * lisp/autoarg.el: Use lexical binding.) Michael Heerdegen
  2020-04-28 15:32               ` master 8f0f851: * lisp/autoarg.el: Use lexical binding Drew Adams
  0 siblings, 2 replies; 23+ messages in thread
From: Michael Heerdegen @ 2020-04-28  2:14 UTC (permalink / raw)
  To: Stefan Monnier
  Cc: Juanma Barranquero, Stefan Kangas, Drew Adams, Emacs developers

Stefan Monnier <monnier@iro.umontreal.ca> writes:

> > Is this just an implementation artifact
>
> It's mostly an implementation artifact, but one which I think happens
> to be good.

The bad thing is that most people don't understand why that happens and
are just confused and wasting time.

Since RESULT is deprecated anyway, and there were no strong opinions
against that, I would like to turn that warning into a warning that
always happens when you use RESULT saying "warning: argument RESULT in
dotimes is deprecated" or so.

The only other reasonable alternative I see is to fix the warning.  What
we now have shouldn't be the end state.

FWIW, personally I never liked that RESULT argument, I find it odd no
matter if it depends on the iteration var or not.

Michael.



^ permalink raw reply	[flat|nested] 23+ messages in thread

* Strange compiler warning in `dotimes' (was: master 8f0f851: * lisp/autoarg.el: Use lexical binding.)
  2020-04-28  2:14             ` Michael Heerdegen
@ 2020-04-28  2:59               ` Michael Heerdegen
  2020-04-28 15:32               ` master 8f0f851: * lisp/autoarg.el: Use lexical binding Drew Adams
  1 sibling, 0 replies; 23+ messages in thread
From: Michael Heerdegen @ 2020-04-28  2:59 UTC (permalink / raw)
  To: emacs-devel

Michael Heerdegen <michael_heerdegen@web.de> writes:

> The bad thing is that most people don't understand why that happens
> and are just confused and wasting time.

I have merged the recent Bug#39919 "Incorrect byte-compiler warning"
with the respective bugs from the past (hope I did it right) - the
merged report is probably a better place to continue discussing than
here.

Michael.




^ permalink raw reply	[flat|nested] 23+ messages in thread

* RE: master 8f0f851: * lisp/autoarg.el: Use lexical binding.
  2020-04-28  2:14             ` Michael Heerdegen
  2020-04-28  2:59               ` Strange compiler warning in `dotimes' (was: master 8f0f851: * lisp/autoarg.el: Use lexical binding.) Michael Heerdegen
@ 2020-04-28 15:32               ` Drew Adams
  2020-04-29  0:53                 ` Michael Heerdegen
                                   ` (2 more replies)
  1 sibling, 3 replies; 23+ messages in thread
From: Drew Adams @ 2020-04-28 15:32 UTC (permalink / raw)
  To: Michael Heerdegen, Stefan Monnier
  Cc: Juanma Barranquero, Stefan Kangas, Emacs developers

> Since RESULT is deprecated anyway, and there were no strong opinions
> against that, I would like to turn that warning into a warning that
> always happens when you use RESULT saying "warning: argument RESULT in
> dotimes is deprecated" or so.

Why was RESULT deprecated?

RESULT is good enough for Common Lisp.  Why isn't
it good enough for Elisp?  Just curious.

http://clhs.lisp.se/Body/m_dotime.htm



^ permalink raw reply	[flat|nested] 23+ messages in thread

* Re: master 8f0f851: * lisp/autoarg.el: Use lexical binding.
  2020-04-28 15:32               ` master 8f0f851: * lisp/autoarg.el: Use lexical binding Drew Adams
@ 2020-04-29  0:53                 ` Michael Heerdegen
  2020-04-29  0:59                   ` Drew Adams
  2020-04-29  2:31                 ` Vladimir Sedach
  2020-04-29  3:53                 ` Stefan Monnier
  2 siblings, 1 reply; 23+ messages in thread
From: Michael Heerdegen @ 2020-04-29  0:53 UTC (permalink / raw)
  To: emacs-devel

Drew Adams <drew.adams@oracle.com> writes:

> Why was RESULT deprecated?
>
> RESULT is good enough for Common Lisp.  Why isn't
> it good enough for Elisp?  Just curious.

See the discussion in Bug#16206.

Michael.




^ permalink raw reply	[flat|nested] 23+ messages in thread

* RE: master 8f0f851: * lisp/autoarg.el: Use lexical binding.
  2020-04-29  0:53                 ` Michael Heerdegen
@ 2020-04-29  0:59                   ` Drew Adams
  2020-04-29  1:13                     ` Michael Heerdegen
  0 siblings, 1 reply; 23+ messages in thread
From: Drew Adams @ 2020-04-29  0:59 UTC (permalink / raw)
  To: Michael Heerdegen, emacs-devel

> > Why was RESULT deprecated?
> >
> > RESULT is good enough for Common Lisp.  Why isn't
> > it good enough for Elisp?  Just curious.
> 
> See the discussion in Bug#16206.

I saw it.  I still have the same question.



^ permalink raw reply	[flat|nested] 23+ messages in thread

* Re: master 8f0f851: * lisp/autoarg.el: Use lexical binding.
  2020-04-29  0:59                   ` Drew Adams
@ 2020-04-29  1:13                     ` Michael Heerdegen
  2020-04-29  1:23                       ` Drew Adams
  0 siblings, 1 reply; 23+ messages in thread
From: Michael Heerdegen @ 2020-04-29  1:13 UTC (permalink / raw)
  To: Drew Adams; +Cc: emacs-devel

Drew Adams <drew.adams@oracle.com> writes:

> > > RESULT is good enough for Common Lisp.  Why isn't
> > > it good enough for Elisp?  Just curious.
> >
> > See the discussion in Bug#16206.
>
> I saw it.  I still have the same question.

Some people argued that RESULT is not so useful, and it's position in
the syntax is strange, and seems nobody really found this totally wrong.

BTW, in the discussion in said bug report we now found the idea to
always warn about using the RESULT argument in subr.el's dotimes (in
order to remove it later) and fix the warning in cl-dotimes.

Michael.



^ permalink raw reply	[flat|nested] 23+ messages in thread

* RE: master 8f0f851: * lisp/autoarg.el: Use lexical binding.
  2020-04-29  1:13                     ` Michael Heerdegen
@ 2020-04-29  1:23                       ` Drew Adams
  0 siblings, 0 replies; 23+ messages in thread
From: Drew Adams @ 2020-04-29  1:23 UTC (permalink / raw)
  To: Michael Heerdegen; +Cc: emacs-devel

> Some people argued that RESULT is not so useful, and it's position in
> the syntax is strange, and seems nobody really found this totally
> wrong.
> 
> BTW, in the discussion in said bug report we now found the idea to
> always warn about using the RESULT argument in subr.el's dotimes (in
> order to remove it later) and fix the warning in cl-dotimes.

Perhaps the difference in usefulness has to
do with other differences between dotimes
and cl-dotimes.  Perhaps the RETURN arg is
more useful in combination with go tags,
for instance.  Dunno.



^ permalink raw reply	[flat|nested] 23+ messages in thread

* Re: master 8f0f851: * lisp/autoarg.el: Use lexical binding.
  2020-04-28 15:32               ` master 8f0f851: * lisp/autoarg.el: Use lexical binding Drew Adams
  2020-04-29  0:53                 ` Michael Heerdegen
@ 2020-04-29  2:31                 ` Vladimir Sedach
  2020-04-29  3:58                   ` Michael Heerdegen
                                     ` (3 more replies)
  2020-04-29  3:53                 ` Stefan Monnier
  2 siblings, 4 replies; 23+ messages in thread
From: Vladimir Sedach @ 2020-04-29  2:31 UTC (permalink / raw)
  To: Drew Adams
  Cc: Michael Heerdegen, Juanma Barranquero, emacs-devel,
	Stefan Monnier, Stefan Kangas


Drew Adams <drew.adams@oracle.com> writes:
> Why was RESULT deprecated?

That is indeed bizarre. Why break existing Elisp code? David
Touretzky provides lots of examples of how to use RESULT with DOTIMES
and DOLIST in _Common Lisp: A Gentle Introduction_. Conceptually,
RESULT is a neat way to have the DOLIST/DOTIMES/DO expression
evaluate to a useful value, instead of always being nil valued.
Deprecating RESULT makes it harder to port Common Lisp code to Elisp.

Those are four good arguments for keeping it.

--
Vladimir Sedach
Software engineering services in Los Angeles https://oneofus.la



^ permalink raw reply	[flat|nested] 23+ messages in thread

* Re: master 8f0f851: * lisp/autoarg.el: Use lexical binding.
  2020-04-28 15:32               ` master 8f0f851: * lisp/autoarg.el: Use lexical binding Drew Adams
  2020-04-29  0:53                 ` Michael Heerdegen
  2020-04-29  2:31                 ` Vladimir Sedach
@ 2020-04-29  3:53                 ` Stefan Monnier
  2 siblings, 0 replies; 23+ messages in thread
From: Stefan Monnier @ 2020-04-29  3:53 UTC (permalink / raw)
  To: Drew Adams
  Cc: Michael Heerdegen, Juanma Barranquero, Stefan Kangas,
	Emacs developers

> RESULT is good enough for Common Lisp.  Why isn't
> it good enough for Elisp?  Just curious.

I think the question makes no sense.  Noone said it's not "good enough
for Elisp" because noone is suggesting to make it better.


        Stefan




^ permalink raw reply	[flat|nested] 23+ messages in thread

* Re: master 8f0f851: * lisp/autoarg.el: Use lexical binding.
  2020-04-29  2:31                 ` Vladimir Sedach
@ 2020-04-29  3:58                   ` Michael Heerdegen
  2020-04-29  4:21                     ` Stefan Monnier
  2020-04-29 18:33                     ` Vladimir Sedach
  2020-04-29  4:02                   ` Stefan Monnier
                                     ` (2 subsequent siblings)
  3 siblings, 2 replies; 23+ messages in thread
From: Michael Heerdegen @ 2020-04-29  3:58 UTC (permalink / raw)
  To: Vladimir Sedach
  Cc: Juanma Barranquero, emacs-devel, Stefan Monnier, Drew Adams,
	Stefan Kangas

Vladimir Sedach <vas@oneofus.la> writes:

> Touretzky provides lots of examples of how to use RESULT with DOTIMES
> and DOLIST in _Common Lisp: A Gentle Introduction_. Conceptually,
> RESULT is a neat way to have the DOLIST/DOTIMES/DO expression

Some of us don't find it neat.

Are there examples in that book that aren't easily rewritten without the
RESULT arg, and/or the skeptical people here would say ah! that's really
neat and elegant?

Do you often use it, personally?

> Deprecating RESULT makes it harder to port Common Lisp code to Elisp.

As I said, I would make the cl- version support it.  I don't expect that
code is very frequently ported from Common Lisp to Elisp.  But AFAIR
scheme also has RESULT in its `do', so people coming from other Lisps
might miss it.  I don't know any Lisp programmers, I can't say.

Michael.



^ permalink raw reply	[flat|nested] 23+ messages in thread

* Re: master 8f0f851: * lisp/autoarg.el: Use lexical binding.
  2020-04-29  2:31                 ` Vladimir Sedach
  2020-04-29  3:58                   ` Michael Heerdegen
@ 2020-04-29  4:02                   ` Stefan Monnier
  2020-04-29 15:05                   ` Noam Postavsky
  2020-04-30  2:26                   ` Richard Stallman
  3 siblings, 0 replies; 23+ messages in thread
From: Stefan Monnier @ 2020-04-29  4:02 UTC (permalink / raw)
  To: Vladimir Sedach
  Cc: Michael Heerdegen, Juanma Barranquero, Stefan Kangas, Drew Adams,
	emacs-devel

> Conceptually, RESULT is a neat way to have the DOLIST/DOTIMES/DO
> expression evaluate to a useful value,

It's not.  Putting the return value right after (wrapping the two in
a `progn` if needed) is a much neater solution, which is also visually
much better at clarifying what is returned.

The only potential usefulness of the RETURN part is to get access to the
"after-last" value of the iteration variable (which is the only
concrete difference between using RESULT or placing the result as
a separate expression after the iteration).

> Deprecating RESULT makes it harder to port Common Lisp code to Elisp.

I have tried to port a few Common Lisp codes to Elisp, and this kind of
syntactic rewrite is so trivial to handle (and the dotimes/dolist macros
could even tell you how to do them) that it doesn't even register in
comparison to the much harder work of dealing with library differences,
packages, reader macros, ...


        Stefan




^ permalink raw reply	[flat|nested] 23+ messages in thread

* Re: master 8f0f851: * lisp/autoarg.el: Use lexical binding.
  2020-04-29  3:58                   ` Michael Heerdegen
@ 2020-04-29  4:21                     ` Stefan Monnier
  2020-04-29 18:33                     ` Vladimir Sedach
  1 sibling, 0 replies; 23+ messages in thread
From: Stefan Monnier @ 2020-04-29  4:21 UTC (permalink / raw)
  To: Michael Heerdegen
  Cc: Juanma Barranquero, emacs-devel, Drew Adams, Stefan Kangas

> But AFAIR scheme also has RESULT in its `do', so people coming from
> other Lisps might miss it.

This one is quite different because it has access to the final value
of all the loop variables.  So while it is occasionally possible to move
the "RESULT" expression to after the `do` loop, it's often not an option
because it needs to access some of the loop variables.

For `dolist` this can *never* happen because the only loop variable is
known to always contain nil at that point.

For `dotimes` this can very occasionally happen, tho you can always work
around it with a simple rewrite.


        Stefan




^ permalink raw reply	[flat|nested] 23+ messages in thread

* Re: master 8f0f851: * lisp/autoarg.el: Use lexical binding.
  2020-04-29  2:31                 ` Vladimir Sedach
  2020-04-29  3:58                   ` Michael Heerdegen
  2020-04-29  4:02                   ` Stefan Monnier
@ 2020-04-29 15:05                   ` Noam Postavsky
  2020-04-30  2:26                   ` Richard Stallman
  3 siblings, 0 replies; 23+ messages in thread
From: Noam Postavsky @ 2020-04-29 15:05 UTC (permalink / raw)
  To: Vladimir Sedach
  Cc: Michael Heerdegen, Juanma Barranquero, Emacs developers,
	Stefan Kangas, Drew Adams, Stefan Monnier

On Tue, 28 Apr 2020 at 22:35, Vladimir Sedach <vas@oneofus.la> wrote:

> Drew Adams <drew.adams@oracle.com> writes:
> > Why was RESULT deprecated?
>
> That is indeed bizarre. Why break existing Elisp code? David
> Touretzky provides lots of examples of how to use RESULT with DOTIMES
> and DOLIST in _Common Lisp: A Gentle Introduction_.

I think it's useful to look at a couple of concrete examples from
there. I found it at <https://www.cs.cmu.edu/~dst/LispBook/book.pdf>.
There is this kind of usage (page 345):

    (defun it-intersection (x y)
      (let ((result-set nil))
        (dolist (element x result-set)
          (when (member element y)
            (push element result-set)))))

The argument for deprecating the RESULT param is mainly because code
like this is (arguably) clearer when written

    (defun it-intersection (x y)
      (let ((result-set nil))
        (dolist (element x)
          (when (member element y)
            (push element result-set)))
        result-set))

Because it's easier to quickly pick out what the return value is.
Obviously it's a matter of taste to some degree though.

There's another kind of usage that isn't as easily replaced (page 343):

    (defun check-all-odd (list-of-numbers)
      (dolist (e list-of-numbers t)
        (format t "~&Checking ~S..." e)
        (if (not (oddp e)) (return nil))))

But this relies on dolist establishing a block that be used with
return. So in elisp, this should be done with cl-dolist which I
believe everyone agrees will always support the RESULT argument.



^ permalink raw reply	[flat|nested] 23+ messages in thread

* Re: master 8f0f851: * lisp/autoarg.el: Use lexical binding.
  2020-04-29  3:58                   ` Michael Heerdegen
  2020-04-29  4:21                     ` Stefan Monnier
@ 2020-04-29 18:33                     ` Vladimir Sedach
  1 sibling, 0 replies; 23+ messages in thread
From: Vladimir Sedach @ 2020-04-29 18:33 UTC (permalink / raw)
  To: Michael Heerdegen
  Cc: Juanma Barranquero, emacs-devel, Stefan Monnier, Drew Adams,
	Stefan Kangas


Michael Heerdegen <michael_heerdegen@web.de> writes:
> I don't know any Lisp programmers, I can't say.

Well, you are replying to one. I program regularly in Common Lisp and
Elisp, and occasionally in Scheme. Most of the Elisp code I write is
"ported" from Common Lisp, because that is the Lisp dialect I am most
familiar with, and "think" in. Obviously I make occasional use
RESULTS in DOLIST/DOTIMES/DO/DO*, otherwise I would not have an
opinion about it.

--
Vladimir Sedach
Software engineering services in Los Angeles https://oneofus.la



^ permalink raw reply	[flat|nested] 23+ messages in thread

* Re: master 8f0f851: * lisp/autoarg.el: Use lexical binding.
  2020-04-29  2:31                 ` Vladimir Sedach
                                     ` (2 preceding siblings ...)
  2020-04-29 15:05                   ` Noam Postavsky
@ 2020-04-30  2:26                   ` Richard Stallman
  2020-05-16  3:21                     ` Michael Heerdegen
  3 siblings, 1 reply; 23+ messages in thread
From: Richard Stallman @ 2020-04-30  2:26 UTC (permalink / raw)
  To: Vladimir Sedach
  Cc: michael_heerdegen, lekktu, emacs-devel, stefankangas, drew.adams,
	monnier

[[[ To any NSA and FBI agents reading my email: please consider    ]]]
[[[ whether defending the US Constitution against all enemies,     ]]]
[[[ foreign or domestic, requires you to follow Snowden's example. ]]]

It would take a strong reason justify introducing an incompatibility
which breaks code.  The reasons people have stated here might be enough
reason not to introduce the RESULT argument, but they are not enough
reason to remove it.

-- 
Dr Richard Stallman
Chief GNUisance of the GNU Project (https://gnu.org)
Founder, Free Software Foundation (https://fsf.org)
Internet Hall-of-Famer (https://internethalloffame.org)





^ permalink raw reply	[flat|nested] 23+ messages in thread

* Re: master 8f0f851: * lisp/autoarg.el: Use lexical binding.
  2020-04-30  2:26                   ` Richard Stallman
@ 2020-05-16  3:21                     ` Michael Heerdegen
  0 siblings, 0 replies; 23+ messages in thread
From: Michael Heerdegen @ 2020-05-16  3:21 UTC (permalink / raw)
  To: Richard Stallman; +Cc: lekktu, emacs-devel, monnier, drew.adams, stefankangas

Richard Stallman <rms@gnu.org> writes:

> It would take a strong reason justify introducing an incompatibility
> which breaks code.  The reasons people have stated here might be
> enough reason not to introduce the RESULT argument, but they are not
> enough reason to remove it.

And just the fact of how often the question about the warning popped up
in the last weeks shows that quite some people want to use the RESULT
argument.

So I see no alternative but to fix the warning and undeprecate the
RESULT argument.  I will do this shortly if there are no objections.

Michael.



^ permalink raw reply	[flat|nested] 23+ messages in thread

end of thread, other threads:[~2020-05-16  3:21 UTC | newest]

Thread overview: 23+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
     [not found] <20200419004503.26161.91884@vcs0.savannah.gnu.org>
     [not found] ` <20200419004504.C65772049B@vcs0.savannah.gnu.org>
2020-04-19  6:18   ` master 8f0f851: * lisp/autoarg.el: Use lexical binding Juanma Barranquero
2020-04-20  5:10     ` Stefan Kangas
2020-04-20  5:34       ` Michael Heerdegen
2020-04-20 11:06         ` Noam Postavsky
2020-04-20 13:52       ` Stefan Monnier
2020-04-20 14:55         ` Drew Adams
2020-04-20 16:32           ` Stefan Monnier
2020-04-28  2:14             ` Michael Heerdegen
2020-04-28  2:59               ` Strange compiler warning in `dotimes' (was: master 8f0f851: * lisp/autoarg.el: Use lexical binding.) Michael Heerdegen
2020-04-28 15:32               ` master 8f0f851: * lisp/autoarg.el: Use lexical binding Drew Adams
2020-04-29  0:53                 ` Michael Heerdegen
2020-04-29  0:59                   ` Drew Adams
2020-04-29  1:13                     ` Michael Heerdegen
2020-04-29  1:23                       ` Drew Adams
2020-04-29  2:31                 ` Vladimir Sedach
2020-04-29  3:58                   ` Michael Heerdegen
2020-04-29  4:21                     ` Stefan Monnier
2020-04-29 18:33                     ` Vladimir Sedach
2020-04-29  4:02                   ` Stefan Monnier
2020-04-29 15:05                   ` Noam Postavsky
2020-04-30  2:26                   ` Richard Stallman
2020-05-16  3:21                     ` Michael Heerdegen
2020-04-29  3:53                 ` Stefan Monnier

Code repositories for project(s) associated with this public inbox

	https://git.savannah.gnu.org/cgit/emacs.git

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).