Pushing the mark from a primitive like goto-char

Pushing the mark from a primitive like goto-char

[Daniel Martín]

goto-char is an interactive function that has the potential to take you
long distances, so it might be a good idea, for user convenience, to
push the mark as a documented side effect (is it a good idea?).

If it's a good idea, what's the cleanest and simplest way to do that?
goto-char is implemented in C, so it'd need to call push-mark, which is
implemented in ELisp.  Should it call push-mark via eval_sub or Feval,
or is there an alternative C primitive to push the mark into the mark
ring correctly?

TIA

Re: Pushing the mark from a primitive like goto-char

[Philipp Stephani]

Am Mo., 28. Dez. 2020 um 13:15 Uhr schrieb Daniel Martín <mardani29@yahoo.es>:
>
>
> goto-char is an interactive function that has the potential to take you
> long distances, so it might be a good idea, for user convenience, to
> push the mark as a documented side effect (is it a good idea?).

goto-char is a low-level primitive that's used pervasively in Emacs
Lisp code. I think that pushing the mark would be a way too drastic
change.

Re: Pushing the mark from a primitive like goto-char

[Daniel Martín]

Philipp Stephani <p.stephani2@gmail.com> writes:

> Am Mo., 28. Dez. 2020 um 13:15 Uhr schrieb Daniel Martín <mardani29@yahoo.es>:
>>
>>
>> goto-char is an interactive function that has the potential to take you
>> long distances, so it might be a good idea, for user convenience, to
>> push the mark as a documented side effect (is it a good idea?).
>
> goto-char is a low-level primitive that's used pervasively in Emacs
> Lisp code. I think that pushing the mark would be a way too drastic
> change.

But, AFAIK, goto-char is a function that is used both interactively and
in ELisp programs.  I meant to suggest pushing the mark only when used
interactively.

Re: Pushing the mark from a primitive like goto-char

[Eli Zaretskii]

> From: Philipp Stephani <p.stephani2@gmail.com>
> Date: Mon, 28 Dec 2020 15:17:30 +0100
> Cc: Emacs developers <emacs-devel@gnu.org>
> 
> Am Mo., 28. Dez. 2020 um 13:15 Uhr schrieb Daniel Martín <mardani29@yahoo.es>:
> > goto-char is an interactive function that has the potential to take you
> > long distances, so it might be a good idea, for user convenience, to
> > push the mark as a documented side effect (is it a good idea?).
> 
> goto-char is a low-level primitive that's used pervasively in Emacs
> Lisp code. I think that pushing the mark would be a way too drastic
> change.

I tend to agree.  I think this is the reason why goto-char was not
made to push the mark in the first place.

Re: Pushing the mark from a primitive like goto-char

[Stefan Kangas]

Philipp Stephani <p.stephani2@gmail.com> writes:

>> goto-char is an interactive function that has the potential to take you
>> long distances, so it might be a good idea, for user convenience, to
>> push the mark as a documented side effect (is it a good idea?).
>
> goto-char is a low-level primitive that's used pervasively in Emacs
> Lisp code. I think that pushing the mark would be a way too drastic
> change.

Agreed.

But would it perhaps make sense to push the mark only when it is called
interactively?  Or to replace `M-g c' with a new command that also
pushes mark?

Re: Pushing the mark from a primitive like goto-char

[Philipp Stephani]

Am Mo., 28. Dez. 2020 um 15:56 Uhr schrieb Stefan Kangas
<stefankangas@gmail.com>:
>
> Philipp Stephani <p.stephani2@gmail.com> writes:
>
> >> goto-char is an interactive function that has the potential to take you
> >> long distances, so it might be a good idea, for user convenience, to
> >> push the mark as a documented side effect (is it a good idea?).
> >
> > goto-char is a low-level primitive that's used pervasively in Emacs
> > Lisp code. I think that pushing the mark would be a way too drastic
> > change.
>
> Agreed.
>
> But would it perhaps make sense to push the mark only when it is called
> interactively?

I don't think we should have functions that behave significantly
differently when called interactively - too much confusion.

>  Or to replace `M-g c' with a new command that also
> pushes mark?

