bug#10614: [EXPERIMENTAL PATCH] Extending Isearch-repeat-forward/backward to support a prefix argument following suggesion by Juri Linkov

bug#10614: [EXPERIMENTAL PATCH] Extending Isearch-repeat-forward/backward to support a prefix argument following suggesion by Juri Linkov

[Gideon Stupp]

[-- Attachment #1: Type: text/plain, Size: 576 bytes --]

Package: emacs
Tags: patch
Severity: wishlist

This experimental patch implements a suggestion by Juri Linkov to extend
isearch-repeat-forward/backward to support a prefix argument. Instead of
pressing C-s / C-r multiple times it is possible with this patch to
enter a prefix argument
which runs the command multiple times for you. If a negative argument
is given for
isearch-repeat-forward then isearch-repeat-backward is run and visa
versa. Visual hints
are added to the matched strings to help figure out what argument
should be given.

Please try it out.

Thanks, Gideon.

[-- Attachment #2: isearchnavjuri.patch --]
[-- Type: text/x-patch, Size: 7354 bytes --]

This experimental patch implements a suggestion by Juri Linkov to extend
isearch-repeat-forward/backward to support a prefix argument. Instead of 
pressing C-s / C-r multiple times it is now possible to enter a prefix argument
which runs the command multiple times for you. If a negative argument is given for
isearch-repeat-forward than isearch-repeat-backward is run and visa versa. Visual hints
are added to the matched strings to help figure out what argument should be given.


diff --git a/lisp/isearch.el b/lisp/isearch.el
index ce75911..fce6fd5 100644
--- a/lisp/isearch.el
+++ b/lisp/isearch.el
@@ -333,6 +333,21 @@ A value of nil means highlight all matches."
                                 'lazy-highlight-face
                                 "22.1")
 (defvar lazy-highlight-face 'lazy-highlight)
+
+(defface lazy-highlight-hint
+  '((((class color) (min-colors 88) (background light))
+     (:background "paleturquoise" :bold t))
+    (((class color) (min-colors 88) (background dark))
+     (:background "paleturquoise4" :bold t))
+    (((class color) (min-colors 16))
+     (:background "turquoise3" :bold t))
+    (((class color) (min-colors 8))
+     (:background "turquoise3" :bold t))
+    (t (:underline t)))
+  "Face for lazy highlighting hints."
+  :group 'lazy-highlight
+  :group 'basic-faces)
+
 \f
 ;; Define isearch help map.
 
@@ -417,10 +432,25 @@ This is like `describe-bindings', but displays only Isearch keys."
     ;; We need these explicit definitions because, in a dense keymap,
     ;; the binding for t does not affect characters.
     ;; We use a dense keymap to save space.
+
     (while (< i ?\s)
       (define-key map (make-string 1 i) 'isearch-other-control-char)
       (setq i (1+ i)))
 
+    ;; Bring universal-argument and friends back in
+    (define-key map "\C-u" 'universal-argument)
+    (define-key map (kbd "C--") 'negative-argument)
+    (define-key map (kbd "C-0") 'digit-argument)
+    (define-key map (kbd "C-1") 'digit-argument)
+    (define-key map (kbd "C-2") 'digit-argument)
+    (define-key map (kbd "C-3") 'digit-argument)
+    (define-key map (kbd "C-4") 'digit-argument)
+    (define-key map (kbd "C-5") 'digit-argument)
+    (define-key map (kbd "C-6") 'digit-argument)
+    (define-key map (kbd "C-7") 'digit-argument)
+    (define-key map (kbd "C-8") 'digit-argument)
+    (define-key map (kbd "C-9") 'digit-argument)
+
     ;; Single-byte printing chars extend the search string by default.
     (setq i ?\s)
     (while (< i 256)
@@ -434,7 +464,20 @@ This is like `describe-bindings', but displays only Isearch keys."
     ;; default local key binding for any key not otherwise bound.
     (let ((meta-map (make-sparse-keymap)))
       (define-key map (char-to-string meta-prefix-char) meta-map)
-      (define-key map [escape] meta-map))
+      (define-key map [escape] meta-map)
+    (define-key meta-map (kbd "-") 'negative-argument)
+    (define-key meta-map (kbd "C--") 'negative-argument)
+    (define-key meta-map (kbd "C-0") 'digit-argument)
+    (define-key meta-map (kbd "C-1") 'digit-argument)
+    (define-key meta-map (kbd "C-2") 'digit-argument)
+    (define-key meta-map (kbd "C-3") 'digit-argument)
+    (define-key meta-map (kbd "C-4") 'digit-argument)
+    (define-key meta-map (kbd "C-5") 'digit-argument)
+    (define-key meta-map (kbd "C-6") 'digit-argument)
+    (define-key meta-map (kbd "C-7") 'digit-argument)
+    (define-key meta-map (kbd "C-8") 'digit-argument)
+    (define-key meta-map (kbd "C-9") 'digit-argument))
+
     (define-key map (vector meta-prefix-char t) 'isearch-other-meta-char)
 
     ;; Several non-printing chars change the searching behavior.
@@ -528,6 +571,7 @@ This is like `describe-bindings', but displays only Isearch keys."
 ;; These are all set with setq while isearching
 ;; and bound locally while editing the search string.
 
+(defvar isearch-hint-count 0)
 (defvar isearch-forward nil)	; Searching in the forward direction.
 (defvar isearch-regexp nil)	; Searching for a regexp.
 (defvar isearch-word nil)	; Searching for words.
@@ -1340,15 +1384,30 @@ Use `isearch-exit' to quit without signaling."
   (isearch-push-state)
   (isearch-update))
 
-(defun isearch-repeat-forward ()
+(defun isearch-repeat-forward (arg)
   "Repeat incremental search forwards."
-  (interactive)
-  (isearch-repeat 'forward))
+  (interactive "p")
+  (while (> arg 0)
+    (isearch-repeat 'forward)
+    (setq arg (1- arg))
+    (setq isearch-hint-count (1+ isearch-hint-count)))
+  (while (< arg 0)
+    (isearch-repeat 'backward)
+    (setq arg (1+ arg))
+    (setq isearch-hint-count (1+ isearch-hint-count)))
+  (isearch-update))
 
-(defun isearch-repeat-backward ()
+(defun isearch-repeat-backward (arg)
   "Repeat incremental search backwards."
-  (interactive)
-  (isearch-repeat 'backward))
+  (interactive "p")
+  (while (> arg 0)
+    (isearch-repeat 'backward)
+    (setq arg (1- arg))
+    (setq isearch-hint-count (1+ isearch-hint-count)))
+  (while (< arg 0)
+    (isearch-repeat 'forward)
+    (setq arg (1+ arg)))
+  (setq isearch-hint-count (1+ isearch-hint-count)))
 
 (defun isearch-toggle-regexp ()
   "Toggle regexp searching on or off."
@@ -2627,6 +2686,7 @@ since they have special meaning in a regexp."
 (defvar isearch-lazy-highlight-word nil)
 (defvar isearch-lazy-highlight-forward nil)
 (defvar isearch-lazy-highlight-error nil)
+(defvar isearch-lazy-highlight-hint-count nil)
 
 (defun lazy-highlight-cleanup (&optional force)
   "Stop lazy highlighting and remove extra highlighting from current buffer.
@@ -2671,6 +2731,9 @@ by other Emacs features."
 			 isearch-lazy-highlight-window-end))
 		 (not (eq isearch-forward
 			  isearch-lazy-highlight-forward))
+		 (not (eq isearch-lazy-highlight-hint-count
+			  isearch-hint-count))
+
 		 ;; In case we are recovering from an error.
 		 (not (equal isearch-error
 			     isearch-lazy-highlight-error))))
@@ -2693,6 +2756,7 @@ by other Emacs features."
 	  isearch-lazy-highlight-regexp       isearch-regexp
 	  isearch-lazy-highlight-space-regexp search-whitespace-regexp
 	  isearch-lazy-highlight-word         isearch-word
+	  isearch-lazy-highlight-hint-count   isearch-hint-count
 	  isearch-lazy-highlight-forward      isearch-forward)
       (unless (equal isearch-string "")
 	(setq isearch-lazy-highlight-timer
@@ -2739,7 +2803,8 @@ Attempt to do the search exactly the way the pending Isearch would."
   "Update highlighting of other matches for current search."
   (let ((max lazy-highlight-max-at-a-time)
         (looping t)
-        nomore)
+        nomore
+	(count 1))
     (with-local-quit
       (save-selected-window
 	(if (and (window-live-p isearch-lazy-highlight-window)
@@ -2773,8 +2838,14 @@ Attempt to do the search exactly the way the pending Isearch would."
 			      (forward-char -1)))
 
 			;; non-zero-length match
-			(let ((ov (make-overlay mb me)))
+			(let ((ov (make-overlay mb me)) hint)
 			  (push ov isearch-lazy-highlight-overlays)
+			  (if (not isearch-lazy-highlight-wrapped)
+			      (progn
+				(setq hint (number-to-string count))
+				(setq count (1+ count))
+				(set-text-properties 0 (length hint) '(face lazy-highlight-hint) hint)
+				(overlay-put ov 'before-string hint)))
 			  ;; 1000 is higher than ediff's 100+,
 			  ;; but lower than isearch main overlay's 1001
 			  (overlay-put ov 'priority 1000)

Re: [EXPERIMENTAL PATCH] Extending Isearch-repeat-forward/backward to support a prefix argument following suggesion by Juri Linkov

[Tassilo Horn]

Gideon Stupp <gideon.stupp@gmail.com> writes:

Hi Gideon,

> This experimental patch implements a suggestion by Juri Linkov to extend
> isearch-repeat-forward/backward to support a prefix argument.

I like it.  I adapted it a bit to show the hints at the position where
point would be if that one's selected, and I added also a bit
superscript magic, which suits me better, visually.  (Well, that should
be customizable, of course.)

But how the heck is the usage of the prefix arg supposed to work?  When
I do C-s foo C-3, isearch is exited...

Bye,
Tassilo

Re: [EXPERIMENTAL PATCH] Extending Isearch-repeat-forward/backward to support a prefix argument following suggesion by Juri Linkov

[Tassilo Horn]

[-- Attachment #1: Type: text/plain, Size: 482 bytes --]

Tassilo Horn <tassilo@member.fsf.org> writes:

>> This experimental patch implements a suggestion by Juri Linkov to
>> extend isearch-repeat-forward/backward to support a prefix argument.
>
> I like it.  I adapted it a bit to show the hints at the position where
> point would be if that one's selected, and I added also a bit
> superscript magic, which suits me better, visually.  (Well, that should
> be customizable, of course.)

Ups, I forgot to attach the patch.

Bye,
Tassilo

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2: isearchnavjuri.patch --]
[-- Type: text/x-patch, Size: 6509 bytes --]

=== modified file 'lisp/isearch.el'
--- lisp/isearch.el	2012-01-19 07:21:25 +0000
+++ lisp/isearch.el	2012-01-26 18:32:18 +0000
@@ -333,6 +333,21 @@
                                 'lazy-highlight-face
                                 "22.1")
 (defvar lazy-highlight-face 'lazy-highlight)
+
+(defface lazy-highlight-hint
+  '((((class color) (min-colors 88) (background light))
+     (:background "paleturquoise" :bold t))
+    (((class color) (min-colors 88) (background dark))
+     (:background "paleturquoise4" :bold t))
+    (((class color) (min-colors 16))
+     (:background "turquoise3" :bold t))
+    (((class color) (min-colors 8))
+     (:background "turquoise3" :bold t))
+    (t (:underline t)))
+  "Face for lazy highlighting hints."
+  :group 'lazy-highlight
+  :group 'basic-faces)
+
 \f
 ;; Define isearch help map.
 
@@ -417,10 +432,25 @@
     ;; We need these explicit definitions because, in a dense keymap,
     ;; the binding for t does not affect characters.
     ;; We use a dense keymap to save space.
+
     (while (< i ?\s)
       (define-key map (make-string 1 i) 'isearch-other-control-char)
       (setq i (1+ i)))
 
+    ;; Bring universal-argument and friends back in
+    (define-key map "\C-u" 'universal-argument)
+    (define-key map (kbd "C--") 'negative-argument)
+    (define-key map (kbd "C-0") 'digit-argument)
+    (define-key map (kbd "C-1") 'digit-argument)
+    (define-key map (kbd "C-2") 'digit-argument)
+    (define-key map (kbd "C-3") 'digit-argument)
+    (define-key map (kbd "C-4") 'digit-argument)
+    (define-key map (kbd "C-5") 'digit-argument)
+    (define-key map (kbd "C-6") 'digit-argument)
+    (define-key map (kbd "C-7") 'digit-argument)
+    (define-key map (kbd "C-8") 'digit-argument)
+    (define-key map (kbd "C-9") 'digit-argument)
+
     ;; Single-byte printing chars extend the search string by default.
     (setq i ?\s)
     (while (< i 256)
@@ -434,7 +464,20 @@
     ;; default local key binding for any key not otherwise bound.
     (let ((meta-map (make-sparse-keymap)))
       (define-key map (char-to-string meta-prefix-char) meta-map)
-      (define-key map [escape] meta-map))
+      (define-key map [escape] meta-map)
+    (define-key meta-map (kbd "-") 'negative-argument)
+    (define-key meta-map (kbd "C--") 'negative-argument)
+    (define-key meta-map (kbd "C-0") 'digit-argument)
+    (define-key meta-map (kbd "C-1") 'digit-argument)
+    (define-key meta-map (kbd "C-2") 'digit-argument)
+    (define-key meta-map (kbd "C-3") 'digit-argument)
+    (define-key meta-map (kbd "C-4") 'digit-argument)
+    (define-key meta-map (kbd "C-5") 'digit-argument)
+    (define-key meta-map (kbd "C-6") 'digit-argument)
+    (define-key meta-map (kbd "C-7") 'digit-argument)
+    (define-key meta-map (kbd "C-8") 'digit-argument)
+    (define-key meta-map (kbd "C-9") 'digit-argument))
+
     (define-key map (vector meta-prefix-char t) 'isearch-other-meta-char)
 
     ;; Several non-printing chars change the searching behavior.
@@ -528,6 +571,7 @@
 ;; These are all set with setq while isearching
 ;; and bound locally while editing the search string.
 
+(defvar isearch-hint-count 0)
 (defvar isearch-forward nil)	; Searching in the forward direction.
 (defvar isearch-regexp nil)	; Searching for a regexp.
 (defvar isearch-word nil)	; Searching for words.
@@ -1340,15 +1384,30 @@
   (isearch-push-state)
   (isearch-update))
 
-(defun isearch-repeat-forward ()
+(defun isearch-repeat-forward (arg)
   "Repeat incremental search forwards."
-  (interactive)
-  (isearch-repeat 'forward))
+  (interactive "p")
+  (while (> arg 0)
+    (isearch-repeat 'forward)
+    (setq arg (1- arg))
+    (setq isearch-hint-count (1+ isearch-hint-count)))
+  (while (< arg 0)
+    (isearch-repeat 'backward)
+    (setq arg (1+ arg))
+    (setq isearch-hint-count (1+ isearch-hint-count)))
+  (isearch-update))
 
-(defun isearch-repeat-backward ()
+(defun isearch-repeat-backward (arg)
   "Repeat incremental search backwards."
-  (interactive)
-  (isearch-repeat 'backward))
+  (interactive "p")
+  (while (> arg 0)
+    (isearch-repeat 'backward)
+    (setq arg (1- arg))
+    (setq isearch-hint-count (1+ isearch-hint-count)))
+  (while (< arg 0)
+    (isearch-repeat 'forward)
+    (setq arg (1+ arg)))
+  (setq isearch-hint-count (1+ isearch-hint-count)))
 
 (defun isearch-toggle-regexp ()
   "Toggle regexp searching on or off."
@@ -2627,6 +2686,7 @@
 (defvar isearch-lazy-highlight-word nil)
 (defvar isearch-lazy-highlight-forward nil)
 (defvar isearch-lazy-highlight-error nil)
+(defvar isearch-lazy-highlight-hint-count nil)
 
 (defun lazy-highlight-cleanup (&optional force)
   "Stop lazy highlighting and remove extra highlighting from current buffer.
@@ -2671,6 +2731,9 @@
 			 isearch-lazy-highlight-window-end))
 		 (not (eq isearch-forward
 			  isearch-lazy-highlight-forward))
+		 (not (eq isearch-lazy-highlight-hint-count
+			  isearch-hint-count))
+
 		 ;; In case we are recovering from an error.
 		 (not (equal isearch-error
 			     isearch-lazy-highlight-error))))
@@ -2693,6 +2756,7 @@
 	  isearch-lazy-highlight-regexp       isearch-regexp
 	  isearch-lazy-highlight-space-regexp search-whitespace-regexp
 	  isearch-lazy-highlight-word         isearch-word
+	  isearch-lazy-highlight-hint-count   isearch-hint-count
 	  isearch-lazy-highlight-forward      isearch-forward)
       (unless (equal isearch-string "")
 	(setq isearch-lazy-highlight-timer
@@ -2739,7 +2803,8 @@
   "Update highlighting of other matches for current search."
   (let ((max lazy-highlight-max-at-a-time)
         (looping t)
-        nomore)
+        nomore
+	(count 1))
     (with-local-quit
       (save-selected-window
 	(if (and (window-live-p isearch-lazy-highlight-window)
@@ -2773,8 +2838,19 @@
 			      (forward-char -1)))
 
 			;; non-zero-length match
-			(let ((ov (make-overlay mb me)))
+			(let ((ov (make-overlay mb me)) hint)
 			  (push ov isearch-lazy-highlight-overlays)
+			  (if (not isearch-lazy-highlight-wrapped)
+			      (progn
+				(setq hint (number-to-string count))
+				(setq count (1+ count))
+				(set-text-properties 0 (length hint)
+						     '(face lazy-highlight-hint
+							    display ((height 0.7) (raise 0.3)))
+						     hint)
+				(if isearch-lazy-highlight-forward
+				    (overlay-put ov 'after-string hint)
+				  (overlay-put ov 'before-string hint))))
 			  ;; 1000 is higher than ediff's 100+,
 			  ;; but lower than isearch main overlay's 1001
 			  (overlay-put ov 'priority 1000)

Re: Re: [EXPERIMENTAL PATCH] Extending Isearch-repeat-forward/backward to support a prefix argument

[gideon.stupp]

[-- Attachment #1: Type: text/plain, Size: 818 bytes --]

hmm. It shouldn't exit. I probably have a bug in the patch (that's the  
problem with experimental patches ;)). I will look at it again in (my)  
morning.

Thanks, Gideon.

On , Tassilo Horn <tassilo@member.fsf.org> wrote:
> Gideon Stupp gideon.stupp@gmail.com> writes:



> Hi Gideon,



> > This experimental patch implements a suggestion by Juri Linkov to extend

> > isearch-repeat-forward/backward to support a prefix argument.



> I like it. I adapted it a bit to show the hints at the position where

> point would be if that one's selected, and I added also a bit

> superscript magic, which suits me better, visually. (Well, that should

> be customizable, of course.)



> But how the heck is the usage of the prefix arg supposed to work? When

> I do Cs foo C-3, isearch is exited...



> Bye,

> Tassilo


[-- Attachment #2: Type: text/html, Size: 1179 bytes --]

Re: Re: Re: [EXPERIMENTAL PATCH] Extending Isearch-repeat-forward/backward to support a prefix argum

[gideon.stupp]

[-- Attachment #1: Type: text/plain, Size: 1217 bytes --]

Oh, I just thought of something. If you try to patch isearch.el and then  
load-file it the new keybindings won't take place (the map is defvar'ed). I  
think you have to compile isearch.el to isearch.elc and then run with  
temacs.

Hope this helps,

Gideon.

On , gideon.stupp@gmail.com wrote:
> hmm. It shouldn't exit. I probably have a bug in the patch (that's the  
> problem with experimental patches ;)). I will look at it again in (my)  
> morning.

> Thanks, Gideon.

> On , Tassilo Horn tassilo@member.fsf.org> wrote:
> > Gideon Stupp gideon.stupp@gmail.com> writes:
> >
> >
> >
> > Hi Gideon,
> >
> >
> >
> > > This experimental patch implements a suggestion by Juri Linkov to  
> extend
> >
> > > isearch-repeat-forward/backward to support a prefix argument.
> >
> >
> >
> > I like it. I adapted it a bit to show the hints at the position where
> >
> > point would be if that one's selected, and I added also a bit
> >
> > superscript magic, which suits me better, visually. (Well, that should
> >
> > be customizable, of course.)
> >
> >
> >
> > But how the heck is the usage of the prefix arg supposed to work? When
> >
> > I do Cs foo C-3, isearch is exited...
> >
> >
> >
> > Bye,
> >
> > Tassilo
> >

[-- Attachment #2: Type: text/html, Size: 1703 bytes --]

Re: [EXPERIMENTAL PATCH] Extending Isearch-repeat-forward/backward to support a prefix argument following suggesion by Juri Linkov

[Tassilo Horn]

Tassilo Horn <tassilo@member.fsf.org> writes:

> But how the heck is the usage of the prefix arg supposed to work?
> When I do C-s foo C-3, isearch is exited...

That was my fault.  Of course, loading the patched isearch.el didn't
make the changed isearch-mode-map active (defvar).  It works fine, now.

Usability-wise, C-s foo C-<number> C-s makes only sense if that
keystroke is shorter to type than C-s multiple times.  So maybe the
numbering should start with some offset, say, with the 5th next match?

And the typing of C-s after the number is a bit inconvenient, so maybe,
C-7 could jump directly to the match hinted with 7, and only for
two-digit matches C-s was needed, i.e., C-u 1 2 C-s to jump to the 12th
match?

Bye,
Tassilo

bug#10614: [EXPERIMENTAL PATCH] Extending Isearch-repeat-forward/backward to support a prefix argument following suggesion by Juri Linkov

[Jérémy Compostella]

[-- Attachment #1: Type: text/plain, Size: 1328 bytes --]

2012/1/26 Tassilo Horn <tassilo@member.fsf.org>

> Tassilo Horn <tassilo@member.fsf.org> writes:
>
> > But how the heck is the usage of the prefix arg supposed to work?
> > When I do C-s foo C-3, isearch is exited...
>
> That was my fault.  Of course, loading the patched isearch.el didn't
> make the changed isearch-mode-map active (defvar).  It works fine, now.
>
> Usability-wise, C-s foo C-<number> C-s makes only sense if that
> keystroke is shorter to type than C-s multiple times.  So maybe the
> numbering should start with some offset, say, with the 5th next match?
>
> And the typing of C-s after the number is a bit inconvenient, so maybe,
> C-7 could jump directly to the match hinted with 7, and only for
> two-digit matches C-s was needed, i.e., C-u 1 2 C-s to jump to the 12th
> match?
>
>
I just played play with it too and I really like it. Here my notes:
- I do agree with Tassilo, C-7 should directly jump to match hinted 7.
- When more than lazy-highlight-max-at-a-time are visible in the window,
  the prefix number is restarted from 1 on the next match hinted. It's
confusing
  and I think it should not appear on these items.
- A defcustom variable should be added to enable/disable the match hinted
prefix
  number.

Anyway, it's an very interesting improvement.

Jérémy

[-- Attachment #2: Type: text/html, Size: 1815 bytes --]

bug#10614: [EXPERIMENTAL PATCH] ExtendingIsearch-repeat-forward/backward to support a prefix argumentfollowing suggesion by Juri Linkov

[Drew Adams]

Please do not send stuff to both emacs-devel and the bug list.

bug#10614: [EXPERIMENTAL PATCH] Extending Isearch-repeat-forward/backward to support a prefix argument following suggesion by Juri Linkov

[Lars Ingebrigtsen]

Gideon Stupp <gideon.stupp@gmail.com> writes:

> This experimental patch implements a suggestion by Juri Linkov to
> extend isearch-repeat-forward/backward to support a prefix
> argument. Instead of pressing C-s / C-r multiple times it is possible
> with this patch to enter a prefix argument which runs the command
> multiple times for you. If a negative argument is given for
> isearch-repeat-forward then isearch-repeat-backward is run and visa
> versa. Visual hints are added to the matched strings to help figure
> out what argument should be given.

Hm...  I guess I can see why this would be attractive, but I'm a bit
sceptical.  Numeric prefixes make sense in many instances, but I would
myself never this "hm, I must repeat the search three times"...  I would
just hit `C-s' four times instead.  That seems faster and more
convenient...

-- 
(domestic pets only, the antidote for overdose, milk.)
   bloggy blog: http://lars.ingebrigtsen.no

bug#10614: [EXPERIMENTAL PATCH] Extending Isearch-repeat-forward/backward to support a prefix argument following suggesion by Juri Linkov

[Juri Linkov]

>> This experimental patch implements a suggestion by Juri Linkov to
>> extend isearch-repeat-forward/backward to support a prefix
>> argument. Instead of pressing C-s / C-r multiple times it is possible
>> with this patch to enter a prefix argument which runs the command
>> multiple times for you. If a negative argument is given for
>> isearch-repeat-forward then isearch-repeat-backward is run and visa
>> versa. Visual hints are added to the matched strings to help figure
>> out what argument should be given.
>
> Hm...  I guess I can see why this would be attractive, but I'm a bit
> sceptical.  Numeric prefixes make sense in many instances, but I would
> myself never this "hm, I must repeat the search three times"...  I would
> just hit `C-s' four times instead.  That seems faster and more
> convenient...

What if you need to visit a Nth occurrence where N is larger
than the number of keystrokes with numeric prefixes
(while using isearch for navigation)?

bug#10614: [EXPERIMENTAL PATCH] Extending Isearch-repeat-forward/backward to support a prefix argument following suggesion by Juri Linkov

[Lars Ingebrigtsen]

Juri Linkov <juri@jurta.org> writes:

> What if you need to visit a Nth occurrence where N is larger
> than the number of keystrokes with numeric prefixes
> (while using isearch for navigation)?

I still don't think I'd want to enter a number.  I'd either stop doing
isearch if it was too far away (and just move the cursor where I wanted
it to be), or I'd hit `C-s' a lot.

-- 
(domestic pets only, the antidote for overdose, milk.)
   bloggy blog: http://lars.ingebrigtsen.no

bug#10614: [EXPERIMENTAL PATCH] Extending Isearch-repeat-forward/backward to support a prefix argument following suggesion by Juri Linkov

[Lars Ingebrigtsen]

Lars Ingebrigtsen <larsi@gnus.org> writes:

> Juri Linkov <juri@jurta.org> writes:
>
>> What if you need to visit a Nth occurrence where N is larger
>> than the number of keystrokes with numeric prefixes
>> (while using isearch for navigation)?
>
> I still don't think I'd want to enter a number.  I'd either stop doing
> isearch if it was too far away (and just move the cursor where I wanted
> it to be), or I'd hit `C-s' a lot.

Nobody else weighed in three years ago, so I'm closing this bug report.
The "counting and jumping" thing seems so vim-like to me.  :-)

-- 
(domestic pets only, the antidote for overdose, milk.)
   bloggy blog: http://lars.ingebrigtsen.no