Implement a decent vi editing mode

[munyari]

Vim has the ; and , motions in normal mode, to repeat the last f/F/t/T motion. These are also implemented in GNU readline, and would make a great addition to this library.

[AndrewRayCode]

Yes please! ghci is painful to use without ;

[Aster89]

I've started looking at the code, and for now I still haven't figured out how to proceed, so I'm just experimenting in an attempt to understand how it works.

I'll take some notes below.

---

The commands , and ; are not broken, they just don't exist because they were never implemented in this library.

At the moment, the commands f/F/t/T are dealt with in two places, and there's indeed also a comment saying that "'t' and 'f' behave differently" in the two cases, but I'm not sure how this affects the sought solution:

haskeline/System/Console/Haskeline/Vi.hs

Lines 152 to 164 in b12552d

	pureMovements :: InputKeyCmd (ArgMode CommandMode) CommandMode
	pureMovements = choiceCmd $ charMovements ++ map mkSimpleCommand movements
	where
	charMovements = [ charMovement 'f' $ \c -> goRightUntil $ overChar (==c)
	, charMovement 'F' $ \c -> goLeftUntil $ overChar (==c)
	, charMovement 't' $ \c -> goRightUntil $ beforeChar (==c)
	, charMovement 'T' $ \c -> goLeftUntil $ afterChar (==c)
	]
	mkSimpleCommand (k,move) = k +> change (applyCmdArg move)
	charMovement c move = simpleChar c +> keyChoiceCmd [
	useChar (change . applyCmdArg . move)
	, withoutConsuming (change argState)
	]

haskeline/System/Console/Haskeline/Vi.hs

Lines 166 to 182 in b12552d

	useMovementsForKill :: Command m s t -> (KillHelper -> Command m s t) -> KeyCommand m s t
	useMovementsForKill alternate useHelper = choiceCmd $
	specialCases
	++ map (\(k,move) -> k +> useHelper (SimpleMove move)) movements
	where
	specialCases = [ simpleChar 'e' +> useHelper (SimpleMove goToWordDelEnd)
	, simpleChar 'E' +> useHelper (SimpleMove goToBigWordDelEnd)
	, simpleChar '%' +> useHelper (GenericKill deleteMatchingBrace)
	-- Note 't' and 'f' behave differently than in pureMovements.
	, charMovement 'f' $ \c -> goRightUntil $ afterChar (==c)
	, charMovement 'F' $ \c -> goLeftUntil $ overChar (==c)
	, charMovement 't' $ \c -> goRightUntil $ overChar (==c)
	, charMovement 'T' $ \c -> goLeftUntil $ afterChar (==c)
	]
	charMovement c move = simpleChar c +> keyChoiceCmd [
	useChar (useHelper . SimpleMove . move)
	, withoutConsuming alternate]

To implement , and ;, the commands f/F/t/T should alter some part of the State, just like the commands / and ? do. I haven't worked out yet, however, how to achieve this. I've only got to the conclusion that most likely one necessary step is to augment ViState with one more piece of state, i.e. changing it from this

haskeline/System/Console/Haskeline/Vi.hs

Lines 24 to 33 in b12552d

	data ViState m = ViState {
	lastCommand :: SavedCommand m,
	lastSearch :: [Grapheme]
	}
	emptyViState :: Monad m => ViState m
	emptyViState = ViState {
	lastCommand = return . Left . argState,
	lastSearch = []
	}

to this

data ViState m = ViState {
            lastCommand :: SavedCommand m,
            lastSearch :: [Grapheme],
            lastInlineSearch :: Maybe Grapheme
         }

emptyViState :: Monad m => ViState m
emptyViState = ViState {
            lastCommand = return . Left . argState,
            lastSearch = [],
            lastInlineSearch = Nothing
        }

I don't exclude that a different approach could be more productive: moving the f/F/t/T commands inside simpleCmdActions, where the //?/n/N commands are, which offer an opportunity to emulate existing code, since they already emply this thing of being stateful.

