mark-word

mark-word

[Andreas Röhler]

If mark-word is called while inside a word, it marks
from this point until the end of word first AFAIS, thus
leaving the first part of the word unmarked.

IMO marking the word-at-point completely then would be
a more convenient behaviour.

Any opinions?

Thanks

Andreas Röhler

mark-word

[Stephen J. Turnbull]

Andreas Röhler writes:

 > If mark-word is called while inside a word, it marks
 > from this point until the end of word first AFAIS, thus
 > leaving the first part of the word unmarked.

 > IMO marking the word-at-point completely then would be
 > a more convenient behaviour.

`mark-word' itself should remain compatible with `kill-word' and
`mark-sexp'.  I think it would be a good idea to have a
`mark-entire-word' command and bind it to M-@, especially since C-@
doesn't mark a character.  Ditto `mark-entire-sexp' and C-M-@.

Re: mark-word

[David Kastrup]

"Stephen J. Turnbull" <stephen@xemacs.org> writes:

> Andreas Röhler writes:
>
>  > If mark-word is called while inside a word, it marks
>  > from this point until the end of word first AFAIS, thus
>  > leaving the first part of the word unmarked.
>
>  > IMO marking the word-at-point completely then would be
>  > a more convenient behaviour.
>
> `mark-word' itself should remain compatible with `kill-word' and
> `mark-sexp'.  I think it would be a good idea to have a
> `mark-entire-word' command and bind it to M-@, especially since C-@
> doesn't mark a character.  Ditto `mark-entire-sexp' and C-M-@.

Since "mark whole ..." for both directions is useful for more than
words, I think it would be more useful to have a prefix for that.

C-u C-u feels natural for "both directions", but to make it
non-surprising, one would likely have to assign separate meaning to C-u
(as opposed to C-u 4).  So probably rather C-u C-@.

-- 
David Kastrup, Kriemhildstr. 15, 44793 Bochum

Re: mark-word

[Leo]

On 2007-11-14 08:11 +0000, Stephen J. Turnbull wrote:
> Andreas Röhler writes:
>
>  > If mark-word is called while inside a word, it marks
>  > from this point until the end of word first AFAIS, thus
>  > leaving the first part of the word unmarked.
>
>  > IMO marking the word-at-point completely then would be
>  > a more convenient behaviour.
>
> `mark-word' itself should remain compatible with `kill-word' and
> `mark-sexp'.

Why?

Is mark-paragraph compatible with kill-paragraph?

> I think it would be a good idea to have a `mark-entire-word' command
> and bind it to M-@, especially since C-@ doesn't mark a character.
> Ditto `mark-entire-sexp' and C-M-@.

-- 
.:  Leo  :.  [ sdl.web AT gmail.com ]  .:  [ GPG Key: 9283AA3F ]  :.

          Use the best OS -- http://www.fedoraproject.org/

Re: mark-word

[Andreas Röhler]

Am Mittwoch, 14. November 2007 09:26 schrieb David Kastrup:
> "Stephen J. Turnbull" <stephen@xemacs.org> writes:
> > Andreas Röhler writes:
> >  > If mark-word is called while inside a word, it marks
> >  > from this point until the end of word first AFAIS, thus
> >  > leaving the first part of the word unmarked.
> >  >
> >  > IMO marking the word-at-point completely then would be
> >  > a more convenient behaviour.
> >
> > `mark-word' itself should remain compatible with `kill-word' and
> > `mark-sexp'.  I think it would be a good idea to have a
> > `mark-entire-word' command and bind it to M-@, especially since C-@
> > doesn't mark a character.  Ditto `mark-entire-sexp' and C-M-@.
>
> Since "mark whole ..." for both directions is useful for more than
> words, I think it would be more useful to have a prefix for that.
>
> C-u C-u feels natural for "both directions", but to make it
> non-surprising, one would likely have to assign separate meaning to C-u
> (as opposed to C-u 4).  So probably rather C-u C-@.


What about this?

