Struct Discriminant 

pub struct Discriminant<T>(/* private fields */);

Available on crate features crypto and std only.

Opaque type representing the discriminant of an enum.

See the discriminant function in this module for more information.

Implementations

impl<T> Discriminant<T>

pub const fn ord(&self) -> DiscriminantOrd<T>

🔬This is a nightly-only experimental API. (discriminant_ord)

Returns an ordering key for this Discriminant that has an unstable implementation with regards to semantic versioning. This is not the be confused with an [“unstable sort”].

Because all types have a publicly accessible Discriminant, regardless of whether the order of said type is a part of its stability guarantees, the exact ordering of the returned DiscriminantOrd cannot be relied on for stability across crates. This is similar to the stability of the size of a type as returned by size_of.

Enum values will be ordered based on the source declaration and repr values of their variants, consistent with derived implementations of PartialOrd and Ord. Noting that only the discriminant and no field values are considered. All other kinds of values have an unspecified ordering, but will typically be trivially ordered as equivalent.

Users of this function should instead rely on the Ord implementation of T wherever possible.

Examples

#![feature(discriminant_ord)]

use std::cmp::Ordering;
use std::mem::discriminant;

enum Foo { A(i32), B(i32) }

// Equivalent arms will compare equal regardless of contained data
assert_matches!(
    discriminant(&Foo::A(1)).ord().cmp(&discriminant(&Foo::A(2)).ord()),
    Ordering::Equal,
);

// Inequivalent arms will compare not-equal
assert_matches!(
    discriminant(&Foo::A(1)).ord().cmp(&discriminant(&Foo::B(1)).ord()),
    Ordering::Less | Ordering::Greater,
);

Upstream libraries and the compiler are free to change the exact ordering of discriminants. The below may break at any time:

// Foo::A is declared before Foo::B, but that ordering is not stable
assert_matches!(
    discriminant(&Foo::A(0)).ord().cmp(&discriminant(&Foo::B(0)).ord()),
    Ordering::Less,
);

Trait Implementations

impl<T> Clone for Discriminant<T>

fn clone(&self) -> Discriminant<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Copy for Discriminant<T>

impl<T> Debug for Discriminant<T>

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

Formats the value using the given formatter.

impl<T> Eq for Discriminant<T>

impl<T> Hash for Discriminant<T>

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

where H: Hasher,

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<T> PartialEq for Discriminant<T>

fn eq(&self, rhs: &Discriminant<T>) -> bool

Equality operator ==.

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

Inequality operator !=.