Idempotency of add-hook wrt lambda expressions

Idempotency of add-hook wrt lambda expressions

[Geoff Gole]

Say a file contains an add-hook form with a lambda argument:

  (add-hook 'foo-mode (lambda () (bar)))

Annoyingly, the function will be added to the hook twice if the file
is byte compiled, loaded, then reevaluated (such as with eval-buffer).
This can be worked around in any number of ways (don't byte compile,
don't use lambdas in hooks, restart emacs on every change), but I
wonder if add-hook can be made to do the right thing. One way is to
change the hook membership test from:

  (member function hook-value)

to something like

  (ignore-errors
    (let ((bc-function (byte-compile function)))
      (or (member function hook-value)
	  (member bc-function hook-value))))

But that's pretty horrible. In any case, if there is no fix shouldn't
this wrinkle be mentioned in the add-hook docstring?

Re: Idempotency of add-hook wrt lambda expressions

[Stefan Monnier]

> Say a file contains an add-hook form with a lambda argument:
>   (add-hook 'foo-mode (lambda () (bar)))
> Annoyingly, the function will be added to the hook twice if the file
> is byte compiled, loaded, then reevaluated (such as with eval-buffer).

As a general rule, you should not put a lambda but a function name
(i.e. a symbol) instead, to avoid all those problems (and be able to
replace the function with a newer version of it).  But occasionally
a lambda is really exactly what you want, of course.


        Stefan

Re: Idempotency of add-hook wrt lambda expressions

[xah lee]

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

On Wed, Mar 4, 2009 at 6:18 AM, Stefan Monnier <monnier@iro.umontreal.ca>wrote:

> > Say a file contains an add-hook form with a lambda argument:
> >   (add-hook 'foo-mode (lambda () (bar)))
> > Annoyingly, the function will be added to the hook twice if the file
> > is byte compiled, loaded, then reevaluated (such as with eval-buffer).
>
> As a general rule, you should not put a lambda but a function name
> (i.e. a symbol) instead, to avoid all those problems (and be able to
> replace the function with a newer version of it).  But occasionally
> a lambda is really exactly what you want, of course.
>

i prefer this be transparent to the user as Geoff Gole suggested.

My reason is that from a user point of view, lambda serves the same purpose
as function name, and one less thing to worry about problems that might come
from byte compiling.

if the code suggested does fix this without any other problems,  why not?

cheers,

  Xah

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

Re: Idempotency of add-hook wrt lambda expressions

[Stefan Monnier]

> if the code suggested does fix this without any other problems, why not?

Because it's a hack.  So it takes care of 80% of the cases but still
doesn't fix the remaining cases.  Fixing the remaining cases requires
using a symbol, so just use a symbol and get on with your life.
I'd much rather add a patch that complains when you pass a lambda to
add-hook.


        Stefan

Re: Idempotency of add-hook wrt lambda expressions

[Lennart Borgman]

On Wed, Mar 4, 2009 at 10:23 PM, Stefan Monnier
<monnier@iro.umontreal.ca> wrote:
>> if the code suggested does fix this without any other problems, why not?
>
> Because it's a hack.  So it takes care of 80% of the cases but still
> doesn't fix the remaining cases.  Fixing the remaining cases requires
> using a symbol, so just use a symbol and get on with your life.
> I'd much rather add a patch that complains when you pass a lambda to
> add-hook.

Please do and do the same for menus. This would make it much easier to
search for errors.

Re: Idempotency of add-hook wrt lambda expressions

[M Jared Finder]

Lennart Borgman wrote:
> On Wed, Mar 4, 2009 at 10:23 PM, Stefan Monnier
> <monnier@iro.umontreal.ca> wrote:
>>> if the code suggested does fix this without any other problems, why not?
>> Because it's a hack.  So it takes care of 80% of the cases but still
>> doesn't fix the remaining cases.  Fixing the remaining cases requires
>> using a symbol, so just use a symbol and get on with your life.
>> I'd much rather add a patch that complains when you pass a lambda to
>> add-hook.
> 
> Please do and do the same for menus. This would make it much easier to
> search for errors.
> 
> 
> 

I'm a user of Emacs and have created the following macro for my usage. 
I've been using it since Emacs 21.3 with no issues.  Maybe it'd be 
useful to add to Emacs?

   -- MJF

;;; Used like this:
;;;
;;; (hook-mode c-mode-common-hook
;;;   c-subword-mode
;;;  (c-set-offset 'case-label '+)
;;;  (setf (local-key-binding (kbd "C-c M-<right>"))
;;;        'c-forward-conditional
;;         (local-key-binding (kbd "C-c M-<left>"))
;;         'c-backward-conditional))

(defmacro hook-mode (hook &body modes)
   "Hook each member of MODES on HOOK.  If the member is a symbol,
call (member 1); if it is a list, just execute it directly.

This allows you to declaratively hook in minor modes on a major mode."
   (let ((body (loop for expr in modes
                     if (and (symbolp expr) (fboundp expr))
                       collect (list expr 1)
                     else if (listp expr)
                       collect expr
                     else do (error "%s does not appear to name a minor 
mode." expr))))
     `(hook-mode-attach ',hook (lambda () "Auto-generated by `hook-mode'"
                                       ,@body))))

(defvar hook-mode-*hooks* (make-hash-table :test #'eq))
(defun hook-mode-attach (hook function)
   (when (gethash hook hook-mode-*hooks*)
     (remove-hook hook (gethash hook hook-mode-*hooks*)))
   (add-hook hook function)
   (setf (gethash hook hook-mode-*hooks*) function))

Re: Idempotency of add-hook wrt lambda expressions

[David Reitter]

On 4 Mar 2009, at 09:18, Stefan Monnier wrote:

> As a general rule, you should not put a lambda but a function name
> (i.e. a symbol) instead, to avoid all those problems (and be able to
> replace the function with a newer version of it).  But occasionally
> a lambda is really exactly what you want, of course.


People haven't adopted this, and this is pretty annoying.

A similar case are commands bound to menu items (or any other keys): C- 
h k does not bring up something useful for keys that are just bound to  
a lambda term.

As for hooks, is a lambda expression ever suitable to be added to a  
hook?
Would it make sense to change add-hook such that only true function  
names are allowed?

Re: Idempotency of add-hook wrt lambda expressions

[Stephen J. Turnbull]

David Reitter writes:

 > On 4 Mar 2009, at 09:18, Stefan Monnier wrote:
 > 
 > > As a general rule, you should not put a lambda but a function name
 > > (i.e. a symbol) instead, to avoid all those problems (and be able to
 > > replace the function with a newer version of it).  But occasionally
 > > a lambda is really exactly what you want, of course.

 > People haven't adopted this, and this is pretty annoying.
 > 
 > A similar case are commands bound to menu items (or any other keys): C- 
 > h k does not bring up something useful for keys that are just bound to  
 > a lambda term.
 > 
 > As for hooks, is a lambda expression ever suitable to be added to a  
 > hook?
 > Would it make sense to change add-hook such that only true function  
 > names are allowed?

In all these cases the problem that you consistently run into is that
Emacs Lisp doesn't have namespaces/packages.  It's very common to want
to make a small tweak to a command's default arguments when it's used
as a hook or menu item, and adding more symbols for that just feels
wrong.  Not to mention getting in the way of completion.

lambdas may have docstrings, and probably things like C-h k would find
them if provided.  Hm, easy enough to check:

  (define-key global-map [(control c) z]
              (lambda () "Found doc!" (interactive) (message "yowza")))

C-h k C-c z ==>
C-c z runs (lambda nil Found doc! (interactive) (message yowza))

Found doc!

So the obvious workaround is to report a bug if a lambda in a menu
item doesn't have a docstring.  Maybe there should be a describe-hook
help function that returns a buffer like

----------------------------------------------------------------
foo-hook runs, in this order:

1. default-foo-hook-function
Drink foo in bar.

2. (lambda ...)
Call auxiliary-foo-hook-function with argument "hair of dog".
----------------------------------------------------------------

Re: Idempotency of add-hook wrt lambda expressions

[Stefan Monnier]

> A similar case are commands bound to menu items (or any other keys): C-
> h k does not bring up something useful for keys that are just bound to
> a lambda term.

C-h k does give useful info, provided the lambda term has a docstring.
Just as is the case for symbols.


        Stefan

Re: Idempotency of add-hook wrt lambda expressions

[Geoff Gole]

> I'd much rather add a patch that complains when you pass a lambda to
add-hook.

Sounds good to me.

Re: Idempotency of add-hook wrt lambda expressions

[David Kastrup]

Geoff Gole <geoffgole@gmail.com> writes:

>> I'd much rather add a patch that complains when you pass a lambda to
> add-hook.
>
> Sounds good to me.

Does not jibe with existing practise.

For example, (info "(emacs) Init Examples") carefully explains

   * Turn on Auto Fill mode automatically in Text mode and related
     modes.

          (add-hook 'text-mode-hook
            '(lambda () (auto-fill-mode 1)))

     This shows how to add a hook function to a normal hook variable
     (*note Hooks::).  The function we supply is a list starting with
     `lambda', with a single-quote in front of it to make it a list
     constant rather than an expression.

     It's beyond the scope of this manual to explain Lisp functions,
     but for this example it is enough to know that the effect is to
     execute `(auto-fill-mode 1)' when Text mode is entered.  You can
     replace that with any other expression that you like, or with
     several expressions in a row.

Sure, you can "fix" the manual here.  But you can't expect that the real
world has never used an idiom explicitly documented and used as an
example.

Also, in some cases you can't avoid lambda, namely when using computed
functions.

-- 
David Kastrup

Re: Idempotency of add-hook wrt lambda expressions

[tomas]

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

On Thu, Mar 05, 2009 at 10:49:14AM +0100, David Kastrup wrote:

[...]

> Also, in some cases you can't avoid lambda, namely when using computed
> functions.

Yes, and one particularly useful example would be "poor-man's currying",
where you want to use the same function with slight variations in
bindings.

Regards
- -- tomás
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.6 (GNU/Linux)

iD8DBQFJr7p0Bcgs9XrR2kYRAktQAJ9tApSRFowHTetKEtZ02g6e2u1o4gCffDP/
GsXiJd4jAChs/oMEb4dlqww=
=IX1U
-----END PGP SIGNATURE-----

Re: Idempotency of add-hook wrt lambda expressions

[Geoff Gole]

> Also, in some cases you can't avoid lambda, namely when using computed
> functions.

Can't you avoid this with (add-hook 'hook (progn (fset symbol
calculated-definition) symbol)) or similar?

Re: Idempotency of add-hook wrt lambda expressions

[Alan Mackenzie]

On Thu, Mar 05, 2009 at 08:53:23PM +0900, Geoff Gole wrote:
> > Also, in some cases you can't avoid lambda, namely when using computed
> > functions.

> Can't you avoid this with (add-hook 'hook (progn (fset symbol
> calculated-definition) symbol)) or similar?

Probably, yes.  But who'd want to?

One of the reasons for using a lambda is to save having to think up a
function name, and to save cluttering up one's .emacs, or whatever.
Compare

    (add-hook 'foo-mode-hook (lambda (some-minor-mode 1)))

with

    (defun switch-some-minor-mode-on ()
      (some-minor-mode 1))
    (add-hook 'foo-mode-hook 'switch-some-minor-mode-on)

.

-- 
Alan Mackenzie (Nuremberg, Germany).

Re: Idempotency of add-hook wrt lambda expressions

[Helmut Eller]

* Alan Mackenzie [2009-03-05 17:45+0100] writes:

> One of the reasons for using a lambda is to save having to think up a
> function name, and to save cluttering up one's .emacs, or whatever.
> Compare
>
>     (add-hook 'foo-mode-hook (lambda (some-minor-mode 1)))
>
> with
>
>     (defun switch-some-minor-mode-on ()
>       (some-minor-mode 1))
>     (add-hook 'foo-mode-hook 'switch-some-minor-mode-on)
>

I've seen this idiom in several places:

(add-hook 'foo-mode-hook 
          (defun switch-some-minor-mode-on () 
            (some-minor-mode 1)))


Helmut.

Re: Idempotency of add-hook wrt lambda expressions

[Stefan Monnier]

> One of the reasons for using a lambda is to save having to think up a
> function name, and to save cluttering up one's .emacs, or whatever.
> Compare

>     (add-hook 'foo-mode-hook (lambda (some-minor-mode 1)))

> with

>     (defun switch-some-minor-mode-on ()
>       (some-minor-mode 1))
>     (add-hook 'foo-mode-hook 'switch-some-minor-mode-on)

FWIW, I use the second form in my .emacs, because I try to make my
.emacs idempotent (so I can just reload it any number of time, and that
won't add N copies of my lambda on that magic hook).


        Stefan

Re: Idempotency of add-hook wrt lambda expressions

[Geoff Gole]

> But who'd want to?

Somebody who wants the convenience of an idempotent init file?

Re: Idempotency of add-hook wrt lambda expressions

[Alan Mackenzie]

On Thu, Mar 05, 2009 at 10:49:14AM +0100, David Kastrup wrote:
> Geoff Gole <geoffgole@gmail.com> writes:

> >> I'd much rather add a patch that complains when you pass a lambda to
> > add-hook.

> > Sounds good to me.

> Does not jibe with existing practise.

"Me too!".

> For example, (info "(emacs) Init Examples") carefully explains

>    * Turn on Auto Fill mode automatically in Text mode and related
>      modes.

>           (add-hook 'text-mode-hook
>             '(lambda () (auto-fill-mode 1)))

>      This shows how to add a hook function to a normal hook variable
>      (*note Hooks::).  The function we supply is a list starting with
>      `lambda', with a single-quote in front of it to make it a list
>      constant rather than an expression.

>      It's beyond the scope of this manual to explain Lisp functions,
>      but for this example it is enough to know that the effect is to
>      execute `(auto-fill-mode 1)' when Text mode is entered.  You can
>      replace that with any other expression that you like, or with
>      several expressions in a row.

> Sure, you can "fix" the manual here.  But you can't expect that the
> real world has never used an idiom explicitly documented and used as an
> example.

I have stuff like the following in my setup:

    (global-set-key [f1] (lambda () "Switch to frame F1"
                          (interactive)
                          (select-frame-acm-no 0)))

That `global-set-key' might easily have been an `add-hook'.  I think it
would get tedious very quickly if warnings were given with add-hook +
lambda.  To outlaw it would be the Wrong Thing completely.

With all due respect to Geoff, I don't think this is really a problem.

> Also, in some cases you can't avoid lambda, namely when using computed
> functions.

Yes.

> David Kastrup

-- 
Alan Mackenzie (Nuremberg, Germany).

Re: Idempotency of add-hook wrt lambda expressions

[Reiner Steib]

On Thu, Mar 05 2009, David Kastrup wrote:

> For example, (info "(emacs) Init Examples") carefully explains
>
>    * Turn on Auto Fill mode automatically in Text mode and related
>      modes.
>
>           (add-hook 'text-mode-hook
>             '(lambda () (auto-fill-mode 1)))

Maybe we should provide turn-on-auto-fill-mode and use it here?

Bye, Reiner.
-- 
       ,,,
      (o o)
---ooO-(_)-Ooo---  |  PGP key available  |  http://rsteib.home.pages.de/

Re: Idempotency of add-hook wrt lambda expressions

[Edward O'Connor]

>> For example, (info "(emacs) Init Examples") carefully explains
>>
>>    * Turn on Auto Fill mode automatically in Text mode and related
>>      modes.
>>
>>           (add-hook 'text-mode-hook
>>             '(lambda () (auto-fill-mode 1)))
>
> Maybe we should provide turn-on-auto-fill-mode and use it here?

`turn-on-auto-fill' and `turn-off-auto-fill' are already defined in
simple.el. The docs should just be updated to use them.


-- 
Ted

Re: Idempotency of add-hook wrt lambda expressions

[Reiner Steib]

On Thu, Mar 05 2009, Edward O'Connor wrote:

>> Maybe we should provide turn-on-auto-fill-mode and use it here?
>
> `turn-on-auto-fill' and `turn-off-auto-fill' are already defined in
> simple.el. 

Oh, stupid me.  I thought it should be interactive, so I only checked
`M-x turn-on-a TAB' and got "No match".

> The docs should just be updated to use them.

Agreed.

Bye, Reiner.
-- 
       ,,,
      (o o)
---ooO-(_)-Ooo---  |  PGP key available  |  http://rsteib.home.pages.de/

Re: Idempotency of add-hook wrt lambda expressions

[David Kastrup]

Reiner Steib <reinersteib+gmane@imap.cc> writes:

> On Thu, Mar 05 2009, Edward O'Connor wrote:
>
>>> Maybe we should provide turn-on-auto-fill-mode and use it here?
>>
>> `turn-on-auto-fill' and `turn-off-auto-fill' are already defined in
>> simple.el. 
>
> Oh, stupid me.  I thought it should be interactive, so I only checked
> `M-x turn-on-a TAB' and got "No match".
>
>> The docs should just be updated to use them.
>
> Agreed.

They already mention this as a simpler variant, right after the passage
I quoted.  But that does not change that the "complex" variant is
presented first, and with the full intent of showing the use of lambda
in a hook.

-- 
David Kastrup

Re: Idempotency of add-hook wrt lambda expressions

[Alan Mackenzie]

Hi, Geoff, Hi, Emacs!

On Wed, Mar 04, 2009 at 09:10:45PM +0900, Geoff Gole wrote:
> Say a file contains an add-hook form with a lambda argument:

>   (add-hook 'foo-mode (lambda () (bar)))

> Annoyingly, the function will be added to the hook twice if the file
> is byte compiled, loaded, then reevaluated (such as with eval-buffer).
> This can be worked around in any number of ways (don't byte compile,
> don't use lambdas in hooks, restart emacs on every change), but I
> wonder if add-hook can be made to do the right thing.

That begs the question as to what the Right Thing actually is.  Surely
this is a case of "you asked for it, you got it".

Also, is there really anything special about hooks here?  You're going to
be having this sort of problem wherever you use a lambda when you "really
ought" to be using a symbol.

> One way is to change the hook membership test from:

>   (member function hook-value)

> to something like

>   (ignore-errors
>     (let ((bc-function (byte-compile function)))
>       (or (member function hook-value)
> 	  (member bc-function hook-value))))

> But that's pretty horrible. In any case, if there is no fix shouldn't
> this wrinkle be mentioned in the add-hook docstring?

No, it's not "pretty horrible", it's utterly horrific.  ;-)

I'm not convinced anything's really needed in the add-hook docstring or
manual entry, but if so, I'd suggest something along the lines "you'd
best use a symbol here unless you really know what you're doing".

-- 
Alan Mackenzie (Nuremberg, Germany).

Re: Idempotency of add-hook wrt lambda expressions

[Stefan Monnier]

> I'm not convinced anything's really needed in the add-hook docstring or
> manual entry, but if so, I'd suggest something along the lines "you'd
> best use a symbol here unless you really know what you're doing".

I'm glad we agree.


        Stefan