Why does replace not accept a motion?

Question

A lot of operator like delete, change, indent, switch-case accept a motion to apply on.

For example, let say I want to replace the current word with all letter a, I do:

viwra

Compared to the imagined:

riwa

Why isn't it the same for the replace command?

It's obviously by design, do you know the reason behind this choice?

Answer 1

Actually. There is no reason, apart from things being as they are, that would be against an r operator. The simple fact that viwra works means that riwa could work. The reason is simply a historical one, but there is nothing against an alternative implementation. It can help 'filling' some area defined by a motion/text-object with a single character.

I think the main idea against it was that e.g. ri to replace the current character with i was found more useful (= often needed) than an operator which for that case would need more letters (rli would have probably sufficed for the above example: 'replace' operation + 'move one char to the right' motion + replacement char).

But what's nice with Vim is that anybody can come up with this alternative :) rri as "replace all chars in line with i" doesn't look too bad :)

Answer 2

Replace is a specific type of situation, that I don't believe is equivalent to the others you listed that take motions. r can take an optional count, but the action is the same. 3ra replaces 3 characters with the letter "a". In its current state, adding a motion would only allow for the repetition of the replace action. You could "replace word with the letter 'a'" but anything else would be the equivalent to just doing a change.

You can achieve the same outcome using visual selection. viwra would do a "Visual selection in word, replace with 'a'". You'll notice that a lot of other actions that only provide counts, have the same sort of "visual selection replacement for motion".

R version of replace is a mode so there wouldn't be any type of motion, similar to how there is no motion for any other mode.

Answer 3

Not an answer, but a piece of code I used to "simulate" the functionality of an operator with r:

function! ROperator()
  call inputsave()
  let l:replace_pattern = input('Replace > ')
  call inputrestore()

  if len(l:replace_pattern) != 3
    throw "Bad pattern size (expected 3)"
  endif

  let l:motion = strpart(replace_pattern, 0, 2)
  let l:char = strpart(replace_pattern, 2, 2)

  execute "normal! v".l:motion."r".l:char

endfunction

nnoremap gr :call ROperator()<CR>

This can be used like so ([] is the cursor position):

 This is a se[n]tence.

 griw*

 This is a **[*]****.