Enum MotionKind 

#[non_exhaustive]
pub enum MotionKind {
    CharLeft,
    CharRight,
    LineDown,
    LineUp,
    FirstNonBlankDown,
    FirstNonBlankUp,
    WordForward,
    BigWordForward,
    WordBackward,
    BigWordBackward,
    WordEnd,
    BigWordEnd,
    LineStart,
    FirstNonBlank,
    LineEnd,
    GotoLine,
    FindRepeat,
    FindRepeatReverse,
    BracketMatch,
    ViewportTop,
    ViewportMiddle,
    ViewportBottom,
    HalfPageDown,
    HalfPageUp,
    FullPageDown,
    FullPageUp,
    FirstNonBlankLine,
    SectionBackward,
    SectionForward,
    SectionEndBackward,
    SectionEndForward,
}

Cursor motion identity for the hjkl keymap layer.

Moved from hjkl-vim into hjkl-engine (Phase 6.6 cycle-break) so that hjkl-vim can depend on hjkl-engine without a circular dependency. hjkl-vim re-exports this type as hjkl_vim::MotionKind for back-compat.

The host converts a MotionKind to the appropriate Editor::apply_motion call. Designed for extensibility: future phases may add variants without breaking existing match arms — callers must use .. or add the new arms when they bump the hjkl-engine minor version.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

CharLeft

h / <Backspace> — move the cursor one character to the left. Clamps at column 0 (no line-wrap), matching vim’s normal-mode h.

CharRight

l / <Space> — move the cursor one character to the right. Clamps at the last character of the line (no line-wrap), matching vim’s normal-mode l.

LineDown

j — move the cursor one line down, restoring the sticky column.

LineUp

k — move the cursor one line up, restoring the sticky column.

FirstNonBlankDown

+ / <CR> (not yet bound) — move down one line and land on the first non-blank character. Sets the sticky column.

FirstNonBlankUp

- — move up one line and land on the first non-blank character. Sets the sticky column.

WordForward

w — move the cursor forward to the start of the next small word. Counts repeat the motion; wraps across lines matching vim’s w.

BigWordForward

W — move the cursor forward to the start of the next BIG word (whitespace-delimited). Counts repeat; wraps across lines.

WordBackward

b — move the cursor backward to the start of the current or previous small word. Counts repeat; wraps across lines matching vim’s b.

BigWordBackward

B — move the cursor backward to the start of the current or previous BIG word (whitespace-delimited). Counts repeat; wraps across lines.

WordEnd

e — move the cursor forward to the end of the current or next small word. Counts repeat; wraps across lines matching vim’s e.

BigWordEnd

E — move the cursor forward to the end of the current or next BIG word (whitespace-delimited). Counts repeat; wraps across lines.

LineStart

0 / <Home> — move the cursor to the first column of the current line (column 0). Count is ignored (vim 0 is always a plain motion).

FirstNonBlank

^ — move the cursor to the first non-blank character on the current line. On a blank/all-whitespace line, lands at column 0.

LineEnd

$ / <End> — move the cursor to the last character on the current line. On an empty line, stays at column 0. Count-aware: count$ moves down count-1 lines, then lands at the end of that line.

GotoLine

G — go to line. Count semantics match vim:

• count 0 or 1 (bare G) → last line of buffer.
• count > 1 → jump to that line number (1-based).

Note: gg (first line) is dispatched via the G-chord path (Editor::after_g), not via this variant.

FindRepeat

; — repeat last f/F/t/T in the same direction. No-op if no prior find exists.

FindRepeatReverse

, — repeat last f/F/t/T in the reverse direction. No-op if no prior find exists.

BracketMatch

% — jump to matching bracket. With a count N%, vim normally jumps to the N% line of the file (percentage). The engine currently implements only the matching-bracket semantic; count is passed through and handled engine-side. Bracket types: (), [], {}, plus C-style block comments /* */ (engine detail).

ViewportTop

H — jump to the top of the visible viewport. With a count, moves to the viewport top and then count - 1 rows further down (matching vim’s H count semantics). Lands on the first non-blank character.

ViewportMiddle

M — jump to the middle row of the visible viewport. Count is ignored (vim’s M is always a plain motion). Lands on the first non-blank character.

ViewportBottom

L — jump to the bottom of the visible viewport. With a count, moves to the viewport bottom and then count - 1 rows further up (matching vim’s L count semantics). Lands on the first non-blank character.

HalfPageDown

<C-d> — move the cursor half a page down. Count multiplies the half-page distance (e.g. 2<C-d> = one full page). Lands on the first non-blank of the target row.

HalfPageUp

<C-u> — move the cursor half a page up. Count multiplies the half-page distance. Lands on the first non-blank of the target row.

FullPageDown

<C-f> — move the cursor a full page down (with 2-line overlap). Count multiplies the full-page distance. Lands on the first non-blank of the target row.

FullPageUp

<C-b> — move the cursor a full page up (with 2-line overlap). Count multiplies the full-page distance. Lands on the first non-blank of the target row.

FirstNonBlankLine

_ — first non-blank of count-1 lines below the cursor (count=1 = current line). Linewise. Vim’s _ motion.

SectionBackward

[[ — backward to the previous { at column 0 (C section header). Charwise exclusive; count-aware.

SectionForward

]] — forward to the next { at column 0. Charwise exclusive; count-aware.

SectionEndBackward

[] — backward to the previous } at column 0 (C section end). Charwise exclusive; count-aware.

SectionEndForward

][ — forward to the next } at column 0. Charwise exclusive; count-aware.

Trait Implementations

impl Clone for MotionKind

fn clone(&self) -> MotionKind

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for MotionKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for MotionKind

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for MotionKind

fn eq(&self, other: &MotionKind) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for MotionKind

impl Eq for MotionKind

impl StructuralPartialEq for MotionKind