Trait enum_vec::EnumLike

pub unsafe trait EnumLike: Copy {
    const NUM_VARIANTS: usize;

    fn to_discr(self) -> usize;
    fn from_discr(x: usize) -> Self;
}

The EnumLike trait specifies how a type will be stored inside the EnumVec.

It associates every possible instance of the type with a number. However this number does not need to be the same as the result of a simple enum as usize cast.

This trait is unsafe because implementations must follow the contract, especially the first rule:

• self.to_discr() returns a value x < NUM_VARIANTS
• Self::from_discr(self.to_discr()) == self
• Self::from_discr(x) is only required to handle valid values of x

Example 1

use enum_like::EnumLike;

#[derive(Copy, Clone, Debug)]
enum ExtendedBool {
    True,
    False,
    FileNotFound,
}

unsafe impl EnumLike for ExtendedBool {
    const NUM_VARIANTS: usize = 3;

    fn to_discr(self) -> usize {
        match self {
            ExtendedBool::True => 0,
            ExtendedBool::False => 1,
            ExtendedBool::FileNotFound => 2,
        }
    }

    fn from_discr(x: usize) -> Self {
        match x {
            0 => ExtendedBool::True,
            1 => ExtendedBool::False,
            2 => ExtendedBool::FileNotFound,
            _ => unreachable!(),
        }
    }
}

Example 2

use enum_like::EnumLike;

#[derive(Copy, Clone, Debug)]
enum SomeFlags {
    Read = 4,
    Write = 2,
    Exec = 1,
}

unsafe impl EnumLike for SomeFlags {
    const NUM_VARIANTS: usize = 3;

    fn to_discr(self) -> usize {
        match self {
            // We override the default values, because 4 is out of range,
            // but we could also increase NUM_VARIANTS to 5 instead.
            SomeFlags::Read => 0,
            SomeFlags::Write => 1,
            SomeFlags::Exec => 2,

        }
    }

    fn from_discr(x: usize) -> Self {
        match x {
            0 => SomeFlags::Read,
            1 => SomeFlags::Write,
            2 => SomeFlags::Exec,
            _ => unreachable!(),
        }
    }
}

Example 3

Of course, it is not limited to enums:

use enum_like::EnumLike;

#[derive(Copy, Clone, Debug)]
struct Digit {
    x: u8, // x >= 0 && x <= 9
}

unsafe impl EnumLike for Digit {
    const NUM_VARIANTS: usize = 10;
    fn to_discr(self) -> usize {
        self.x as usize
    }
    fn from_discr(x: usize) -> Self {
        let x = x as u8;
        Self { x }
    }
}

Here it is important to make sure that the Digit will always have a valid value in the [0, 9] range. Otherwise, if self.to_discr() returns any number bigger than NUM_VARIANTS, everything breaks.

Associated Constants

const NUM_VARIANTS: usize

The number of variants of this type

Required Methods

fn to_discr(self) -> usize

Convert type to discriminant

fn from_discr(x: usize) -> Self

Get type instance from discriminant

Implementations on Foreign Types

impl<A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A15> EnumLike for (A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A15) where     A0: EnumLike,     A1: EnumLike,     A10: EnumLike,     A11: EnumLike,     A12: EnumLike,     A13: EnumLike,     A14: EnumLike,     A15: EnumLike,     A2: EnumLike,     A3: EnumLike,     A4: EnumLike,     A5: EnumLike,     A6: EnumLike,     A7: EnumLike,     A8: EnumLike,     A9: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(     x: usize ) -> (A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A15)

impl<T, S> EnumLike for (T, S) where     S: EnumLike,     T: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(x: usize) -> (T, S)

impl<A> EnumLike for [A; 28] where     A: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(x: usize) -> [A; 28]

impl<A24, A23, A22, A21, A20, A19, A18, A17, A16, A15, A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A25> EnumLike for (A24, A23, A22, A21, A20, A19, A18, A17, A16, A15, A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A25) where     A0: EnumLike,     A1: EnumLike,     A10: EnumLike,     A11: EnumLike,     A12: EnumLike,     A13: EnumLike,     A14: EnumLike,     A15: EnumLike,     A16: EnumLike,     A17: EnumLike,     A18: EnumLike,     A19: EnumLike,     A2: EnumLike,     A20: EnumLike,     A21: EnumLike,     A22: EnumLike,     A23: EnumLike,     A24: EnumLike,     A25: EnumLike,     A3: EnumLike,     A4: EnumLike,     A5: EnumLike,     A6: EnumLike,     A7: EnumLike,     A8: EnumLike,     A9: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(     x: usize ) -> (A24, A23, A22, A21, A20, A19, A18, A17, A16, A15, A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A25)

