Enum Kind 

pub enum Kind<'a> {
    Unit,
    Bool(bool),
    Char(char),
    I8(i8),
    I16(i16),
    I32(i32),
    I64(i64),
    I128(i128),
    Isize(isize),
    U8(u8),
    U16(u16),
    U32(u32),
    U64(u64),
    U128(u128),
    Usize(usize),
    F32(f32),
    F64(f64),
    Str(Cow<'a, str>),
    Bytes(&'a [u8]),
    Struct,
    Tuple,
    TupleStruct,
    Sequence,
    Map,
    Set,
    Enum,
    Option,
    Result,
    Opaque,
}

The kind of value being inspected.

This represents the fundamental shape and type of a value, including scalar types, containers, and structured data.

Variants

Unit

The unit type ().

Bool(bool)

A boolean value.

Char(char)

A character.

I8(i8)

A signed 8-bit integer.

I16(i16)

A signed 16-bit integer.

I32(i32)

A signed 32-bit integer.

I64(i64)

A signed 64-bit integer.

I128(i128)

A signed 128-bit integer.

Isize(isize)

A pointer-sized signed integer.

U8(u8)

An unsigned 8-bit integer.

U16(u16)

An unsigned 16-bit integer.

U32(u32)

An unsigned 32-bit integer.

U64(u64)

An unsigned 64-bit integer.

U128(u128)

An unsigned 128-bit integer.

Usize(usize)

A pointer-sized unsigned integer.

F32(f32)

A 32-bit floating point number.

F64(f64)

A 64-bit floating point number.

Str(Cow<'a, str>)

A string value.

Bytes(&'a [u8])

A byte sequence.

Struct

A struct with named fields.

Tuple

A tuple with positional fields.

TupleStruct

A tuple struct with positional fields.

Sequence

A sequence (Vec, slice, array).

Map

A map (HashMap, BTreeMap).

Set

A set (HashSet, BTreeSet).

Enum

An enum with a selected variant.

Option

An Option value.

Result

A Result value.

Opaque

An opaque value that doesn’t expose internal structure.

Implementations

impl<'a> Kind<'a>

pub fn name(&self) -> &'static str

Returns a human-readable name for this kind.

pub fn is_scalar(&self) -> bool

Returns true if this is a scalar kind (primitives without children).

Trait Implementations

impl<'a> Clone for Kind<'a>

fn clone(&self) -> Kind<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Kind<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq for Kind<'a>

fn eq(&self, other: &Kind<'a>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<'a> StructuralPartialEq for Kind<'a>