Struct TimedPending 

pub struct TimedPending { /* private fields */ }

A PendingSequence with a time-window expiry gate.

Each call to feed performs three things in order:

1. If the pending buffer is non-empty and the gap since the last accepted key exceeds window, the old buffer is drained, and the result’s expired field carries those keys (guaranteed non-empty when Some).
2. The buffer (now empty if it just expired) accepts the new key.
3. The new-key Step is returned in TimedStep::step.

The library does not call Instant::now(); now is caller data (see the crate docs and PendingSequence).

Layout

TimedPending is designed to live beside the map it reads:

use keymap_seq::{SequenceKeymap, TimedPending};

struct App<A> {
    map: SequenceKeymap<A>,
    pending: TimedPending,
}

Example

use std::time::{Duration, Instant};
use keymap_core::{Key, KeyInput, Modifiers};
use keymap_seq::{SequenceKeymap, Step, TimedPending, TimedStep};

#[derive(Debug, PartialEq)]
enum Action { NormalMode }

let j = KeyInput::new(Key::Char('j'), Modifiers::NONE);
let mut map = SequenceKeymap::new();
map.bind([j, j], Action::NormalMode).unwrap();

const WINDOW: Duration = Duration::from_millis(500);
let base = Instant::now();
let mut pending = TimedPending::new();

// First j: still a prefix, no expiry yet.
let r1 = pending.feed(&map, j, base, WINDOW);
assert!(r1.expired.is_none());
assert!(matches!(r1.step, Step::Pending));

// Second j arrives within the window: fires.
let r2 = pending.feed(&map, j, base + Duration::from_millis(100), WINDOW);
assert!(r2.expired.is_none());
assert!(matches!(r2.step, Step::Fired(&Action::NormalMode)));

Implementations

impl TimedPending

pub fn new() -> Self

Creates an empty timed pending buffer.

Examples found in repository

examples/leader_sequence.rs (line 103)

fn timed() {
    const WINDOW: Duration = Duration::from_millis(500);

    println!("== timed (jj, via TimedPending) ==");
    let mut map = SequenceKeymap::new();
    map.bind([plain('j'), plain('j')], Action::NormalMode)
        .unwrap();

    // Deterministic timestamps: base + offset (no real sleep / Instant::now).
    let base = Instant::now();
    let stream = [
        (plain('j'), 0u64),
        (plain('j'), 120), // 120ms gap: quick, completes `jj`
        (plain('j'), 900),
        (plain('j'), 1700), // 800ms gap: too slow, expiry fires
    ];

    let mut pending = TimedPending::new();
    for (key, ms) in stream {
        let now = base + Duration::from_millis(ms);
        let result = pending.feed(&map, key, now, WINDOW);

        // If a previous prefix expired, report its keys as literals first.
        if let Some(expired) = result.expired {
            println!(
                "{} @ +{ms}ms -> idle timeout, flushed as literals",
                render(&expired),
            );
        }

        match result.step {
            Step::Fired(action) => println!("{key} @ +{ms}ms -> fire {action:?}"),
            Step::Pending => println!("{key} @ +{ms}ms -> prefix, waiting (window {WINDOW:?})"),
            Step::PassThrough(keys) => {
                println!("{} @ +{ms}ms -> no binding, passing through", render(&keys));
            }
        }
    }

    // The stream ended mid-prefix. Drain as literals (what an idle timer does).
    let dangling = pending.flush();
    if !dangling.is_empty() {
        println!(
            "{} -> pending at end; flushed as literals",
            render(&dangling)
        );
    }
}

pub fn feed<'a, A>( &mut self, map: &'a SequenceKeymap<A>, key: KeyInput, now: Instant, window: Duration, ) -> TimedStep<'a, A>

Processes one key with expiry checking, returning the combined result.

The call sequence is:

1. Expiry check: if the pending buffer is non-empty and now - last_key_at > window, the buffer is flushed. The flushed keys appear in TimedStep::expired (always non-empty when Some).
2. Key processing: key is fed into the (possibly just-reset) buffer via PendingSequence::feed, and the result becomes TimedStep::step.
3. Clock update: last_key_at is set to now when the step is Step::Pending (the buffer grew), or cleared otherwise.

The library never calls Instant::now(). Pass the event timestamp from your event loop.

Examples found in repository

examples/leader_sequence.rs (line 106)