haskeline/System/Console/Haskeline/Vi.hs

Lines 116 to 135 in b12552d

	simpleCmdActions :: InputKeyCmd CommandMode CommandMode
	simpleCmdActions = choiceCmd [
	simpleChar '\ESC' +> change id -- helps break out of loops
	, simpleChar 'r' +> replaceOnce
	, simpleChar 'R' +> replaceLoop
	, simpleChar 'D' +> noArg >|> killAndStoreCmd (SimpleMove moveToEnd)
	, ctrlChar 'l' +> clearScreenCmd
	, simpleChar 'u' +> commandUndo
	, ctrlChar 'r' +> commandRedo
	-- vi-mode quirk: history is put at the start of the line.
	, simpleChar 'j' +> historyForward >|> change moveToStart
	, simpleChar 'k' +> historyBack >|> change moveToStart
	, simpleKey DownKey +> historyForward >|> change moveToStart
	, simpleKey UpKey +> historyBack >|> change moveToStart
	, simpleChar '/' +> viEnterSearch '/' Reverse
	, simpleChar '?' +> viEnterSearch '?' Forward
	, simpleChar 'n' +> viSearchHist Reverse []
	, simpleChar 'N' +> viSearchHist Forward []
	, simpleKey KillLine +> noArg >|> killAndStoreCmd (SimpleMove moveToStart)
	]

[Aster89]

@athas , do you have some pointers to old conversation/design documents of some sort that might be relevant to this code? I'm struggling immensely to try understand how this whole code works. Let me clarify, I'm not referring to just Vi.hs, but to the whole repo. I find the abstractions very unclear and poorly documented (hence #204, and I wish I could spot more opportunities for simplification).

[athas]

I became curator of haskeline quite recently, and I'm mostly here to merge PRs and handle new GHC versions. It is possible you already know the code better than I do.

[Aster89]

Fantastic 😆 Let's see where I can get to.

[Aster89]

The amount of non-conformances with respect to Vim and even just readline is impressive. Below I'm taking note of what I find, while I try to implement ; and , with counts.

• x doesn't populate the text that p puts;
• i and j don't get counts, but they should, like readline's vi mode does;
• f/t followed by a character that doesn't occur anywhere on the following part of the line causes the cursor to move to the last character, where it should stay still, like readline's vi mode does; the same is true for F/T that go to the beginning of the line;
• t and T are not idempotent as they should be (in Vim and readline, if the cursor is on X in aXa, it won't move with any of ta/Ta);
  • regarding this, the implementation of ,/; can be a bit tricky, because these are not idempotent even after t/T, at least by default, i.e. when cpo does not include ; (see :h cpo-;);
  • on the other hand, readline acts as if cpo had ;; not sure if that's readline option or just a bug in it;
• with the cursor at the beginning of f...f,,,, dff results in ...f,,,, whereas it should result in ,,,, according to both Vim and readline;
• when used for deleting with a count, the count is ignored in storing the action for repeatition it via .; example: given the cursor in command mode at the beginning of ...a...a...a...a...a, 2dfa correctly leaves us with ...a...a...a, but pressing . gives ...a...a wheras it should give (as it happens in readline and Vim) ...a;
• with cursor at | in foo|bar in normal mode, doing ixxxEscapell. should result in fooxxxbxx|xar in normal mode (that's the case in readline and actual Vim), wheras it results in fooxxxbxx|ar in normal mode;
• many commands that should accept a count argument, such as j and k in normal mode to navigate history, don't accept it (indeed, they're listed in simpleCmdActions, not in repeatableCmdMode);
• with cursor anywhere on hello in hello (world), % should jump to ), according to Vim and readline, but it doesn't;
• with the cursor anywhere in world, c% seems to have the same effect as just i, i.e. entering insert mode;
  • incidentally, if the cursor is anywhere on world, % in Vim jumps to (, wheras readline doesn't move;
  • weirdly, if the cursor is anywhere on world, c% behaves like cl in readline;

[athas]

Fair enough.