impl<A6, A5, A4, A3, A2, A1, A0, A7> EnumLike for (A6, A5, A4, A3, A2, A1, A0, A7) where     A0: EnumLike,     A1: EnumLike,     A2: EnumLike,     A3: EnumLike,     A4: EnumLike,     A5: EnumLike,     A6: EnumLike,     A7: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(x: usize) -> (A6, A5, A4, A3, A2, A1, A0, A7)

impl<A1, A0, A2> EnumLike for (A1, A0, A2) where     A0: EnumLike,     A1: EnumLike,     A2: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(x: usize) -> (A1, A0, A2)

impl<A> EnumLike for [A; 13] where     A: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(x: usize) -> [A; 13]

impl<A25, A24, A23, A22, A21, A20, A19, A18, A17, A16, A15, A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A26> EnumLike for (A25, A24, A23, A22, A21, A20, A19, A18, A17, A16, A15, A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A26) where     A0: EnumLike,     A1: EnumLike,     A10: EnumLike,     A11: EnumLike,     A12: EnumLike,     A13: EnumLike,     A14: EnumLike,     A15: EnumLike,     A16: EnumLike,     A17: EnumLike,     A18: EnumLike,     A19: EnumLike,     A2: EnumLike,     A20: EnumLike,     A21: EnumLike,     A22: EnumLike,     A23: EnumLike,     A24: EnumLike,     A25: EnumLike,     A26: EnumLike,     A3: EnumLike,     A4: EnumLike,     A5: EnumLike,     A6: EnumLike,     A7: EnumLike,     A8: EnumLike,     A9: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(     x: usize ) -> (A25, A24, A23, A22, A21, A20, A19, A18, A17, A16, A15, A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A26)

impl<A> EnumLike for [A; 14] where     A: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(x: usize) -> [A; 14]

impl<A26, A25, A24, A23, A22, A21, A20, A19, A18, A17, A16, A15, A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A27> EnumLike for (A26, A25, A24, A23, A22, A21, A20, A19, A18, A17, A16, A15, A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A27) where     A0: EnumLike,     A1: EnumLike,     A10: EnumLike,     A11: EnumLike,     A12: EnumLike,     A13: EnumLike,     A14: EnumLike,     A15: EnumLike,     A16: EnumLike,     A17: EnumLike,     A18: EnumLike,     A19: EnumLike,     A2: EnumLike,     A20: EnumLike,     A21: EnumLike,     A22: EnumLike,     A23: EnumLike,     A24: EnumLike,     A25: EnumLike,     A26: EnumLike,     A27: EnumLike,     A3: EnumLike,     A4: EnumLike,     A5: EnumLike,     A6: EnumLike,     A7: EnumLike,     A8: EnumLike,     A9: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(     x: usize ) -> (A26, A25, A24, A23, A22, A21, A20, A19, A18, A17, A16, A15, A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A27)

impl<A21, A20, A19, A18, A17, A16, A15, A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A22> EnumLike for (A21, A20, A19, A18, A17, A16, A15, A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A22) where     A0: EnumLike,     A1: EnumLike,     A10: EnumLike,     A11: EnumLike,     A12: EnumLike,     A13: EnumLike,     A14: EnumLike,     A15: EnumLike,     A16: EnumLike,     A17: EnumLike,     A18: EnumLike,     A19: EnumLike,     A2: EnumLike,     A20: EnumLike,     A21: EnumLike,     A22: EnumLike,     A3: EnumLike,     A4: EnumLike,     A5: EnumLike,     A6: EnumLike,     A7: EnumLike,     A8: EnumLike,     A9: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(     x: usize ) -> (A21, A20, A19, A18, A17, A16, A15, A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A22)

impl<T> EnumLike for (T,) where     T: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(x: usize) -> (T,)

impl<A> EnumLike for [A; 25] where     A: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(x: usize) -> [A; 25]

