Enum Enum

#[non_exhaustive]
pub enum Enum<const LEN: usize, A, B, C = (), D = (), E = (), F = (), G = (), H = (), I = (), J = (), K = (), L = ()> {
    A(A),
    B(B),
    C(C),
    D(D),
    E(E),
    F(F),
    G(G),
    H(H),
    I(I),
    J(J),
    K(K),
    L(L),
}

A generic, parameterized enum for expressing structured alternatives.

Variants are expected to be contiguous, meaning () (unit types) should only appear at the end.

The first variant (A) is considered the default, implementing Default when A: Default.

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.

A(A)

The 1st variant (default).

B(B)

The 2nd variant.

C(C)

The 3rd variant.

D(D)

The 4th variant.

E(E)

The 5th variant.

F(F)

The 6th variant.

G(G)

The 7th variant.

H(H)

The 8th variant.

I(I)

The 9th variant.

J(J)

The 10th variant.

K(K)

The 11th variant.

L(L)

The 12th variant.

Implementations

impl<const LEN: usize, A, B, C, D, E, F, G, H, I, J, K, L> Enum<LEN, A, B, C, D, E, F, G, H, I, J, K, L>

Structural methods.

pub const LEN: usize

The number of active (non-() type) variants.

pub const MAX_ARITY: usize = 12usize

The maximum number of generic type parameters in this enum.

pub const fn variant_index(&self) -> usize

Returns the current variant index (0-based).

pub const fn is_variant_index(&self, index: usize) -> bool

Checks whether the current variant is at index (0-based).

pub const fn variant_name(&self) -> &'static str

Returns the current variant name.

pub const fn is_variant_name(&self, name: &str) -> bool

Checks whether the current variant has the given name.

impl<const LEN: usize, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static> Enum<LEN, A, B, C, D, E, F, G, H, I, J, K, L>

pub fn first_non_unit() -> Option<&'static str>

Returns the first non-unit variant name, if any.

pub fn validate() -> bool

Validates that inactive () variants only appear at the end, and that LEN equals the number of active variants.

impl<const LEN: usize, A: Clone, B: Clone, C: Clone, D: Clone, E: Clone, F: Clone, G: Clone, H: Clone, I: Clone, J: Clone, K: Clone, L: Clone> Enum<LEN, A, B, C, D, E, F, G, H, I, J, K, L>

Conversion methods.

pub fn into_tuple_options( self, ) -> (Option<A>, Option<B>, Option<C>, Option<D>, Option<E>, Option<F>, Option<G>, Option<H>, Option<I>, Option<J>, Option<K>, Option<L>)

Returns a tuple with Some(value) for the active variant and None elsewhere.

pub fn into_tuple_defaults(self) -> (A, B, C, D, E, F, G, H, I, J, K, L)

where A: Default, B: Default, C: Default, D: Default, E: Default, F: Default, G: Default, H: Default, I: Default, J: Default, K: Default, L: Default,

Returns a tuple with the active variant’s inner value in its corresponding position and Default::default() for all others.

impl<const LEN: usize, A, B, C, D, E, F, G, H, I, J, K, L> Enum<LEN, A, B, C, D, E, F, G, H, I, J, K, L>

pub fn as_tuple_ref_options( &self, ) -> (Option<&A>, Option<&B>, Option<&C>, Option<&D>, Option<&E>, Option<&F>, Option<&G>, Option<&H>, Option<&I>, Option<&J>, Option<&K>, Option<&L>)

Returns a tuple with Some(&value) for the active variant and None elsewhere.

impl<const LEN: usize, A, B, C, D, E, F, G, H, I, J, K, L> Enum<LEN, A, B, C, D, E, F, G, H, I, J, K, L>

Variant-specific methods.

pub const fn is_a(&self) -> bool

Returns true if the value is of type A

pub fn into_a(self) -> Option<A>

Returns the inner A value, if present.

pub fn as_ref_a(&self) -> Option<&A>

Returns a reference to the inner A value, if present.

pub fn as_mut_a(&mut self) -> Option<&mut A>

Returns a reference to the inner A value, if present.

pub const fn is_b(&self) -> bool

Returns true if the value is of type B

pub fn into_b(self) -> Option<B>

Returns the inner B value, if present.

pub fn as_ref_b(&self) -> Option<&B>

Returns a reference to the inner B value, if present.

pub fn as_mut_b(&mut self) -> Option<&mut B>

Returns a reference to the inner B value, if present.

pub const fn is_c(&self) -> bool

Returns true if the value is of type C

pub fn into_c(self) -> Option<C>

Returns the inner C value, if present.

