RE: [External] : Re: POLL: make C-x o transient

[Drew Adams]

> > > a very useful (i[f] not necessary) feature...
                     ^^^^^^^^^^^^^^^^^^

> > Indeed, as you admit, that's _not_ a necessary
> > feature for a repeatable command.
> 
> That's not what I said. 

Sure seems to be what you said: your claim was that
it's "very useful", but "not necessary".

> > The _much_ more common use case for a repeatable
> > command is to be able to use the same prefix arg
> > for each repetition - i.e., pass the prefix arg
> > at the beginning. ...
>
> > Replacing `C-x z' by `C-=' -- or by any other
> > single key -- gains nothing (AFAICS).
> 
> I understand that you believe that having the
> possibility to change the argument between two
> repetitions is useless.

You may understand that, but that's not what I said,
at all.

I said it's not a common use case.  I said the much
more common case is providing a prefix arg once (e.g.
to the key that initiates repetition of some other
command), and having it apply to _each_ repetition.

More importantly, I pointed out that nothing is
gained by replacing `C-x z' by `C-='.  Whatever key
sequence is bound to a command that _initiates_
repetition, is _NOT_ bound to a repeatable command.

A single, repeatable key such as `C-=' is better
saved (for users or for Emacs someday) to bind to a
repeatable command.

> But it is in essence what the OP asked: he wanted
> both other-window _and_ other-window-backward,
> not just a repeatable other-window.

The typical case is that Emacs already has a command
for doing something forward, and another command for
doing it backward.  Making each of those repeatable
solves the same "problem".  I mentioned the case of
`C-a' and `C-e' - just switch to the other key to
switch direction.

The case that initiated this, `other-window', does
not have any reverse-direction partner.  Instead, a
negative prefix arg reverses direction.  (But there
are ways to accommodate that, if it's important.)

Even without changing anything it's not _difficult_
to reverse direction:

`C-x o C-x z z... C-- C-x o C-x z z...

Or define `other-window-back` and bind repeatable
versions of `other-window' and `other-window-back'
to different repeatable keys (like the case of
`C-a' and `C-e').  But as Teemu pointed out, the
use case for cycling backward isn't very strong
(for the reason he gave).

Lots of things are possible.

But again, my _main point_ was about not wasting a
repeatable key (e.g. `C-=') for a NON-repeatable
command (`repeat').

It may not have been obvious to some (and so far,
you haven't acknowledged this deficiency in your
argument in favor of `C-=' as a replacement for
`C-x z') that command `repeat' (now`C-x z') is
NOT a repeatable command.

One doesn't bind that command to a key that you
can just hold down to repeat some action.  Its
action is only to _initiate_ the use of some
other command in a repeatable way.