RE: [PATCH] Make `C-x {' and `C-x }' repeatable

[Drew Adams]

> I don't know why a prefix arg exits temporary-overlay-map.  Trying to
> (define-key window-size-adjust-keymap [?\C-u] 'universal-argument)
> doesn't help to fix this.  `C-u' still terminates the key sequence
> `C-x } } } } C-u }'.

Dunno.  But anyway, as I said, the typical use case for repetition (at least 
for me) would reuse the same prefix-arg value given to the prefix key.  IOW, I 
would typically not want to use a different prefix value for one occurrence of 
repetition from another.

Or at least I would not want to be *obliged* to repeat the prefix arg each time 
I repeated the final key.  And I think that is what your approach amounts to 
(assuming you can fix it so a prefix arg does not exit the map).

It would be OK for a user to be *able* to employ a new prefix arg along the 
way, for a one-off final-key occurrence.  But you wouldn't want to be forced to 
keep providing a prefix arg for each final-key repetition. 

> > I want to have a repeatable command bound to a key on `isearch-mode-map'.
> 
> In bug#10654 I proposed a patch that implements repeatable keys for Isearch
> e.g. `M-s C-f C-f M-f C-f ...'

Yes, I saw that.  Good.  I would still prefer a simpler approach.  You are 
essentially requiring each repeatable command to set variables 
`isearch-repeat-command' and `isearch-repeat-key'.  (That might be similar to 
the older approach used in repeat.el - dunno.)

I would prefer something simpler, using either an approach like 
`set-temporary-overlay-map' (which you proposed for this thread) or an approach 
like `repeat-command' (which I mentioned).  Both of those allow for short, 
simple & clear command definitions.

The former has the advantage that you can define the map to include a set of 
keys, any of which can be the repeatable final key (mix & match within the set).

Of course it means creating a different map for each such set of keys.  E.g., 
if you want several such sets on the same key prefix, but you want them to be 
separate - so that, e.g., you could repeat with `C-x a b c a b b' or with `C-x 
m m o n o o', but not with `C-x a b m a n'.

And you would need to use a singleton map if you wanted a singleton final-key 
set.  E.g, if you want to get the effect that repeat.el provides of allowing 
`C-x a a a a' and `C-x b b b', but not C-x a b b a, then you would need two 
singleton keymaps.

IOW, it is good to be able to define sets of final keys that work together, 
repeating any of them without needing to repeat the prefix key.  Code that lets 
you do that simply, even for the singleton set case, and preferably without 
needing to define multiple global vars, would be preferable.

FWIW, I have all of these "yank" keys on prefix `C-y' in Isearch:

`C-y C-('    `isearchp-yank-sexp-symbol-or-char'
`C-y C-2'    `isearch-yank-secondary'
`C-y C-c'    `isearchp-yank-char'
`C-y C-e'    `isearchp-yank-line'
`C-y C-w'    `isearchp-yank-word-or-char'
`C-y C-y'    `isearch-yank-kill'
`C-y M-y'    `isearch-yank-pop'

5 of those commands are repeatable.  But because I use `repeat-command' to 
implement this, you cannot mix and match these within the same `C-y' 
occurrence: each is separately repeatable (e.g., `C-y C-e C-e... C-y C-w C-w' 
is OK, but not `C-y C-e C-e C-w C-w').

(And anyway, the repeatable Isearch commands have stopped working because of 
bug #14095.)

> Maybe a better implementation would be with the help of
> `set-temporary-overlay-map'.

Only, I think, if bug #14095 gets fixed.  I think it's the same problem.

The problem that bug #14095 points out is that `set-temporary-overlay-map' does 
not work with Isearch because its map does not override the map used by 
Isearch.  `overriding(-terminal)-local-map' (used by Isearch) overrules the 
temporary map used by `set-temporary-overlay-map'.

> I'll try to do this for Isearch.

See previous.  AFAICT, it won't work to use `set-temporary-overlay-map' there, 
unless bug #14095 is fixed.

> But it seems repeat.el can't be used if there are different commands
> in the key sequence.

No (i.e., correct), at least not the way I did it.

I thought for a moment that perhaps one could somehow leverage a sequence value 
of `repeat-on-final-keystroke', to allow such behavior, but I guess not.  Too 
bad.  I guess that's only for allowing multiple "alias" keys for the *same* 
repeatable command (not for multiple commands intended to be used together).

(And I'm not even sure how you would use that option for keys such as <right>.  
Any idea?  I tried fiddling with option values but couldn't make it work.  And 
why the doc speaks of "characters" instead of keys, I don't know.)