Efficient copy->paste onto mark

Question

I typically write all my software in the same way (omitting the TDD parts):

1. Iterate pseudo code until it is granular enough that each part can be written in, hopefully, under 20 minutes.
2. Implement each "pseudo"-component

Contrived example:

# Get file
# Open file
# Verify integrity
# Parse
# Close file

To encourage modularity i typically don't write these functions in "one" block. I write them in separate files or at least separate blocks and then "paste" them in. This is to ensure I'm not encouraged to add unnecessary dependencies. Right now, I'm literally copy->move to pseudocode-line->Paste over it with block of code, a function or method name, or whatever copy represents. This works very well for me and the code turns out nice. However, being lazy, I don't want to have to touch the mouse or do too much if there's a way to do it with less effort. I'm looking for a way to select->copy->replace a pseudocode-line with the selected:

In file Parse.c:

int ParseMyFile(char* fileName)
{
  # Get file
  return 0;
}

I would then write # Get file in another file or buffer:

{GetFileSomehow}

As a next step I would love to just mark this block of code, and replace # Get file with the block to produce:

int ParseMyFile(char* fileName)
{
  {GetFileSomehow}
  return 0;
}

I tried experimenting with marks to copy&paste "onto" a mark, but it did not work well enough. I copied->move to mark-> replace line. I would love to get this down to copy->replace. I can not download extensions. I only have access to standard Vim. It must be less effort than physically marking the block, navigate to the correct pseudo-line, and paste it. It may not sound like a lot of work, but I write even very small blocks of code like this, as little as 2-3 lines if it helps me reason about the code. It adds up.

Answer 1

The ex commands :put and :delete both allow you to specify a line, so if you've already placed mark 'a on the line you want replaced, then you can execute the following after the copy:

:'apu
:'ad

or as a one liner:

:'apu|'ad

If you haven't placed a mark, you could specify the line using a search instead:

:/# Get here/pu
://d

Or, again, as a one liner:

:/# Get here/pu|//d

I'm not convinced this is actually any more efficient than Doktor OSwaldo's suggestion—it's certainly more keystrokes—but perhaps it aligns better with your mental model.

Answer 2

Alternative solution:

If you want to replace the text at the mark, you could just use

:norm!'aVp``

Or in one line with the copy:

:'<,'>y | norm!'aVp``

Answer 3

One approach:

Go to the # Get file line, delete it (e.g., dd), and then :read your file starting from the previous line:

:-read otherfile

This only works if you save the file though.

However, you can write it as one sequence of commands:

:/# Get file/delete | -read otherfile

---

If you have the contents in a register from a previous yank, you can use (e.g.)

:put! a

Instead of -read otherfile. Substitute a for the register you yanked to (or nothing for the default register).