impl<A19, A18, A17, A16, A15, A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A20> EnumLike for (A19, A18, A17, A16, A15, A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A20) where     A0: EnumLike,     A1: EnumLike,     A10: EnumLike,     A11: EnumLike,     A12: EnumLike,     A13: EnumLike,     A14: EnumLike,     A15: EnumLike,     A16: EnumLike,     A17: EnumLike,     A18: EnumLike,     A19: EnumLike,     A2: EnumLike,     A20: EnumLike,     A3: EnumLike,     A4: EnumLike,     A5: EnumLike,     A6: EnumLike,     A7: EnumLike,     A8: EnumLike,     A9: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(     x: usize ) -> (A19, A18, A17, A16, A15, A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A20)

impl<A> EnumLike for [A; 31] where     A: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(x: usize) -> [A; 31]

impl<A3, A2, A1, A0, A4> EnumLike for (A3, A2, A1, A0, A4) where     A0: EnumLike,     A1: EnumLike,     A2: EnumLike,     A3: EnumLike,     A4: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(x: usize) -> (A3, A2, A1, A0, A4)

impl<A> EnumLike for [A; 2] where     A: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(x: usize) -> [A; 2]

impl<A> EnumLike for [A; 30] where     A: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(x: usize) -> [A; 30]

impl<T, S> EnumLike for Result<T, S> where     S: EnumLike,     T: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(x: usize) -> Result<T, S>

impl<T> EnumLike for [T; 0] where     T: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(_x: usize) -> [T; 0]

impl<A> EnumLike for [A; 29] where     A: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(x: usize) -> [A; 29]

impl<A> EnumLike for [A; 23] where     A: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(x: usize) -> [A; 23]

impl<A> EnumLike for [A; 15] where     A: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(x: usize) -> [A; 15]

impl<A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A13> EnumLike for (A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A13) where     A0: EnumLike,     A1: EnumLike,     A10: EnumLike,     A11: EnumLike,     A12: EnumLike,     A13: EnumLike,     A2: EnumLike,     A3: EnumLike,     A4: EnumLike,     A5: EnumLike,     A6: EnumLike,     A7: EnumLike,     A8: EnumLike,     A9: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(     x: usize ) -> (A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A13)

impl<A29, A28, A27, A26, A25, A24, A23, A22, A21, A20, A19, A18, A17, A16, A15, A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A30> EnumLike for (A29, A28, A27, A26, A25, A24, A23, A22, A21, A20, A19, A18, A17, A16, A15, A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A30) where     A0: EnumLike,     A1: EnumLike,     A10: EnumLike,     A11: EnumLike,     A12: EnumLike,     A13: EnumLike,     A14: EnumLike,     A15: EnumLike,     A16: EnumLike,     A17: EnumLike,     A18: EnumLike,     A19: EnumLike,     A2: EnumLike,     A20: EnumLike,     A21: EnumLike,     A22: EnumLike,     A23: EnumLike,     A24: EnumLike,     A25: EnumLike,     A26: EnumLike,     A27: EnumLike,     A28: EnumLike,     A29: EnumLike,     A3: EnumLike,     A30: EnumLike,     A4: EnumLike,     A5: EnumLike,     A6: EnumLike,     A7: EnumLike,     A8: EnumLike,     A9: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(     x: usize ) -> (A29, A28, A27, A26, A25, A24, A23, A22, A21, A20, A19, A18, A17, A16, A15, A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A30)

impl<A> EnumLike for [A; 32] where     A: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(x: usize) -> [A; 32]

impl<A> EnumLike for [A; 19] where     A: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(x: usize) -> [A; 19]

impl<A> EnumLike for [A; 18] where     A: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(x: usize) -> [A; 18]

impl<A> EnumLike for [A; 24] where     A: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(x: usize) -> [A; 24]

impl<A> EnumLike for [A; 8] where     A: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(x: usize) -> [A; 8]

impl<A> EnumLike for [A; 20] where     A: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(x: usize) -> [A; 20]

impl<A> EnumLike for [A; 1] where     A: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(x: usize) -> [A; 1]

impl<A22, A21, A20, A19, A18, A17, A16, A15, A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A23> EnumLike for (A22, A21, A20, A19, A18, A17, A16, A15, A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A23) where     A0: EnumLike,     A1: EnumLike,     A10: EnumLike,     A11: EnumLike,     A12: EnumLike,     A13: EnumLike,     A14: EnumLike,     A15: EnumLike,     A16: EnumLike,     A17: EnumLike,     A18: EnumLike,     A19: EnumLike,     A2: EnumLike,     A20: EnumLike,     A21: EnumLike,     A22: EnumLike,     A23: EnumLike,     A3: EnumLike,     A4: EnumLike,     A5: EnumLike,     A6: EnumLike,     A7: EnumLike,     A8: EnumLike,     A9: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(     x: usize ) -> (A22, A21, A20, A19, A18, A17, A16, A15, A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A23)

