Replace . with -> in specific places

Question

Sometimes I need to replace . with -> when fixing code.

Usually search and replace cannot be used because there will be many (hundreds of) dots (.) and only a few ones of them must be changed.

However, I find the ones that need to be changed when I am going through a make changelist.

Using the repetition operator does not quite work because if I change one instance and then repeat with the dot command, then I get this:

structBlah->.memberBlah

If I then use x to delete the extraneous dot, then paste and dot no longer work because the last change was a delete.

So, basically the problem is that the repetition operator repeats a motion and an edit, whereas here we need to repeat two edits: a delete and an insert.

Is there any convenient way to do this? One idea I had was to maybe use a macro like this:

xi-><ESC>

Answer 1

The cw(change word) command will solve your problem.

Put your cursor on the period and type cw-><Escape>

something.somethingelse

turns into

something->somethingelse

and the . operator will still work, because cw is one operation that does both the deletion and substitution.

Answer 2

You could use the s operator, which deletes the character under your cursor and puts you in insert mode. You can then type the replacement and later use . to repeat the whole replacement. Workflow becomes:

1. /\. to highlight all periods.
2. n to first dot
3. s-> and then Esc. This will replace the dot and insert the text with a single operation.
4. n to next dot
5. . to change when needed.

:h s for more info.

Answer 3

I recommande using the substitute command:

:%s/\./->/gc

This will:

:%s     substitute over all lines
/\.     match dot
/->     replace by arrow
/g      replace all on lines
c       ask for confirmation

This will go through all . of your file and asking each time if you want to substitute.

Press y for substitute, n to go to the next dot.

see :h :s_c for all options.

Answer 4

If you don't want to use a substitution or the dot command as suggested by the other answers your best bet is probably to create a macro which you can use when your cursor is next to a dot.

You can record the macro

qaf.vc->^[q

Which will go to the following dot on the line (f.) visually select it (v) and replace it (c->).

Now when you navigate your code and you spot a dot which should be changed you can call the macro with @a.

You can even put that in your .vimrc to keep the macro between you different coding sessions:

let @a="f.vc->^["

---

Edit @grochmal suggested in the comments to use a second register to have a backward moving macro which seems pretty useful:

let @e="F.vc->^["