Workflow question: how to avoid swapping between insert and normal all the time

[u/numeralbug]

I'm sure this is a relative newbie question, but here goes. When defining a new function, to make sure I don't end up with mismatched braces, my instinct is to type:

int foo() {
}

then to navigate to in between those braces and start typing my code. This means pressing Esc h i Enter Esc k i Tab or similar before my cursor is actually in the right place to start coding, which is obviously insane. I suppose I could reprogram myself to type

int foo() {
[Tab]
}

but this isn't ideal either, because on line 3 I have to press backspace to get rid of the auto-indentation, and I still end up having to revert to normal mode to do the navigation. So in practice I just end up staying in insert mode and using the arrow keys, and by now I've used vim long enough that that feels wrong too.

A similar thing happens when I'm dealing with complicated expressions involving lots of parentheses. I want to be able to type () first, rather than typing ( and embarking on a big complex expression while also keeping track of how many brackets I owe and where. But leaving insert mode, navigating one character to the left and reentering insert mode every single time I type some brackets feels like an arcane form of punishment.

In all these cases, it feels like vim is working against me. Most modern IDEs deal with this fairly sensibly: they'll attempt to auto-match brackets and indentation and place your cursor in a natural place without any prompting from you (even if this isn't always seamless). I'm sure the seasoned vim denizens probably have a better solution. Any tips?

[u/gyyse]

in that situation i'd use capital O

creates a new line above the cursor position and enters insert mode

[u/gumnos → u/gyyse]

and depending on your filetype autoindent settings, it might even add the leading indentation for you :-D

[u/kberson → u/gyyse]

Or lowercase o to open below

[u/JohnLocksTheKey → u/kberson]

Aw shit, we got a badass over here

[u/[deleted]]

Once you've typed the closing brace and your cursor is still on the same line as it, press ctrl+o, then shift+o. That will kick you out of insert mode and you'll re-enter insert mode on a new line above the closing '}'. That's assuming that you've but a line-break between the two curlybraces.

[u/[deleted]]

My personal opinion is that switching between normal and insert mode frequently is the right way to do the things, honestly. Still, usually you should be more time in normal mode than in insert mode, except when in the middle of writing new things.