fn timed() {
    const WINDOW: Duration = Duration::from_millis(500);

    println!("== timed (jj, via TimedPending) ==");
    let mut map = SequenceKeymap::new();
    map.bind([plain('j'), plain('j')], Action::NormalMode)
        .unwrap();

    // Deterministic timestamps: base + offset (no real sleep / Instant::now).
    let base = Instant::now();
    let stream = [
        (plain('j'), 0u64),
        (plain('j'), 120), // 120ms gap: quick, completes `jj`
        (plain('j'), 900),
        (plain('j'), 1700), // 800ms gap: too slow, expiry fires
    ];

    let mut pending = TimedPending::new();
    for (key, ms) in stream {
        let now = base + Duration::from_millis(ms);
        let result = pending.feed(&map, key, now, WINDOW);

        // If a previous prefix expired, report its keys as literals first.
        if let Some(expired) = result.expired {
            println!(
                "{} @ +{ms}ms -> idle timeout, flushed as literals",
                render(&expired),
            );
        }

        match result.step {
            Step::Fired(action) => println!("{key} @ +{ms}ms -> fire {action:?}"),
            Step::Pending => println!("{key} @ +{ms}ms -> prefix, waiting (window {WINDOW:?})"),
            Step::PassThrough(keys) => {
                println!("{} @ +{ms}ms -> no binding, passing through", render(&keys));
            }
        }
    }

    // The stream ended mid-prefix. Drain as literals (what an idle timer does).
    let dangling = pending.flush();
    if !dangling.is_empty() {
        println!(
            "{} -> pending at end; flushed as literals",
            render(&dangling)
        );
    }
}

pub fn deadline(&self, window: Duration) -> Option<Instant>

The deadline at which a pending prefix expires, or None if no keys are buffered.

Use this as your event loop’s poll timeout: if no key arrives before deadline, call flush and treat the result as pass-through literals.

use std::time::{Duration, Instant};
use keymap_core::{Key, KeyInput, Modifiers};
use keymap_seq::{SequenceKeymap, TimedPending};

#[derive(Debug)] enum Action { Jump }
let j = KeyInput::new(Key::Char('j'), Modifiers::NONE);
let mut map = SequenceKeymap::new();
map.bind([j, j], Action::Jump).unwrap();

const WINDOW: Duration = Duration::from_millis(500);
let mut pending = TimedPending::new();

// Empty buffer → no deadline.
assert!(pending.deadline(WINDOW).is_none());

let base = Instant::now();
pending.feed(&map, j, base, WINDOW);
// After accepting a prefix key, deadline = base + window.
assert_eq!(pending.deadline(WINDOW), Some(base + WINDOW));

pub fn flush(&mut self) -> Vec<KeyInput>

Drains the pending buffer, returning the keys held in it, and leaves the buffer empty.

This is the idle flush: call it when deadline has passed with no further key. The returned keys are literals the caller now owns (the dangling j of a half-typed jj). Flushing an empty buffer returns an empty Vec.

Examples found in repository

examples/leader_sequence.rs (line 126)

fn timed() {
    const WINDOW: Duration = Duration::from_millis(500);

    println!("== timed (jj, via TimedPending) ==");
    let mut map = SequenceKeymap::new();
    map.bind([plain('j'), plain('j')], Action::NormalMode)
        .unwrap();

    // Deterministic timestamps: base + offset (no real sleep / Instant::now).
    let base = Instant::now();
    let stream = [
        (plain('j'), 0u64),
        (plain('j'), 120), // 120ms gap: quick, completes `jj`
        (plain('j'), 900),
        (plain('j'), 1700), // 800ms gap: too slow, expiry fires
    ];

    let mut pending = TimedPending::new();
    for (key, ms) in stream {
        let now = base + Duration::from_millis(ms);
        let result = pending.feed(&map, key, now, WINDOW);

        // If a previous prefix expired, report its keys as literals first.
        if let Some(expired) = result.expired {
            println!(
                "{} @ +{ms}ms -> idle timeout, flushed as literals",
                render(&expired),
            );
        }

        match result.step {
            Step::Fired(action) => println!("{key} @ +{ms}ms -> fire {action:?}"),
            Step::Pending => println!("{key} @ +{ms}ms -> prefix, waiting (window {WINDOW:?})"),
            Step::PassThrough(keys) => {
                println!("{} @ +{ms}ms -> no binding, passing through", render(&keys));
            }
        }
    }

    // The stream ended mid-prefix. Drain as literals (what an idle timer does).
    let dangling = pending.flush();
    if !dangling.is_empty() {
        println!(
            "{} -> pending at end; flushed as literals",
            render(&dangling)
        );
    }
}

pub fn pending(&self) -> &[KeyInput]

The keys buffered so far, in press order.

pub fn is_empty(&self) -> bool

Returns true if no keys are buffered.

Trait Implementations

impl Clone for TimedPending

fn clone(&self) -> TimedPending

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TimedPending

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

Formats the value using the given formatter.

impl Default for TimedPending

fn default() -> TimedPending

Returns the “default value” for a type.