Enum Step 

pub enum Step<'a, A> {
    Fired(&'a A),
    Pending,
    PassThrough(Vec<KeyInput>),
}

What a PendingSequence::feed resolved to — the caller’s next action.

Step is the action-oriented dual of Match: where Match states a fact about the table (exact / prefix / miss), Step states what the caller does (fire it / keep waiting / take these keys back). The trichotomy is the same closed set — feed is a thin translation of the SequenceKeymap::lookup result into buffer operations, and a pure trie lookup has no fourth outcome — so, like Match, this enum is not #[non_exhaustive]: match all three arms and let the compiler check coverage. (flush’s drain is a Vec, not a Step, so it adds no variant.)

Variants

Fired(&'a A)

The buffer completed a binding, resolving to this action; the buffer has been cleared.

Pending

The buffer is a proper prefix of a longer binding; it has been kept. Keep reading (and, for a timed binding, (re)start your idle timer).

PassThrough(Vec<KeyInput>)

The buffer is not on any binding path; it has been cleared and its keys — every key buffered so far, in order — are handed back for the caller to handle.

Trait Implementations

impl<'a, A: Debug> Debug for Step<'a, A>

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

Formats the value using the given formatter.

impl<'a, A: Eq> Eq for Step<'a, A>

impl<'a, A: PartialEq> PartialEq for Step<'a, A>

fn eq(&self, other: &Step<'a, A>) -> 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<'a, A> StructuralPartialEq for Step<'a, A>