impl<A> EnumLike for [A; 12] where     A: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(x: usize) -> [A; 12]

impl<A> EnumLike for [A; 27] where     A: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(x: usize) -> [A; 27]

impl EnumLike for ()

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(_x: usize)

impl<A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A11> EnumLike for (A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A11) where     A0: EnumLike,     A1: EnumLike,     A10: EnumLike,     A11: EnumLike,     A2: EnumLike,     A3: EnumLike,     A4: EnumLike,     A5: EnumLike,     A6: EnumLike,     A7: EnumLike,     A8: EnumLike,     A9: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(x: usize) -> (A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A11)

impl<A2, A1, A0, A3> EnumLike for (A2, A1, A0, A3) where     A0: EnumLike,     A1: EnumLike,     A2: EnumLike,     A3: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(x: usize) -> (A2, A1, A0, A3)

impl<A> EnumLike for [A; 6] where     A: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(x: usize) -> [A; 6]

impl<T> EnumLike for Option<T> where     T: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(x: usize) -> Option<T>

impl<A15, A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A16> EnumLike for (A15, A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A16) where     A0: EnumLike,     A1: EnumLike,     A10: EnumLike,     A11: EnumLike,     A12: EnumLike,     A13: EnumLike,     A14: EnumLike,     A15: EnumLike,     A16: EnumLike,     A2: EnumLike,     A3: EnumLike,     A4: EnumLike,     A5: EnumLike,     A6: EnumLike,     A7: EnumLike,     A8: EnumLike,     A9: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(     x: usize ) -> (A15, A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A16)

impl<A> EnumLike for [A; 21] where     A: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(x: usize) -> [A; 21]

impl<A> EnumLike for [A; 3] where     A: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(x: usize) -> [A; 3]

impl<A> EnumLike for [A; 17] where     A: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(x: usize) -> [A; 17]

impl<A16, A15, A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A17> EnumLike for (A16, A15, A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A17) where     A0: EnumLike,     A1: EnumLike,     A10: EnumLike,     A11: EnumLike,     A12: EnumLike,     A13: EnumLike,     A14: EnumLike,     A15: EnumLike,     A16: EnumLike,     A17: EnumLike,     A2: EnumLike,     A3: EnumLike,     A4: EnumLike,     A5: EnumLike,     A6: EnumLike,     A7: EnumLike,     A8: EnumLike,     A9: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(     x: usize ) -> (A16, A15, A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A17)

impl<A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A12> EnumLike for (A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A12) where     A0: EnumLike,     A1: EnumLike,     A10: EnumLike,     A11: EnumLike,     A12: EnumLike,     A2: EnumLike,     A3: EnumLike,     A4: EnumLike,     A5: EnumLike,     A6: EnumLike,     A7: EnumLike,     A8: EnumLike,     A9: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(     x: usize ) -> (A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A12)

impl<A17, A16, A15, A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A18> EnumLike for (A17, A16, A15, A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A18) where     A0: EnumLike,     A1: EnumLike,     A10: EnumLike,     A11: EnumLike,     A12: EnumLike,     A13: EnumLike,     A14: EnumLike,     A15: EnumLike,     A16: EnumLike,     A17: EnumLike,     A18: EnumLike,     A2: EnumLike,     A3: EnumLike,     A4: EnumLike,     A5: EnumLike,     A6: EnumLike,     A7: EnumLike,     A8: EnumLike,     A9: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(     x: usize ) -> (A17, A16, A15, A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A18)

impl<A> EnumLike for [A; 22] where     A: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(x: usize) -> [A; 22]

