bug#47992: [External] : bug#47992: 27; 28; Phase out use of `equal` in `add-hook`, `remove-hook`

[Drew Adams <drew.adams@oracle.com>]

> People are proposing a lot of work on a little wrinkle that isn't worth
> much effort.  There are other changes we could make that would
> really help users do editing.

Agreed.

> Here's an easy way to help users avoid such collisions: to say
> they should include a name in each anonymous lambda that they put on a
> hook in their init files -- a name based on the user's name.
> 
> Adding a name to a lambda is easy.  Just write the symbol after the
> argument list (and doc string and interactive spec, if any), like
> this: (lambda () rms-init-3 (glum-mode 1))
> 
> The mame will distinguish it from any otherwise-identical function
> such as (lambda () j-r-gensym (glum-mode 1))
> because they will not be equal.
> 
> Thus, the only change needed is in documentation.

I don't think that solves the problem ("little
wrinkle") raised by the bug report.  (But I agree
that the only change needed is documentation - just
advise users not to use anonymous functions as hook
functions.)

IIUC, the problem is not to _distinguish_ the
lambda.  It's kinda the opposite.  It's to let you
just type a lambda expression and have
`add|remove-hook' recognize it as being the _same_
function you gave it before.

Currently the test used for a lambda is `equal',
meaning that to remove a lambda you've added with
`add-hook' you need to provide a lambda (a list)
that's `equal' to the one you added originally.
(For a named function the function symbol is
simply tested using `eq'.)

Those who proposed solving this looked for a way
to enable an `eq' test for a lambda.  Lars
proposed to have users "name" anonymous functions
they put on hooks, and (presumably) to update the
`add|remove-hook' code to test for such a name
(if present) using `eq'.  (If a given lambda is
unnamed then the wrinkle is still a wrinkle.)

If your suggested way of naming a lambda were
used then the same approach would presumably
apply: change the `add|remove-hook' code to test
for such a name (if present) using `eq'.  And it
has the same problem: no good if not used.
___

I mentioned that if someone really wanted to go
down such a road (not something I'd encourage),
then there's no need to add a "name" possibility
- just use the doc-string possibility for lambdas.
The test (when a doc string is present) could
then be to use `eq' plus function `documentation'.

(That's no different from the test needed for a
lambda with a name - whether named your way or
another way: need to test for the presence of a
name, and if present test it with `eq'.  The test
for a name is analogous to the test for a doc
string with function `documentation'.)

But I and some others also think the whole attempt
to provide more or less `eq' testing for lambdas
is maybe misguided, and that users who today don't
bother to use a named function will likely also
not bother to name the lambdas they use on hooks.
(That goes also for "naming" using a doc string.)

We should, however (IMO) advise users not to use
anonymous functions as hook functions, in general,
and let them know why.  As you said, "the only
change needed is in documentation."