pub fn as_ref_c(&self) -> Option<&C>

Returns a reference to the inner C value, if present.

pub fn as_mut_c(&mut self) -> Option<&mut C>

Returns a reference to the inner C value, if present.

pub const fn is_d(&self) -> bool

Returns true if the value is of type D

pub fn into_d(self) -> Option<D>

Returns the inner D value, if present.

pub fn as_ref_d(&self) -> Option<&D>

Returns a reference to the inner D value, if present.

pub fn as_mut_d(&mut self) -> Option<&mut D>

Returns a reference to the inner D value, if present.

pub const fn is_e(&self) -> bool

Returns true if the value is of type E

pub fn into_e(self) -> Option<E>

Returns the inner E value, if present.

pub fn as_ref_e(&self) -> Option<&E>

Returns a reference to the inner E value, if present.

pub fn as_mut_e(&mut self) -> Option<&mut E>

Returns a reference to the inner E value, if present.

pub const fn is_f(&self) -> bool

Returns true if the value is of type F

pub fn into_f(self) -> Option<F>

Returns the inner F value, if present.

pub fn as_ref_f(&self) -> Option<&F>

Returns a reference to the inner F value, if present.

pub fn as_mut_f(&mut self) -> Option<&mut F>

Returns a reference to the inner F value, if present.

pub const fn is_g(&self) -> bool

Returns true if the value is of type G

pub fn into_g(self) -> Option<G>

Returns the inner G value, if present.

pub fn as_ref_g(&self) -> Option<&G>

Returns a reference to the inner G value, if present.

pub fn as_mut_g(&mut self) -> Option<&mut G>

Returns a reference to the inner G value, if present.

pub const fn is_h(&self) -> bool

Returns true if the value is of type H

pub fn into_h(self) -> Option<H>

Returns the inner H value, if present.

pub fn as_ref_h(&self) -> Option<&H>

Returns a reference to the inner H value, if present.

pub fn as_mut_h(&mut self) -> Option<&mut H>

Returns a reference to the inner H value, if present.

pub const fn is_i(&self) -> bool

Returns true if the value is of type I

pub fn into_i(self) -> Option<I>

Returns the inner I value, if present.

pub fn as_ref_i(&self) -> Option<&I>

Returns a reference to the inner I value, if present.

pub fn as_mut_i(&mut self) -> Option<&mut I>

Returns a reference to the inner I value, if present.

pub const fn is_j(&self) -> bool

Returns true if the value is of type J

pub fn into_j(self) -> Option<J>

Returns the inner J value, if present.

pub fn as_ref_j(&self) -> Option<&J>

Returns a reference to the inner J value, if present.

pub fn as_mut_j(&mut self) -> Option<&mut J>

Returns a reference to the inner J value, if present.

pub const fn is_k(&self) -> bool

Returns true if the value is of type K

pub fn into_k(self) -> Option<K>

Returns the inner K value, if present.

pub fn as_ref_k(&self) -> Option<&K>

Returns a reference to the inner K value, if present.

pub fn as_mut_k(&mut self) -> Option<&mut K>

Returns a reference to the inner K value, if present.

pub const fn is_l(&self) -> bool

Returns true if the value is of type L

pub fn into_l(self) -> Option<L>

Returns the inner L value, if present.

pub fn as_ref_l(&self) -> Option<&L>

Returns a reference to the inner L value, if present.

pub fn as_mut_l(&mut self) -> Option<&mut L>

Returns a reference to the inner L value, if present.

pub fn map_a<NEW>( self, f: impl FnOnce(A) -> NEW, ) -> Enum<LEN, NEW, B, C, D, E, F, G, H, I, J, K, L>

Transforms the inner A value using f, leaving other variants unchanged.

pub fn map_b<NEW>( self, f: impl FnOnce(B) -> NEW, ) -> Enum<LEN, A, NEW, C, D, E, F, G, H, I, J, K, L>

Transforms the inner B value using f, leaving other variants unchanged.

pub fn map_c<NEW>( self, f: impl FnOnce(C) -> NEW, ) -> Enum<LEN, A, B, NEW, D, E, F, G, H, I, J, K, L>

Transforms the inner C value using f, leaving other variants unchanged.

pub fn map_d<NEW>( self, f: impl FnOnce(D) -> NEW, ) -> Enum<LEN, A, B, C, NEW, E, F, G, H, I, J, K, L>

Transforms the inner D value using f, leaving other variants unchanged.

pub fn map_e<NEW>( self, f: impl FnOnce(E) -> NEW, ) -> Enum<LEN, A, B, C, D, NEW, F, G, H, I, J, K, L>