impl<A30, A29, A28, A27, A26, A25, A24, A23, A22, A21, A20, A19, A18, A17, A16, A15, A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A31> EnumLike for (A30, A29, A28, A27, A26, A25, A24, A23, A22, A21, A20, A19, A18, A17, A16, A15, A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A31) where     A0: EnumLike,     A1: EnumLike,     A10: EnumLike,     A11: EnumLike,     A12: EnumLike,     A13: EnumLike,     A14: EnumLike,     A15: EnumLike,     A16: EnumLike,     A17: EnumLike,     A18: EnumLike,     A19: EnumLike,     A2: EnumLike,     A20: EnumLike,     A21: EnumLike,     A22: EnumLike,     A23: EnumLike,     A24: EnumLike,     A25: EnumLike,     A26: EnumLike,     A27: EnumLike,     A28: EnumLike,     A29: EnumLike,     A3: EnumLike,     A30: EnumLike,     A31: EnumLike,     A4: EnumLike,     A5: EnumLike,     A6: EnumLike,     A7: EnumLike,     A8: EnumLike,     A9: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(     x: usize ) -> (A30, A29, A28, A27, A26, A25, A24, A23, A22, A21, A20, A19, A18, A17, A16, A15, A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A31)

impl<A> EnumLike for [A; 16] where     A: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(x: usize) -> [A; 16]

impl<A7, A6, A5, A4, A3, A2, A1, A0, A8> EnumLike for (A7, A6, A5, A4, A3, A2, A1, A0, A8) where     A0: EnumLike,     A1: EnumLike,     A2: EnumLike,     A3: EnumLike,     A4: EnumLike,     A5: EnumLike,     A6: EnumLike,     A7: EnumLike,     A8: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(x: usize) -> (A7, A6, A5, A4, A3, A2, A1, A0, A8)

impl<A> EnumLike for [A; 4] where     A: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(x: usize) -> [A; 4]

impl<A> EnumLike for [A; 26] where     A: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(x: usize) -> [A; 26]

impl<A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A14> EnumLike for (A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A14) where     A0: EnumLike,     A1: EnumLike,     A10: EnumLike,     A11: EnumLike,     A12: EnumLike,     A13: EnumLike,     A14: EnumLike,     A2: EnumLike,     A3: EnumLike,     A4: EnumLike,     A5: EnumLike,     A6: EnumLike,     A7: EnumLike,     A8: EnumLike,     A9: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(     x: usize ) -> (A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A14)

impl EnumLike for bool

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(x: usize) -> bool

impl<A> EnumLike for [A; 9] where     A: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(x: usize) -> [A; 9]

impl<A> EnumLike for [A; 10] where     A: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(x: usize) -> [A; 10]

impl<A27, A26, A25, A24, A23, A22, A21, A20, A19, A18, A17, A16, A15, A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A28> EnumLike for (A27, A26, A25, A24, A23, A22, A21, A20, A19, A18, A17, A16, A15, A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A28) where     A0: EnumLike,     A1: EnumLike,     A10: EnumLike,     A11: EnumLike,     A12: EnumLike,     A13: EnumLike,     A14: EnumLike,     A15: EnumLike,     A16: EnumLike,     A17: EnumLike,     A18: EnumLike,     A19: EnumLike,     A2: EnumLike,     A20: EnumLike,     A21: EnumLike,     A22: EnumLike,     A23: EnumLike,     A24: EnumLike,     A25: EnumLike,     A26: EnumLike,     A27: EnumLike,     A28: EnumLike,     A3: EnumLike,     A4: EnumLike,     A5: EnumLike,     A6: EnumLike,     A7: EnumLike,     A8: EnumLike,     A9: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(     x: usize ) -> (A27, A26, A25, A24, A23, A22, A21, A20, A19, A18, A17, A16, A15, A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A28)

impl<A> EnumLike for [A; 7] where     A: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(x: usize) -> [A; 7]

impl<A20, A19, A18, A17, A16, A15, A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A21> EnumLike for (A20, A19, A18, A17, A16, A15, A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A21) where     A0: EnumLike,     A1: EnumLike,     A10: EnumLike,     A11: EnumLike,     A12: EnumLike,     A13: EnumLike,     A14: EnumLike,     A15: EnumLike,     A16: EnumLike,     A17: EnumLike,     A18: EnumLike,     A19: EnumLike,     A2: EnumLike,     A20: EnumLike,     A21: EnumLike,     A3: EnumLike,     A4: EnumLike,     A5: EnumLike,     A6: EnumLike,     A7: EnumLike,     A8: EnumLike,     A9: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(     x: usize ) -> (A20, A19, A18, A17, A16, A15, A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A21)

impl<A8, A7, A6, A5, A4, A3, A2, A1, A0, A9> EnumLike for (A8, A7, A6, A5, A4, A3, A2, A1, A0, A9) where     A0: EnumLike,     A1: EnumLike,     A2: EnumLike,     A3: EnumLike,     A4: EnumLike,     A5: EnumLike,     A6: EnumLike,     A7: EnumLike,     A8: EnumLike,     A9: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(x: usize) -> (A8, A7, A6, A5, A4, A3, A2, A1, A0, A9)