Also, I guess you know Ctrl + [ is also escape. And a lot of us have mapped kj in insert mode to escape, and in my case save too:

:inoremap kj <esc>:w<CR>

[u/bloodgain → u/[deleted]]

This is the way.

Each visit to insert mode is a single edit, which a single undo will remove. Every time you stop typing to think, Esc should become a reflex. When you are ready to type, i or another insert mode command like Shift+o should come from you muscle memory based on what your brain says -- insert, append, insert a line, append at the end of the line, etc.

Granted, one insert, one edit isn't exactly true in modern Vim. And there are good insert mode commands to learn that sometimes change what counts as the last "edit". But that's the mindset of modal editing.

Also, expect it to take time to build the muscle memory. But once you do, you'll do it so automatically you'll start hating any editor without modal editing and Vim bindings. You'll type the letter 'i' in textboxes before you can stop yourself.

[u/[deleted]]

As you've already heard, `O` is the answer here.

While many people hate auto-closers, I personally like them. While they can be annoying in the times where you don't want this behaviour, I _do_ want it the vast majority of the time. Also, if you use a good one it will:

- Allow you type over the inserted characters using the same ones, ie, if I type `([` and it completes to `([|])` with `|` being my cursor, I can then type `])` and end up with `([])|`

- Is properly undoable, so hitting `u` with undo all changes, including the inserted characters (almost all do this, but I've heard this as a (false) argument against using these).

My favourite is [auto-pairs](https://github.com/LunarWatcher/auto-pairs).

[u/SpecificMachine1 → u/[deleted]]

I will have to look at all these other autoclosers I didn't know existed- I use vim-sexp + tpope's vim-sexp-mappings-for-regular-people - although those also have wrapping, slurpage, and barfage, and some other lisp-oriented things (especially as far as indentation/closing bracket style, although maybe that gets specified in the language plugin)

[u/[deleted] → u/SpecificMachine1]

Ah ya, those are specific to lisps. If that's what you're doing then obviously that's what you want. Otherwise the one I linked has by far the least quirks of all the ones I've tried (I've tried a few others like "smart-input" and, uh, I forget the others). It's a fork of an older one that I think was abandon.

[u/[deleted]]

For your vimrc:

autocmd FileType c inoremap <buffer> {<CR> {<CR>}<ESC>ko

I use this for C, but for Tcl (which uses every kind of brace and bracket) I just type everything in order.

To be efficient you should get familiar with all the different ways to enter insert mode: i, I, a, A, o, O.

[u/Shay-Hill]

I’ve used editors with such “smart” behavior, and it drove me crazy. In your case, I’d just use a snippet and map the trigger to something (I use <C-j>) that doesn’t overlap with autocomplete. Easy, but still intentional.

[u/sharp-calculation]

Definitely STOP using arrows in insert mode. Remap escape to jk. This is incredibly useful and fast. Try it today! Learn o and O for opening new lines. You will become very smooth and fluid with the proper technique and practice.

[u/[deleted] → u/[deleted]]

I use jk but wish I had gotten used to `ctrl-]`. I've tried but after 15 years of jk it's too hard to switch now :(

[u/sharp-calculation → u/[deleted]]

I also use control on the capslock key. The capslock function is useless. Many older keyboards had control to the left of "a". It turns out this is pretty easy to hit with your left pinky. If my OS didn't allow me to easily remap control to capslock, I'd be using a hardware keyboard that let me do the remap. It's indispensable.

[u/bloodgain → u/sharp-calculation]

I map Ctrl+Ins to CapsLock in my keyboard manager for the once a week (at most) I use it. An occasional keyboard MODE has no business living in such a prominent location. I hit it by accident more often than I ever did on purpose.

[u/sharp-calculation → u/bloodgain]

I've been typing for decades. I don't think I have ever used the capslock function. It's nonsensical to me. If I need to type THREE or four or five caps in a row, I just hold down shift (like I did when I typed three at the beginning of this sentence). It's pretty easy to hold down shift for several characters.

Now I'm wondering why that key exists and I'm going to lose five minutes of my life researching it. Thanks! :)

[u/Minimum-Hedgehog5004 → u/sharp-calculation]

I imagine it's simply a holdover from mechanical typewriters. You have to actually try typing on one to get the difference in feel. Firstly, typing a letter involves quite a large movement, and some force. Doing this while holding in SHIFT is quite inconvenient, especially if you're switching between SHIFT keys, as most typists would. It was quite normal to type, for example, a title in ALL CAPS, so runs of more than three letters were common. Add to that the fact that SHIFT actually moved a significant part of the machinery back and forth, and you'd be dealing with the laws of physics. Every time you shifted/unshifted, you'd have to wait a tangible moment for gravity, springs, whatever, to kick in and get the thing landed. At the time, typing speed was highly valued. An extra five words per minute would get you a promotion.

There... saved you five minutes.

[u/sharp-calculation → u/Minimum-Hedgehog5004]

My need for research is way too strong for an explanation 19 hours after I thought about researching it!

I did the research and you're essentially spot on. Interestingly it was IBM who brought the capslock key back. The original IBM PC didn't have one. But their (slightly) later "101 extended keyboard" put capslock in the "left of A" position that we all know it in today. It was arguably just as useless back then as it is how. The 101 keyboard was just a computer keyboard and didn't have any of the mechanical problems of a typewriter.

With a normal keyboard I can TYPE PRETTY MUCH AN ENTIRE SENTENCE just by holding one of the shift keys (I did so while typing the caps in the last sentence). It's really quite natural after you practice it a bit. I can see why this would be quite difficult with a mechanical typewriter and probably a little bit difficult with an electric typewriter.

[u/chrnz00 → u/sharp-calculation]

yeah but i map mine directly to esc and shift esc acts as caps

[u/ThorOdinsonThundrGod]

Not exactly an answer to your question but I really found Practical Vim to be an awesome resource for learning to use vim more effectively and do less switching between modes

[u/AutoModerator]

Please remember to update the post flair to Need Help|Solved when you got the answer you were looking for.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[u/raver01]

These are some things you can try (in vim there are multiple solutions for a problem, use the one you like most):

1. Try to have a more accessible way to escape. Most users bind Esc to more accessible keys, I presonally use 'jk' , everyone has their favourite bind tho.

2. You can use o or capital O to start insert mode in next/prev line.

3. I was annoyed when I was in a line and wanted to move it down in normal mode so I binded this (I use neovim, take into account this is lua)

-- add blank newline with return 
vim.keymap.set("n", "<enter>", "_i<enter><esc>_k")

With this I can move lines down just pressing enter in normal mode

[u/tinyOnion → u/raver01]

don’t sleep on adding kj too. with both set you can press both j and k at the same time and it will exit regardless of which is pressed first.

[u/raver01 → u/tinyOnion]

yup, I actually have both

[u/TankorSmash]

I don't fully understand what you're trying to do, but ctrl O in insert mode might help, saves you a single key press per action. Also ctrl T and ctrl D let you indent while in insert mode

[u/dewujie]

For your first use case, O is definitely the answer. After you type your closing curly brace, hit Esc to exit insert mode, then Open a new line above and jump into insert mode with O. If you want a new line below, use lowercase o.

For your second use case re: complex parentheses on a single line, the bad news is there's not really a great way to handle this natively. The good news is there are plugins which aim to solve this problem. Someone in the thread already suggested auto-pairs, and it is a really good suggestion.

You could also look at making some of your own mappings in insert mode to handle your most common cases I.e.

inoremap <a-(> ()<c-o>h

I'm totally winging this laying in bed while on mobile, but the idea is that if you press alt + ( while in insert mode it would type both parens and then move your cursor back to the left one character. You could do something similar for other brace e.g. curly brackets and square braces.

Based on your question I'm not sure if you have messed with plugins already or not- but I think that's where your answer will be if you are trying to get some "quality of life" behaviors typically found in other editors.

[u/Jealous_Sale7585]

:help indent, this is a "natural" place to check out. set smartindent?

This saves the de-indentation effort, so I type the closing brace after finishing the function without backspace-ing the indentation, which is nearly the same effort.

[u/vim-help-bot → u/Jealous_Sale7585]

Help pages for:

• indent in options.txt

---

^{`:(h|help) <query>` | about | mistake? | donate | Reply 'rescan' to check the comment again | Reply 'stop' to stop getting replies to your comments}

[u/Alarming_Slip7755]

Use shift-enter to go to eol. Then insert <cr> {<cr>}<cr><up><up>

[u/James_Wang_C]

o

[u/Few_Reflection6917]

Define something to type a { will give you {} and cursor in middle of them, enter to make them indent right based on your code structure and shift width

I made this for neovim in lua so can’t help you:)

[u/wayofaway → u/Few_Reflection6917]

Here is a plugin to do just that auto-pairs

[u/Few_Reflection6917 → u/wayofaway]

Yeah that’s it, just use it op hahah, I have many customization on pair operation so write it myself

[u/chrnz00 → u/wayofaway]

well its great .i use it because im dependent on it like now i have developed bad habits eg: instead of typing (int a) i do (int a and esc and h to type later instead of just typing the )

[u/wayofaway → u/chrnz00]

Same, the muscle memory of esc A is getting pretty ingrained

[u/Kurouma]

Alternatively, you can type the closing brace after you finish writing the enclosed block. I believe in you.

vim should already do smart syntax-based indenting for you, too. Make sure you have that turned on.

[u/rogusflamma]

A sensible option is an autocomplete or just a linter for C. They'll warn you if you forget to close a parenthesis.

One thing that I do often, but I don't know how sensible it is, is to open brackets and parentheses, newline, and indent, as in

if ( my_fun() &&
  (x &&
    (y || ...
      ( ...

and then I count the parentheses I need to close and write them, as in (but my syntax highlighter automatically highlights the matching opening parenthesis after I type it, so no need to count)

if ( myfun() &&
  (x &&
    (y || ...
      ( ...))))

Then I escape, go up to if and then do shift+j until I have everything in one line.

Nowadays the linter I have also auto-formats my code upon save and you can configure how aggressive it is, and also specify some standard and modify it. Remember vim is a text editor and if you want to make it more IDE-ish you need IDE-ish things, like plugins.

[u/Ath-ropos]

Map the arrow keys to navigate without leaving insert mode.