That sounds feasible. Maybe we should then also introduce a
customization option to control the behavior.

Re: Pushing the mark from a primitive like goto-char

[martin rudalics]

 >>   Or to replace `M-g c' with a new command that also
 >> pushes mark?
 >
 > That sounds feasible. Maybe we should then also introduce a
 > customization option to control the behavior.

I'd then try to make it behave like 'M-g g' in this regard.

martin

Re: Pushing the mark from a primitive like goto-char

[Juri Linkov]

>>>   Or to replace `M-g c' with a new command that also
>>> pushes mark?
>>
>> That sounds feasible. Maybe we should then also introduce a
>> customization option to control the behavior.
>
> I'd then try to make it behave like 'M-g g' in this regard.

Some interactive versions of low-level primitives have the suffix
`...-command' in their names, so a command like 'M-g g' and bound to
'M-g c' could be named 'goto-char-command'.

Re: Pushing the mark from a primitive like goto-char

[martin rudalics]

 >> I'd then try to make it behave like 'M-g g' in this regard.
 >
 > Some interactive versions of low-level primitives have the suffix
 > `...-command' in their names, so a command like 'M-g g' and bound to
 > 'M-g c' could be named 'goto-char-command'.

I was more concerned about not pushing the mark when the region is
already active so one can use M-g c to extend the region.  BTW, is there
a reason why 'goto-map' is so terribly unpopulated?

martin

Re: Pushing the mark from a primitive like goto-char

[Stefan Kangas]

martin rudalics <rudalics@gmx.at> writes:

> BTW, is there a reason why 'goto-map' is so terribly unpopulated?

Do you have any ideas for what to add?