(defun mark-word-at-point ()
  " "
  (interactive)
  (beginning-of-thing 'word)
  (push-mark nil nil t)
  (end-of-thing 'word))

Andreas Röhler

Re: mark-word

[Stephen J. Turnbull]

Leo writes:

 > > `mark-word' itself should remain compatible with `kill-word' and
 > > `mark-sexp'.
 > 
 > Why?

Erm, backward compatibility is a good thing.  "Why *not* preserve it?"
is the right question, and it better have a good answer.

More specifically, mostly because it's a pain in the neck to deal with
functions whose specifications change for the convenience of the UI,
and because it's an offense against the general regularity of names
with no good reason.  True, symbol names are somewhat scarce, but I
rather doubt anyone in their right mind would give `mark-entire-word'
anything but the proposed semantics.  It should be easy for people who
actually prefer that behavior (if any, I admit) to revert.  And some
of us support Emacsen that won't have the change, often simultaneously
with the latest code.  XEmacs does so as project policy, and many
organizational environments will do so too.

Re: mark-word

[Stephen J. Turnbull]

David Kastrup writes:
 > "Stephen J. Turnbull" <stephen@xemacs.org> writes:

 > > I think it would be a good idea to have a `mark-entire-word'
 > > command and bind it to M-@, especially since C-@ doesn't mark a
 > > character.  Ditto `mark-entire-sexp' and C-M-@.
 > 
 > Since "mark whole ..." for both directions is useful for more than
 > words, I think it would be more useful to have a prefix for that.

But we already have a plethora of ways to accomplish this in 2 or 3
keystrokes.  Andreas's point is to get this (very natural) behavior by
default with M-@.  And as you noticed, C-u M-@ already has semantics
("mark the rest of this word and the three following").

Keep it simple, and backward compatible.  It only costs one element in
the objarray, and an xref to `mark-entire-word' in the documentation
of `mark-word'.  There's really not a lot of future developer cost due
to extra complexity here, since nobody except UI programmers should be
using these commands in programs.

Re: mark-word

[Stephen J. Turnbull]

Andreas Röhler writes:

 > What about this?
 > 
 > (defun mark-word-at-point ()
 >   " "
 >   (interactive)
 >   (beginning-of-thing 'word)
 >   (push-mark nil nil t)
 >   (end-of-thing 'word))

The name is not descriptive of how it differs from `mark-word';
`mark-word' already has "at point" semantics.  Point and mark should
end up in the opposite order, for compatibility with `mark-paragraph'.
Also, I suspect that you'd be surprised by the result in this context:

    foo bar baz?  -!-quux.

With point at -!- I would expect "quux" to be highlighted, but your
function gives "baz".

Re: mark-word

[Lennart Borgman (gmail)]

Stephen J. Turnbull wrote:
> Andreas Röhler writes:
> 
>  > What about this?
>  > 
>  > (defun mark-word-at-point ()
>  >   " "
>  >   (interactive)
>  >   (beginning-of-thing 'word)
>  >   (push-mark nil nil t)
>  >   (end-of-thing 'word))
> 
> The name is not descriptive of how it differs from `mark-word';
> `mark-word' already has "at point" semantics.

Is there a mark-thing-at-point? If there were then mark-word-at-point 
could be implemented using that.

Re: mark-word

[Miles Bader]

"Lennart Borgman (gmail)" <lennart.borgman@gmail.com> writes:
> Is there a mark-thing-at-point?

No

> If there were then mark-word-at-point could be implemented using that.

It could also be implemented rather simply using primitive functions.
The thing-at-point code is hairy and ugly, so it seems backwards to base
other simpler functions on it...

-Miles

-- 
I'm beginning to think that life is just one long Yoko Ono album; no rhyme
or reason, just a lot of incoherent shrieks and then it's over.  --Ian Wolff

Re: mark-word

[Richard Stallman]

    > `mark-word' itself should remain compatible with `kill-word' and
    > `mark-sexp'.

    Why?

For compatibility and simplicity.

Please consider this a final decision.
Please do not ask me to spend more time on this.

Re: mark-word

[Lennart Borgman (gmail)]

>> Is there a mark-thing-at-point?
> 
> No
> 
>> If there were then mark-word-at-point could be implemented using that.
> 
> It could also be implemented rather simply using primitive functions.
> The thing-at-point code is hairy and ugly, so it seems backwards to base
> other simpler functions on it...

Using thing-at-point to make mark-thing-at-point (and then 
mark-work-at-point etc) would mean that it is consistent and eaiser for 
the user to remember.

Re: mark-word

[Miles Bader]

"Lennart Borgman (gmail)" <lennart.borgman@gmail.com> writes:
>> It could also be implemented rather simply using primitive functions.
>> The thing-at-point code is hairy and ugly, so it seems backwards to base
>> other simpler functions on it...
>
> Using thing-at-point to make mark-thing-at-point (and then
> mark-work-at-point etc) would mean that it is consistent and eaiser for
> the user to remember.

Why?  The user doesn't care how mark-word-at-point (incidentally, this
is a crap name) is implemented.

-Miles

-- 
Love is a snowmobile racing across the tundra.  Suddenly it flips over,
pinning you underneath.  At night the ice weasels come.  --Nietzsche

Re: mark-word

[Andreas Röhler]

Am Donnerstag, 15. November 2007 09:40 schrieb Lennart Borgman (gmail):
> >> Is there a mark-thing-at-point?
> >
> > No
> >
> >> If there were then mark-word-at-point could be implemented using that.
> >
> > It could also be implemented rather simply using primitive functions.
> > The thing-at-point code is hairy and ugly, so it seems backwards to base
> > other simpler functions on it...
>
> Using thing-at-point to make mark-thing-at-point (and then
> mark-work-at-point etc) would mean that it is consistent and eaiser for
> the user to remember.
>

As the original issue seems to have no chance, just one
remark to `thing-at-point' (which I should not have
introduced here beside)

As Miles pointed out the code is hairy. Indeed, it's
buggy.

However the idea behind seems valid: Given `beginning'
and `end' of THING, you may reuse a set of functions ad
infinitum, one for all.

The bugs come in, if underlying moving functions don't
stop at the end of THING but one char after.

After cutting this dependencies--see 
thingatpt-utils in gnu-emacs-source--everything 
works fine AFAIS.

Concering the example delivered by Stephen:

foo bar baz?   quux
_____________|____

M-x mark-word-at-point
=> beginning-of-thing: No word here

That's correct, so I can't reproduce the problem.

OTOH the bug described above would show up if cursor is
over question mark.

Then `baz' is marked but should not, because a question
mark is not a word. The same if cursor is beneath foo. Foo is marked, while
cursor over space.

Thanks all

Andreas Röhler

Re: mark-word

[Lennart Borgman (gmail)]

>> Using thing-at-point to make mark-thing-at-point (and then
>> mark-work-at-point etc) would mean that it is consistent and eaiser for
>> the user to remember.
> 
> Why?  The user doesn't care how mark-word-at-point (incidentally, this
> is a crap name) is implemented.


If (thing-at-point 'word) returns "MYWORD" (in a different format 
though) then I would expect something like (mark-thing-at-point 'word) 
to mark MYWORD. And if there was a function mark-word-at-point I would 
expect it to mark MYWORD, etc.

Don't you?

And if thing-at-point is buggy and unnecessary hairy that is IMO not any 
excuse not to use it when it simplifies other code. Also from a user 
point it at least makes things consistent (even with bugs).