Transforms the inner E value using f, leaving other variants unchanged.

pub fn map_f<NEW>( self, f: impl FnOnce(F) -> NEW, ) -> Enum<LEN, A, B, C, D, E, NEW, G, H, I, J, K, L>

Transforms the inner F value using f, leaving other variants unchanged.

pub fn map_g<NEW>( self, f: impl FnOnce(G) -> NEW, ) -> Enum<LEN, A, B, C, D, E, F, NEW, H, I, J, K, L>

Transforms the inner G value using f, leaving other variants unchanged.

pub fn map_h<NEW>( self, f: impl FnOnce(H) -> NEW, ) -> Enum<LEN, A, B, C, D, E, F, G, NEW, I, J, K, L>

Transforms the inner H value using f, leaving other variants unchanged.

pub fn map_i<NEW>( self, f: impl FnOnce(I) -> NEW, ) -> Enum<LEN, A, B, C, D, E, F, G, H, NEW, J, K, L>

Transforms the inner I value using f, leaving other variants unchanged.

pub fn map_j<NEW>( self, f: impl FnOnce(J) -> NEW, ) -> Enum<LEN, A, B, C, D, E, F, G, H, I, NEW, K, L>

Transforms the inner J value using f, leaving other variants unchanged.

pub fn map_k<NEW>( self, f: impl FnOnce(K) -> NEW, ) -> Enum<LEN, A, B, C, D, E, F, G, H, I, J, NEW, L>

Transforms the inner K value using f, leaving other variants unchanged.

pub fn map_l<NEW>( self, f: impl FnOnce(L) -> NEW, ) -> Enum<LEN, A, B, C, D, E, F, G, H, I, J, K, NEW>

Transforms the inner L value using f, leaving other variants unchanged.

Trait Implementations

impl<const LEN: usize, A: Clone, B: Clone, C: Clone, D: Clone, E: Clone, F: Clone, G: Clone, H: Clone, I: Clone, J: Clone, K: Clone, L: Clone> Clone for Enum<LEN, A, B, C, D, E, F, G, H, I, J, K, L>

fn clone(&self) -> Enum<LEN, A, B, C, D, E, F, G, H, I, J, K, L>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<const LEN: usize, A: ConstDefault, B, C, D, E, F, G, H, I, J, K, L> ConstDefault for Enum<LEN, A, B, C, D, E, F, G, H, I, J, K, L>

const DEFAULT: Self

Returns the compile-time “default value” for a type.

impl<const LEN: usize, A: Debug, B: Debug, C: Debug, D: Debug, E: Debug, F: Debug, G: Debug, H: Debug, I: Debug, J: Debug, K: Debug, L: Debug> Debug for Enum<LEN, A, B, C, D, E, F, G, H, I, J, K, L>

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

Formats the value using the given formatter.

impl<const LEN: usize, A: Default, B, C, D, E, F, G, H, I, J, K, L> Default for Enum<LEN, A, B, C, D, E, F, G, H, I, J, K, L>

fn default() -> Self

Returns the “default value” for a type.

impl<const LEN: usize, A: Hash, B: Hash, C: Hash, D: Hash, E: Hash, F: Hash, G: Hash, H: Hash, I: Hash, J: Hash, K: Hash, L: Hash> Hash for Enum<LEN, A, B, C, D, E, F, G, H, I, J, K, L>

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<const LEN: usize, A: PartialEq, B: PartialEq, C: PartialEq, D: PartialEq, E: PartialEq, F: PartialEq, G: PartialEq, H: PartialEq, I: PartialEq, J: PartialEq, K: PartialEq, L: PartialEq> PartialEq for Enum<LEN, A, B, C, D, E, F, G, H, I, J, K, L>

fn eq(&self, other: &Enum<LEN, A, B, C, D, E, F, G, H, I, J, K, L>) -> 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<const LEN: usize, A: Copy, B: Copy, C: Copy, D: Copy, E: Copy, F: Copy, G: Copy, H: Copy, I: Copy, J: Copy, K: Copy, L: Copy> Copy for Enum<LEN, A, B, C, D, E, F, G, H, I, J, K, L>

impl<const LEN: usize, A: Eq, B: Eq, C: Eq, D: Eq, E: Eq, F: Eq, G: Eq, H: Eq, I: Eq, J: Eq, K: Eq, L: Eq> Eq for Enum<LEN, A, B, C, D, E, F, G, H, I, J, K, L>

impl<const LEN: usize, A, B, C, D, E, F, G, H, I, J, K, L> StructuralPartialEq for Enum<LEN, A, B, C, D, E, F, G, H, I, J, K, L>