FWIW, here I have `M-g M-j' for `bookmark-jump' and `M-g M-r' for
`goto-random-line' (local function).

Re: Pushing the mark from a primitive like goto-char

[martin rudalics]

 >> BTW, is there a reason why 'goto-map' is so terribly unpopulated?
 >
 > Do you have any ideas for what to add?

Not really - it's the first time I've been looking into it.  But given
the recent discussions about stealing each other's bindings I wonder why
such a convenient prefix like M-g is not more exploited.  Maybe because
ESC on a terminal is not so convenient.

martin

RE: Pushing the mark from a primitive like goto-char

[Drew Adams]

>>> BTW, is there a reason why 'goto-map' is so terribly unpopulated?
>> Do you have any ideas for what to add?
> 
> Not really - it's the first time I've been looking into it.  But given
> the recent discussions about stealing each other's bindings I wonder why
> such a convenient prefix like M-g is not more exploited.  Maybe because
> ESC on a terminal is not so convenient.

You might consider adding `(beginning|end)-of-buffer'
to `goto-map'.

FWIW, my library `menu-bar+.el' has this for the
`Go To' menu (not quite the same thing as `goto-map'):

 Line...                        M-g g
 Column (Position in Line)...   M-g TAB
 Buffer Position...             M-g c
 Beginning of Buffer            M-<
 End of Buffer                  M->
 Next Error                     C-x `
 Previous Error                 M-g p

And if Bookmark+ is available (which has many kinds
of jump commands), submenu `Bookmark' (jumping only).
(Those jump items are also on a more general `Bookmarks'
menu, along with non-jump bookmark commands.)

And if Icicles is available, submenu `Icicles', which
has multi-command items for moving among markers etc.
___

And tag-finding (now "xref") items could be moved from
`goto-map' to a search map (such as `search-map').
They're not so much about going to a predefined
position as they are about finding something.  A user
is more likely to look for finding and searching in
the same place.

`menu-bar+.el' puts them on a menu-bar `Search' menu,
submenu `Tags':

  Find Tag...
  Find Next Tag
  ___________
  Find Tag Regexp...
  Search Tagged Files...
    Continue Search/Replace
  ___________
  Tags Apropos...
  Set Tags File Name...

___

`menu-bar+.el' also puts `grep' and similar on the
`Search' menu, not `Tools' -- they're about finding
or searching.

The `Tools' menu is a catch-all.  Something should
be there only if there's no more specific kind of
"tool"/action place to put it.  Searching/finding
tools are better on a `Search' menu.

Re: Pushing the mark from a primitive like goto-char

[Juri Linkov]

>>> BTW, is there a reason why 'goto-map' is so terribly unpopulated?
>>
>> Do you have any ideas for what to add?
>
> Not really - it's the first time I've been looking into it.  But given
> the recent discussions about stealing each other's bindings I wonder why
> such a convenient prefix like M-g is not more exploited.  Maybe because
> ESC on a terminal is not so convenient.

Since there is a new unbound command 'goto-line-relative'
maybe then we could add it to 'goto-map' it as follows:

  M-g M-G         goto-line
  M-g M-g         goto-line-relative

Re: Pushing the mark from a primitive like goto-char

[Eli Zaretskii]

> From: Juri Linkov <juri@linkov.net>
> Date: Tue, 29 Dec 2020 21:25:40 +0200
> Cc: Philipp Stephani <p.stephani2@gmail.com>,
>  Emacs developers <emacs-devel@gnu.org>, Stefan Kangas <stefankangas@gmail.com>,
>  Daniel Martín <mardani29@yahoo.es>
> 
> Since there is a new unbound command 'goto-line-relative'

It isn't unbound.

Re: Pushing the mark from a primitive like goto-char

[Juri Linkov]

>> Since there is a new unbound command 'goto-line-relative'
>
> It isn't unbound.

I don't think its current binding is the best.
A binding in 'goto-map' would be more discoverable.

RE: Pushing the mark from a primitive like goto-char

[Drew Adams]

> Since there is a new unbound command 'goto-line-relative'
> maybe then we could add it to 'goto-map' it as follows:
> 
>   M-g M-G         goto-line
>   M-g M-g         goto-line-relative

Isn't `M-g M-g' already bound to `goto-line'?

Why would you move that command to `M-g M-G' and give
its longstanding binding, `M-g M-g', to the new command?

I'm sure there must be some logic behind your
suggestion (you typically give reasons, thankfully),
but it's not clear to me why we'd want to move
`goto-line'.  (And I can't think about it, as I have
no idea what `goto-line-relative' is/does.)

Re: Pushing the mark from a primitive like goto-char

[Juri Linkov]

>> Since there is a new unbound command 'goto-line-relative'
>> maybe then we could add it to 'goto-map' it as follows:
>> 
>>   M-g M-G         goto-line
>>   M-g M-g         goto-line-relative
>
> Isn't `M-g M-g' already bound to `goto-line'?
>
> Why would you move that command to `M-g M-G' and give
> its longstanding binding, `M-g M-g', to the new command?
>
> I'm sure there must be some logic behind your
> suggestion (you typically give reasons, thankfully),
> but it's not clear to me why we'd want to move
> `goto-line'.  (And I can't think about it, as I have
> no idea what `goto-line-relative' is/does.)

Because there is no difference between them when the buffer
is not narrowed, i.e. most users won't notice the difference.
Alternatively, 'M-g M-G' could be bound to goto-line-relative
(if it's still easy to type on tty).  The choice mostly depends on
what the users will mostly use: goto-line or goto-line-relative?

RE: Pushing the mark from a primitive like goto-char

[Drew Adams]

> > it's not clear to me why we'd want to move
> > `goto-line'.  (And I can't think about it, as I have
> > no idea what `goto-line-relative' is/does.)
> 
> Because there is no difference between them when the buffer
> is not narrowed, i.e. most users won't notice the difference.
> Alternatively, 'M-g M-G' could be bound to goto-line-relative
> (if it's still easy to type on tty).  The choice mostly depends on
> what the users will mostly use: goto-line or goto-line-relative?

As I said - no idea what `goto-line-relative' is/does.

From what you say now, it's like `goto-line', except
when the buffer is narrowed.  Other than that, I still
have no idea.

Anyway, a priori it makes more sense to bind the new
command to a new key sequence (if we bind it at all), no?

Re: Pushing the mark from a primitive like goto-char

[Richard Stallman]

[[[ 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. ]]]

  >   But given
  > the recent discussions about stealing each other's bindings I wonder why
  > such a convenient prefix like M-g is not more exploited.  Maybe because
  > ESC on a terminal is not so convenient.

I don't think it is that.

There's nothing hard about typing M-g on the Linux ttys.
Does anyone actally use a terminal on which M-g requires
more than holding the Alt key?

I think the reason there is not much on the M-g prefix
is that we haven't seen many ideas of what to put in 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)

Re: Pushing the mark from a primitive like goto-char

[Howard Melman]

martin rudalics <rudalics@gmx.at> writes:

>>> BTW, is there a reason why 'goto-map' is so terribly unpopulated?
>>
>> Do you have any ideas for what to add?

FWIW I do:

(global-set-key (kbd "M-g d")		'dired-jump)
(global-set-key (kbd "M-g b")		'ibuffer-jump)
(global-set-key (kbd "M-g f")		'reveal-in-finder) ;custom mac command
(global-set-key (kbd "M-g s")		'shell) ; eshell?
(global-set-key (kbd "M-g i")	        'consult-imenu)
(global-set-key (kbd "M-g M-i")	'imenu-anywhere)
(global-set-key (kbd "M-g t") 		'move-to-window-line-top-bottom) 

-- 

Howard

Re: Pushing the mark from a primitive like goto-char

[Daniel Martín via "Emacs development discussions.]

martin rudalics <rudalics@gmx.at> writes:

>>> I'd then try to make it behave like 'M-g g' in this regard.
>>
>> Some interactive versions of low-level primitives have the suffix
>> `...-command' in their names, so a command like 'M-g g' and bound to
>> 'M-g c' could be named 'goto-char-command'.
>
> I was more concerned about not pushing the mark when the region is
> already active so one can use M-g c to extend the region.  BTW, is there
> a reason why 'goto-map' is so terribly unpopulated?
>

This sounds like a good idea:

- Create a 'goto-char-command' command in ELisp.

- Move the interactive spec that is in 'goto-char' to this new command
  and make it push the mark smartly (e.g. be careful when a region is
  active).  Then call 'goto-char'.

- Rebind 'M-g c' to 'goto-char-command'.

- Announce the new command.

What do you think? Could it break something? Thanks.

Re: Pushing the mark from a primitive like goto-char

[Stefan Monnier]

> What do you think?

Sounds good.  Don't forget to mark the `goto-char-command` as
`interactive-only` (with `declare`).


        Stefan

Re: Pushing the mark from a primitive like goto-char

[Stefan Monnier]

>>>> I'd then try to make it behave like 'M-g g' in this regard.
>>>
>>> Some interactive versions of low-level primitives have the suffix
>>> `...-command' in their names, so a command like 'M-g g' and bound to
>>> 'M-g c' could be named 'goto-char-command'.
>>
>> I was more concerned about not pushing the mark when the region is
>> already active so one can use M-g c to extend the region.  BTW, is there
>> a reason why 'goto-map' is so terribly unpopulated?
>>
>
> This sounds like a good idea:
>
> - Create a 'goto-char-command' command in ELisp.
>
> - Move the interactive spec that is in 'goto-char' to this new command
>   and make it push the mark smartly (e.g. be careful when a region is
>   active).  Then call 'goto-char'.
>
> - Rebind 'M-g c' to 'goto-char-command'.
>
> - Announce the new command.
>
> What do you think? Could it break something? Thanks.

Actually, now that I think about it: do we really need a new command, or
can we instead arrange to do all the mark-handling from within the
interactive spec?


        Stefan

Re: Pushing the mark from a primitive like goto-char

[Philipp Stephani]

Am Di., 5. Jan. 2021 um 20:19 Uhr schrieb Stefan Monnier
<monnier@iro.umontreal.ca>:
>
> >>>> I'd then try to make it behave like 'M-g g' in this regard.
> >>>
> >>> Some interactive versions of low-level primitives have the suffix
> >>> `...-command' in their names, so a command like 'M-g g' and bound to
> >>> 'M-g c' could be named 'goto-char-command'.
> >>
> >> I was more concerned about not pushing the mark when the region is
> >> already active so one can use M-g c to extend the region.  BTW, is there
> >> a reason why 'goto-map' is so terribly unpopulated?
> >>
> >
> > This sounds like a good idea:
> >
> > - Create a 'goto-char-command' command in ELisp.
> >
> > - Move the interactive spec that is in 'goto-char' to this new command
> >   and make it push the mark smartly (e.g. be careful when a region is
> >   active).  Then call 'goto-char'.
> >
> > - Rebind 'M-g c' to 'goto-char-command'.
> >
> > - Announce the new command.
> >
> > What do you think? Could it break something? Thanks.
>
> Actually, now that I think about it: do we really need a new command, or
> can we instead arrange to do all the mark-handling from within the
> interactive spec?
>


I think that would be too confusing. The interactive specification
should only gather input, but not perform state changes.

Re: Pushing the mark from a primitive like goto-char

[Stefan Monnier]

> I think that would be too confusing. The interactive specification
> should only gather input, but not perform state changes.

I'd have to see it before I could judge, but I don't think it would
necessarily be confusing, no.  We already do similar things in
some interactive specs, for example for the `handle-shift-selection`.


        Stefan

RE: Pushing the mark from a primitive like goto-char

[Drew Adams]

> The interactive specification should only 
> gather input, but not perform state changes.

Why?  In what contexts?  Or are you proposing
this as a blanket rule?

The interactive spec is just code evaluated when
the function is invoked interactively, and which
can (but need not) return values to be used as
args for the function.  Nothing more.

The interactive spec can do anything you
need/want it to do.  Likewise, the function's
non-interactive code (aka body).

This is Lisp.  Code can change state.  It's up
to the author - you get the behavior you code.

Re: Pushing the mark from a primitive like goto-char

[Richard Stallman]

[[[ 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. ]]]

In general, the interactive spec should only read the arguments.
The "real work" should be done in the function body once it gets the
arguments.

The reason for this is clean design, and to gives the right
relationship between interactive calls and noninteractive.

However, reading the arguments can legitimately have side effects,
byproducts of reading the arguments -- for instance, changing the
obarray if you need to intern something.

-- 
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)

Re: Pushing the mark from a primitive like goto-char

[Eli Zaretskii]

> Date: Tue, 05 Jan 2021 20:06:28 +0100
> Cc: Philipp Stephani <p.stephani2@gmail.com>,
>  Emacs developers <emacs-devel@gnu.org>, Stefan Kangas <stefankangas@gmail.com>,
>  Juri Linkov <juri@linkov.net>
> From: Daniel Martín via "Emacs development discussions." <emacs-devel@gnu.org>
> 
> - Create a 'goto-char-command' command in ELisp.
> 
> - Move the interactive spec that is in 'goto-char' to this new command
>   and make it push the mark smartly (e.g. be careful when a region is
>   active).  Then call 'goto-char'.
> 
> - Rebind 'M-g c' to 'goto-char-command'.

You mean, it will be impossible to invoke "M-x goto-char"?

Re: Pushing the mark from a primitive like goto-char

[Philipp Stephani]

Am Di., 5. Jan. 2021 um 20:29 Uhr schrieb Eli Zaretskii <eliz@gnu.org>:
>
> > Date: Tue, 05 Jan 2021 20:06:28 +0100
> > Cc: Philipp Stephani <p.stephani2@gmail.com>,
> >  Emacs developers <emacs-devel@gnu.org>, Stefan Kangas <stefankangas@gmail.com>,
> >  Juri Linkov <juri@linkov.net>
> > From: Daniel Martín via "Emacs development discussions." <emacs-devel@gnu.org>
> >
> > - Create a 'goto-char-command' command in ELisp.
> >
> > - Move the interactive spec that is in 'goto-char' to this new command
> >   and make it push the mark smartly (e.g. be careful when a region is
> >   active).  Then call 'goto-char'.
> >
> > - Rebind 'M-g c' to 'goto-char-command'.
>
> You mean, it will be impossible to invoke "M-x goto-char"?

Yes, goto-char should retain its interactive spec, there's no harm in that.

Re: Pushing the mark from a primitive like goto-char

[Daniel Martín via "Emacs development discussions.]

Eli Zaretskii <eliz@gnu.org> writes:

>> Date: Tue, 05 Jan 2021 20:06:28 +0100
>> Cc: Philipp Stephani <p.stephani2@gmail.com>,
>>  Emacs developers <emacs-devel@gnu.org>, Stefan Kangas <stefankangas@gmail.com>,
>>  Juri Linkov <juri@linkov.net>
>> From: Daniel Martín via "Emacs development discussions." <emacs-devel@gnu.org>
>> 
>> - Create a 'goto-char-command' command in ELisp.
>> 
>> - Move the interactive spec that is in 'goto-char' to this new command
>>   and make it push the mark smartly (e.g. be careful when a region is
>>   active).  Then call 'goto-char'.
>> 
>> - Rebind 'M-g c' to 'goto-char-command'.
>
> You mean, it will be impossible to invoke "M-x goto-char"?

Yes, what'd happen is that "M-x goto-char" RET will produce
"goto-char-", and the user would need to press another TAB to get
"goto-char-command", which may be inconvenient.

Having both "M-x goto-char" and "M-x goto-char-command" could be
confusing as well.  I'll give a try to implementing this as a side
effect in the interactive spec.

Re: Pushing the mark from a primitive like goto-char

[Philipp Stephani]

Am Di., 5. Jan. 2021 um 20:06 Uhr schrieb Daniel Martín <mardani29@yahoo.es>:
>
> martin rudalics <rudalics@gmx.at> writes:
>
> >>> I'd then try to make it behave like 'M-g g' in this regard.
> >>
> >> Some interactive versions of low-level primitives have the suffix
> >> `...-command' in their names, so a command like 'M-g g' and bound to
> >> 'M-g c' could be named 'goto-char-command'.
> >
> > I was more concerned about not pushing the mark when the region is
> > already active so one can use M-g c to extend the region.  BTW, is there
> > a reason why 'goto-map' is so terribly unpopulated?
> >
>
> This sounds like a good idea:
>
> - Create a 'goto-char-command' command in ELisp.
>
> - Move the interactive spec that is in 'goto-char' to this new command
>   and make it push the mark smartly (e.g. be careful when a region is
>   active).  Then call 'goto-char'.

There's no need the change goto-char; it can remain an interactive command.

>
> - Rebind 'M-g c' to 'goto-char-command'.
>
> - Announce the new command.
>
> What do you think? Could it break something? Thanks.

It will break users that expect the current behavior, so maybe there
should be a customization option that initially defaults to off.

Re: Pushing the mark from a primitive like goto-char

[Gabriel do Nascimento Ribeiro]

"Daniel Martín via \"Emacs development discussions."
<emacs-devel@gnu.org> writes:

> martin rudalics <rudalics@gmx.at> writes:
>
>>>> I'd then try to make it behave like 'M-g g' in this regard.
>>>
>>> Some interactive versions of low-level primitives have the suffix
>>> `...-command' in their names, so a command like 'M-g g' and bound to
>>> 'M-g c' could be named 'goto-char-command'.
>>
>> I was more concerned about not pushing the mark when the region is
>> already active so one can use M-g c to extend the region.  BTW, is there
>> a reason why 'goto-map' is so terribly unpopulated?
>>
>
> This sounds like a good idea:
>
> - Create a 'goto-char-command' command in ELisp.
>
> - Move the interactive spec that is in 'goto-char' to this new command
>   and make it push the mark smartly (e.g. be careful when a region is
>   active).  Then call 'goto-char'.
>
> - Rebind 'M-g c' to 'goto-char-command'.
>
> - Announce the new command.
>
> What do you think? Could it break something? Thanks.

Thank you!
I guess we missed the :group definition, here is a patch:

========================================================
diff --git a/lisp/mb-depth.el b/lisp/mb-depth.el
index ea2ea174b5..22315cd93f 100644
--- a/lisp/mb-depth.el
+++ b/lisp/mb-depth.el
@@ -37,7 +37,8 @@ minibuffer-depth-indicator-function

 (defface minibuffer-depth-indicator '((t :inherit highlight))
   "Face to use for minibuffer depth indicator."
-  :version "28.1")
+  :version "28.1"
+  :group 'basic-faces)

 ;; An overlay covering the prompt.  This is a buffer-local variable in
 ;; each affected minibuffer.
 ========================================================