Enum Key 

#[non_exhaustive]
pub enum Key {
    Char(char),
    F(u8),
    Enter,
    Esc,
    Tab,
    Backspace,
    Delete,
    Insert,
    Home,
    End,
    PageUp,
    PageDown,
    Up,
    Down,
    Left,
    Right,
}

A physical key, independent of which terminal or OS produced it.

Only keys whose identity is unambiguous across environments are enumerated today. Keys whose meaning is environment-dependent (media keys, keypad distinctions, etc.) are intentionally omitted and will be added later; this enum is #[non_exhaustive], so adding them is not a breaking change. Because of that, downstream match expressions must include a _ arm.

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.

Char(char)

A character-producing key, carrying the resolved glyph. See the normalization note on KeyInput for how shift interacts with this.

F(u8)

A function key, F(1) through F(n).

Enter

The Enter / Return key.

Esc

The Escape key.

Tab

The Tab key. Shift+Tab is represented as Tab with Modifiers::SHIFT.

Backspace

The Backspace key.

Delete

The forward Delete key.

Insert

The Insert key.

Home

The Home key.

End

The End key.

PageUp

The Page Up key.

PageDown

The Page Down key.

Up

The Up arrow.

Down

The Down arrow.

Left

The Left arrow.

Right

The Right arrow.

Trait Implementations

impl Clone for Key

fn clone(&self) -> Key

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Key

impl Debug for Key

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

Formats the value using the given formatter.

impl Eq for Key

impl Hash for Key

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 Key

fn eq(&self, other: &Key) -> 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 StructuralPartialEq for Key