Vim navigation

[user202729]

Sometimes I'm quite annoyed that I inefficiently repeat STPH-BS ({#Down Down Down}{^}) or STPH-BG ({#Control_L(Right)}{^}) in Vim.

Previously I turn on "relative line number" feature and can reach any line in 2 strokes, but I don't always press the right number for some reasons, and navigating on the same line is still problematic.

What do you use? (vim-sneak? I think it would be quite hard to use because I don't think I can type s[1 in one or two strokes.) Something else?

This is an experiment with vim-easymotion. (Go to start of any word in 2 strokes. First stroke STPROEU, then stroke the tag. The dictionary is a 1/2-character fingerspelling dictionary)

• .vimrc:

let g:EasyMotion_keys = 'bdfgjklmnprstxz'
map \mw <Plug>(easymotion-bd-w)

• easymotion.py: (add this as a Python dictionary to Plover)

#!/bin/python
from typing import List

from plover.system import english_stenotype as e
from plover_python_dictionary_lib import get_context_from_system

context=get_context_from_system(e)
s=context.SingleDictionary

trigger_stroke="STPROEU"

left_hand=s({
	'PW':      'b',
	'TK':      'd',
	'TP':      'f',
	'TKPW':    'g',
	'SKWR':    'j',
	'K':       'k',
	'HR':      'l',
	'PH':      'm',
	'TPH':     'n',
	'P':       'p',
	'R':       'r',
	'S':       's',
	'T':       't',
	'KP':      'x',
	'STKPW':   'z',
	})

right_hand=s({
	'':        '',
	'-B':      'b',
	'-D':      'd',
	'-F':      'f',
	'-G':      'g',
	'-PBLG':   'j',
	'-BG':     'k',
	'-L':      'l',
	'-PL':     'm',
	'-PB':     'n',
	'-P':      'p',
	'-R':      'r',
	'-S':      's',
	'-T':      't',
	'-BGS':    'x',
	'-Z':      'z',
	})

dictionary=(
		s({
			trigger_stroke: "{#backslash m w}"
			})
		|
		context.stroke(trigger_stroke) / (left_hand*right_hand).map(lambda x: "{^}" + x + "{^}")
		)

lookup=lambda strokes: dictionary.lookup_tuple(strokes)
LONGEST_KEY=dictionary.longest_key

if __name__=="__main__":
	dictionary.print_items()

What do you think?

[icew4ll]

My approach to vim navigation may seem extreme but turns out quite efficient for vim and shell imo. I remove the spaces for all single letter characters and using the plugin hop I can navigate to any word in 1-5 strokes (depending on words on screen) which is equal to typing navigation.

[Josiah-tan]

just made a little plugin for the relative line number problem if you're interested?
https://github.com/Josiah-tan/plover-vim
you can also train on primeagen's plugin (to get better at relative line movement)
https://github.com/ThePrimeagen/vim-be-good
Thinking about putting other things in my plugin as well like for single character commands (to do)

I had some ideas on how we could make easymotion even better (thanks to Preoniky on discord)

Preoniky — 06/12/2021
Hmm... Steno order, basically. Although the user would have to set up a mode so that the strokes don't do any other thing.
So instead of ks, kg, lk etc, it would show ST, PW, HF and so on
Josiah — 06/12/2021
ah I think I see what you mean, that's a pretty good idea, perhaps we could extend this by removing the need for a mode, for example instead of fingerspelling random letters like ks, kg, and lk perhaps 2 letter strokeable words like "at", "by", or even symbols like "$" or "%" (which is an idea that may or may not be faster due to the mental overhead) could be utilized (if someone decides to develop this plugin for emacs / vim)
Another fun idea (but on a different train of thought) could be to switch to the mode (that you suggested above) in the same stroke during the initial stroke, this would deactivate the dictionary translation for navigation stroke before going back to normal steno mode for any other strokes after that.

[user202729]

The main issue with easymotion approach is that there's the delay between "label display" → "human process label" → human stroke". Instead if the jump is to the character already displayed I think there's less overhead. (

---

I also use these (some added recently)

Avoid switching normal/insert mode all the time

Although there isn't much point in using vim for this, vim is supposed to be modal (emacs is modeless) but I'm used to writing vimscript and inertia.

I have those mappings

nore <c-j> <nop>
inore <c-j> <c-\><c-o>
cnoremap <c-j> <esc>
set termwinkey=<c-j>

and some more mode-specific mappings, but the basic idea is that it's possible to map Plover stroke to <c-j> + normal mode vim command so it can be used in any mode.

Relative number

I have a system as well for 99 lines up/down per stroke (already mentioned above but I mistakenly write "2 strokes"?). This alone isn't very efficient, so I add the feature below.

Movement (recently added)

I have STPR*FP + word (1 stroke) to search (word) forward, and STPR*FPL + word (1 stroke) to search word backward.

Example STPR*FP/SRAOUL → jump to next occurrence of value.

Other vim bindings

My system is

• Unique prefix STPR
• Action: -R remove, -PB yank, *PB yank clipboard, -F visual, -RB shift left, -RPB shift right, -FR duplicate
• Range: -L line, -G character, -S inner, -Z outer, -DZ paragraph, -D word, -T WORD
• Special actions: -PBLG join below, -FT paste, *FT paste clipboard, UPG :up, -BLS some miscellaneous action
• Other actions: (A tab, O window) × (-R down, -B up, *F move down, *P move up)

Plan

• Integrate "movement" with "range", and add inclusive/exclusive as well so I can do e.g. "remove to last =, exclusive"

Miscellaneous note

I set up some common 2-strokes that can be 1-stroked to beep so it may be easier to get out of bad habits

[user202729]

Remove paragraph for me would be STPR-RDZ if I ever need it. The "action" and the "range" is in the same stroke (that's why they use separate sections of the right hand).

The relative movement dictionary itself is quite simple, you should be able to make one just with the idea

code

#!/bin/python3

# ======== boilerplate

from plover.system import english_stenotype as e  # type: ignore
from plover_python_dictionary_lib import get_context_from_system
from plover_stroke import BaseStroke  # type: ignore
context=get_context_from_system(e)
s=context.SingleDictionary

# ======== code

block1=s({
	"P"    : "1",
	"PH"   : "2",
	"H"    : "3",
	"PW"   : "4",
	"PWHR" : "5",
	"HR"   : "6",
	"W"    : "7",
	"WR"   : "8",
	"R"    : "9",
	"PR"   : "0",
	"WH"   : "0",
	"PWH"  : "00",
	"PHR"  : "00",
	"PWR"  : "00",
	"WHR"  : "00",
})
block2=s({
	"-F"   : "1",
	"-FP"  : "2",
	"-P"   : "3",
	"-FR"  : "4",
	"-FRPB": "5",
	"-PB"  : "6",
	"-R"   : "7",
	"-RB"  : "8",
	"-B"   : "9",
	"-FB"  : "0",
	"-RP"  : "0",
	"-FRP" : "00",
	"-FPB" : "00",
	"-FRB" : "00",
	"-RPB" : "00",
})

dictionary=(
		s({
			"#AE"  : lambda x: ("{#control(j) " + ' '.join(x) + " down}" if x[0]!="0" else None),     # vim move down (no mnemonic)
			"#SAE" : lambda x: ("{#control(j) " + ' '.join(x) + " up}"   if x[0]!="0" else None),     # vim move up
		}) * (block1 | block1*block2)  # 2 maximum
	)

# ======== more boilerplate

lookup=lambda strokes: dictionary.lookup_tuple(strokes)
LONGEST_KEY=dictionary.longest_key
assert LONGEST_KEY==1

if __name__=="__main__":
	dictionary.print_items()

By "1 stroke" I mean that the "word" to be searched following it must be 1 stroke (sufficient most of the time) see the example after it

[Josiah-tan]

This looks pretty good, I find it interesting that you used a different number system to that of the Plover number system (like EU for inversion and -D for repetition)
is there any reason why you decided to make it like this? (My one was designed with this in mind such that -R and -B was up and down like in Qwerty)

quick questions:
what dependencies do you have to install to get this code to work?
Like pip install Plover is not enough?
Also what does the operator | and * do here in the code (I'm guessing there's some operator overloading going on here?)

Regarding the system for remove paragraph how do you handle
dip verses dap?
I noticed that outer and inner are -Z and -S and this would make something like -SDZ pretty hard to stroke (for the inner variant)

[Josiah-tan]

regarding the code it just clicked in my brain all of a sudden what it meant (thanks!)
just want to confirm my understanding:
* means to select all combinations of keys and their corresponding values from both RHS and LHS dictionaries and combine together
such that:

• The keys are combined as according to steno order
• for the values if RHS and LHS are strings then the value returned is concatenated string, if LHS is a function then pass the RHS string into this function and return the output as the value

| Means to merge two dictionaries

• Like how you would update a normal Python dictionary (I assume that there aren't going to be any conflicts given that all keys for both dictionaries are unique here)

(edit ignore this just read the documentation from user202729)

[user202729]

I use a personal library for the dictionary https://github.com/user202729/plover-python-dictionary-lib see installation guide there

Normally I only need to dip, but there are lots of space left to add more range operators.

[Josiah-tan]

excellent I'll check it out!

(edit: this library is legendary)

[Josiah-tan]

How are you envisioning this just out of curiosity?
Integrate "movement" with "range", and add inclusive/exclusive as well so I can do e.g. "remove to last =, exclusive"
I'd be interested to see this

[user202729]

Adding 4 more range commands (next inclusive, next up-to (exclusive), previous inclusive, previous exclusive) on the right half?

Still need 2 stroke (a separate one for the =) however.

[Josiah-tan]

That sounds like a good idea and I think it'll work!

just came up with another one with a few hacky ideas but I want to know what people think:

So in order to one stroke dt= and anything similar to it (of type action + motion + character) I found a few interesting concepts:
kaoffie mentioned something interesting a while ago
"Anything with -TZ, -SD, -TDZ, -SDZ, -TSZ, -TSD, or -TSDZ is unlikely to have any conflicts"
so let's assume for this purpose that we take up the -LGTSDZ namespace for making a unique chord (nothing that new going on so far)

for me I really like using Emily's modifiers so let's use that to represent "="
that takes up the entire left hand side of the keyboard as well as the vowels

so then we have -FPB left to work with to represent "dt" (we need -R to represent capitalization)
but... that's not enough keys to work with... (2 * 2 * 2 = 8 permutations)

there are more than 3 "actions" that we have to take care of (delete, yank, visual)
and there are more than 4 movement commands (f, F, T, t)
that's 3 * 4 = 12 combinations that we need... Not enough space (and we need space for custom ones as well but don't even get me started on that)

so yes it seemed like we needed to give up for a while... and 2 stroke that "dt="...
sigh...

But then someone mentioned pure left hand fingerspelling on discord and that sparked something in me
Notice how in Emily's modifiers that E and U are only ever used to create the letters e, u and i
so if we move these to the left side:
E: SK
I: SKW
U: WR

Then we can free up the E and U keys
also we can abuse the # key so it means that we can use 3 extra keys!

So maybe we can use #EU for the action keys and -FPB for movement keys
(8 action keys and 8 movement keys)

This means we can stroke "dt=" in a single stroke!

for example, PWHR*EPTDZ:
PWHR* represents "="
E represents "delete" (d)
P represents "previous" (t)
-TDZ is the unique chord in this case

so this means possible to create such a system that does not require entirely relearning what I've learnt earlier (namely Emily's symbols)
I just need to memorize a position for every new command that I create (just like user 2's system)

let me know if there are any loop holes that I may have missed though please

[Josiah-tan]

Forward and reverse single word search:

So I saw user 2's idea for two stroking a word search in vim (see gist)
e.g.
STPR-FP/WEU → search for the next occurrence of "which"
STPR*FP/WEU → search for the previous occurrence
(note that "return" is automatically inserted after stroking WEU)

Then I found another way to two stroke words using the retro_everything plugin:

so you can do something like:
WEU/STPR-FPD → search for next occurrence of "which"
WEU/STPR*FPD → search for the previous occurrence

The entries for these retrostrokes are as follows:
STPR-FPD → "=retro_everything:{#control(j) slash}{^},{#return}"
STPR*FPD → "=retro_everything:{#control(j) shift(question)}{^},{#return}"

this is perfect for those using the control(j) binding above as you can just stay in insert mode and search through the file easily