impl<A28, A27, A26, A25, A24, A23, A22, A21, A20, A19, A18, A17, A16, A15, A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A29> EnumLike for (A28, A27, A26, A25, A24, A23, A22, A21, A20, A19, A18, A17, A16, A15, A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A29) where     A0: EnumLike,     A1: EnumLike,     A10: EnumLike,     A11: EnumLike,     A12: EnumLike,     A13: EnumLike,     A14: EnumLike,     A15: EnumLike,     A16: EnumLike,     A17: EnumLike,     A18: EnumLike,     A19: EnumLike,     A2: EnumLike,     A20: EnumLike,     A21: EnumLike,     A22: EnumLike,     A23: EnumLike,     A24: EnumLike,     A25: EnumLike,     A26: EnumLike,     A27: EnumLike,     A28: EnumLike,     A29: EnumLike,     A3: EnumLike,     A4: EnumLike,     A5: EnumLike,     A6: EnumLike,     A7: EnumLike,     A8: EnumLike,     A9: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(     x: usize ) -> (A28, A27, A26, A25, A24, A23, A22, A21, A20, A19, A18, A17, A16, A15, A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A29)

impl<A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A10> EnumLike for (A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A10) where     A0: EnumLike,     A1: EnumLike,     A10: EnumLike,     A2: EnumLike,     A3: EnumLike,     A4: EnumLike,     A5: EnumLike,     A6: EnumLike,     A7: EnumLike,     A8: EnumLike,     A9: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(x: usize) -> (A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A10)

impl<A5, A4, A3, A2, A1, A0, A6> EnumLike for (A5, A4, A3, A2, A1, A0, A6) where     A0: EnumLike,     A1: EnumLike,     A2: EnumLike,     A3: EnumLike,     A4: EnumLike,     A5: EnumLike,     A6: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(x: usize) -> (A5, A4, A3, A2, A1, A0, A6)

impl<A> EnumLike for [A; 5] where     A: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(x: usize) -> [A; 5]

impl<A23, A22, A21, A20, A19, A18, A17, A16, A15, A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A24> EnumLike for (A23, A22, A21, A20, A19, A18, A17, A16, A15, A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A24) where     A0: EnumLike,     A1: EnumLike,     A10: EnumLike,     A11: EnumLike,     A12: EnumLike,     A13: EnumLike,     A14: EnumLike,     A15: EnumLike,     A16: EnumLike,     A17: EnumLike,     A18: EnumLike,     A19: EnumLike,     A2: EnumLike,     A20: EnumLike,     A21: EnumLike,     A22: EnumLike,     A23: EnumLike,     A24: EnumLike,     A3: EnumLike,     A4: EnumLike,     A5: EnumLike,     A6: EnumLike,     A7: EnumLike,     A8: EnumLike,     A9: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(     x: usize ) -> (A23, A22, A21, A20, A19, A18, A17, A16, A15, A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A24)

impl<A> EnumLike for [A; 11] where     A: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(x: usize) -> [A; 11]

impl<A18, A17, A16, A15, A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A19> EnumLike for (A18, A17, A16, A15, A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A19) where     A0: EnumLike,     A1: EnumLike,     A10: EnumLike,     A11: EnumLike,     A12: EnumLike,     A13: EnumLike,     A14: EnumLike,     A15: EnumLike,     A16: EnumLike,     A17: EnumLike,     A18: EnumLike,     A19: EnumLike,     A2: EnumLike,     A3: EnumLike,     A4: EnumLike,     A5: EnumLike,     A6: EnumLike,     A7: EnumLike,     A8: EnumLike,     A9: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(     x: usize ) -> (A18, A17, A16, A15, A14, A13, A12, A11, A10, A9, A8, A7, A6, A5, A4, A3, A2, A1, A0, A19)

impl<A4, A3, A2, A1, A0, A5> EnumLike for (A4, A3, A2, A1, A0, A5) where     A0: EnumLike,     A1: EnumLike,     A2: EnumLike,     A3: EnumLike,     A4: EnumLike,     A5: EnumLike,

const NUM_VARIANTS: usize

fn to_discr(self) -> usize

fn from_discr(x: usize) -> (A4, A3, A2, A1, A0, A5)

Implementors