Moving around

Motions and counts

Every motion works on its own or as the target of an operator (dw, c$, y}), and a count goes where vim puts it: 5j, 3w, d3w. Two counts multiply — 2d3w deletes six words.

Jump to anything on screen: s

Most of the time the place you want is already on screen, a few rows away. s is for that: the screen dims the moment you press it, then every match of what you type gets a letter after it. Press the letter and you are on the first character of that match. No Enter anywhere.

lstring.c Jump with s 1 / 4 play

1. start The cursor is on line 95.
2. 1 s s dims the screen at once.
3. 2 ta Type a few characters. Every match on screen lights up with a letter after it.
4. 3 k Press a match’s letter. The cursor lands on the first character of that match.

• Only the viewport is searched: this is a jump, not a search.
• The letters never include a character that could narrow the search, so you can keep typing or jump at any moment without switching modes.
• Letters are inserted between cells, so the text after a match stays readable.
• Smartcase, like /. Backspace takes a character back, Esc leaves, and a query that matches nothing leaves by itself.

Walk the structure: ]] and [[

The parse tree knows where every block and argument list starts and ends. ]] and [[ walk those edges the way w walks words: every start and end of a multi-line block is a stop, and so is every argument, so ]] inside a signature hops parameter to parameter. :ts paints every stop on screen, and stays on until :ts again.

lstring.c Walk the parse tree 1 / 5 play

1. start The cursor is at the start of luaS_resize.
2. 1 :tsEnter :ts dims the text and lights every boundary.
3. 2 ]] ]] stops at the ( that opens the parameter list.
4. 3 ]] Next stop: where the first parameter starts.
5. 4 ]] Then where it ends. Each argument’s start and end is a stop.

At the last boundary ]] stays put rather than wrapping. In a file bi has no grammar for, both keys say no syntax tree here.

Search

A search is a motion, so d/foo works and stops just before the match. An all-lowercase pattern matches either case; a capital anywhere makes it case-sensitive. A bare / repeats the last pattern.

What a search leaves behind is the footer. While a search is live the footer shows only the search: the pattern, prefixed with the direction you are travelling, and [4/11] — which match you are on, out of how many.

lstring.c Search and its counter 1 / 6 play

1. start The cursor is on line 95.
2. 1 /osize / starts a search; the footer is the search line.
3. 2 Enter Enter jumps to the first match. The footer shows which match, out of how many.
4. 3 nn n twice: the count follows.
5. 4 N N goes back, and the pattern reads ?osize, the direction you travelled.
6. 5 j Any other key ends the search and the footer returns.

The jump list

Big moves are jumps: G, gg, :{n}, /, ?, n, N, *, #, %, {, }, gd, a picker, :e, :b, Ctrl-^. Ctrl-O goes back to where you were before one, across files, and Ctrl-I goes forward again. Small motions you can see — w, j, f — are not recorded.

The list belongs to the window, not to the file in it. A pane that displaces the text — :find’s results, :results, a tree, a picture — records the place it displaced, so Ctrl-O after Enter on a hit goes back to where you typed :find. Going text → tree → a different file keeps the list too.

lstring.c % and the jump list 1 / 6 play

1. start The cursor is on the { that opens the block on line 102.
2. 1 % % goes to the matching } on line 106. That was a jump.
3. 2 G G jumps to the last line: a second jump.
4. 3 Ctrl-O Ctrl-O goes back to where G started, line 106.
5. 4 Ctrl-O Again: back to where % started, line 102.
6. 5 Ctrl-I Ctrl-I goes forward again.

Scrolling