[−][src]Enum enumx::Enum2

pub enum Enum2<T0, T1> {
    _0(T0),
    _1(T1),
}

Variants

_0(T0)

_1(T1)

Trait Implementations

`impl<T0: Debug, T1: Debug> Debug for Enum2<T0, T1>`[src]

`fn fmt(&self, f: &mut Formatter) -> Result`[src]

`impl<T0: Eq, T1: Eq> Eq for Enum2<T0, T1>`[src]

`impl<T0, T1> ExchangeFrom<Enum0, (Nil, AA)> for Enum2<T0, T1>`[src]

`fn exchange_from(src: Enum0) -> Self`[src]

`impl<Indices, S0, T0, T1> ExchangeFrom<Enum1<S0>, (Indices, AA)> for Enum2<T0, T1> where Self: FromVariant<S0, (Indices, VA)>,` [src]

`fn exchange_from(src: Enum1<S0>) -> Self`[src]

`impl<L, R, S0, S1, T0, T1> ExchangeFrom<Enum2<S0, S1>, (LR<L, R>, AA)> for Enum2<T0, T1> where Self: FromVariant<S0, (L, VA)> + ExchangeFrom<Enum1<S1>, (R, AA)>,` [src]

`fn exchange_from(src: Enum2<S0, S1>) -> Self`[src]

`impl<L, R, S0, S1, T0, T1, T2> ExchangeFrom<Enum2<S0, S1>, (LR<L, R>, AA)> for Enum3<T0, T1, T2> where Self: FromVariant<S0, (L, VA)> + ExchangeFrom<Enum1<S1>, (R, AA)>,` [src]

`fn exchange_from(src: Enum2<S0, S1>) -> Self`[src]

`impl<L, R, S0, S1, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> ExchangeFrom<Enum2<S0, S1>, (LR<L, R>, AA)> for Enum12<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> where Self: FromVariant<S0, (L, VA)> + ExchangeFrom<Enum1<S1>, (R, AA)>,` [src]

`fn exchange_from(src: Enum2<S0, S1>) -> Self`[src]

`impl<L, R, S0, S1, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> ExchangeFrom<Enum2<S0, S1>, (LR<L, R>, AA)> for Enum13<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> where Self: FromVariant<S0, (L, VA)> + ExchangeFrom<Enum1<S1>, (R, AA)>,` [src]

`fn exchange_from(src: Enum2<S0, S1>) -> Self`[src]

`impl<L, R, S0, S1, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> ExchangeFrom<Enum2<S0, S1>, (LR<L, R>, AA)> for Enum14<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> where Self: FromVariant<S0, (L, VA)> + ExchangeFrom<Enum1<S1>, (R, AA)>,` [src]

`fn exchange_from(src: Enum2<S0, S1>) -> Self`[src]

`impl<L, R, S0, S1, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> ExchangeFrom<Enum2<S0, S1>, (LR<L, R>, AA)> for Enum15<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> where Self: FromVariant<S0, (L, VA)> + ExchangeFrom<Enum1<S1>, (R, AA)>,` [src]

`fn exchange_from(src: Enum2<S0, S1>) -> Self`[src]

`impl<L, R, S0, S1, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> ExchangeFrom<Enum2<S0, S1>, (LR<L, R>, AA)> for Enum16<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> where Self: FromVariant<S0, (L, VA)> + ExchangeFrom<Enum1<S1>, (R, AA)>,` [src]

`fn exchange_from(src: Enum2<S0, S1>) -> Self`[src]

`impl<L, R, S0, S1, T0, T1, T2, T3> ExchangeFrom<Enum2<S0, S1>, (LR<L, R>, AA)> for Enum4<T0, T1, T2, T3> where Self: FromVariant<S0, (L, VA)> + ExchangeFrom<Enum1<S1>, (R, AA)>,` [src]

`fn exchange_from(src: Enum2<S0, S1>) -> Self`[src]

`impl<L, R, S0, S1, T0, T1, T2, T3, T4> ExchangeFrom<Enum2<S0, S1>, (LR<L, R>, AA)> for Enum5<T0, T1, T2, T3, T4> where Self: FromVariant<S0, (L, VA)> + ExchangeFrom<Enum1<S1>, (R, AA)>,` [src]

`fn exchange_from(src: Enum2<S0, S1>) -> Self`[src]

`impl<L, R, S0, S1, T0, T1, T2, T3, T4, T5> ExchangeFrom<Enum2<S0, S1>, (LR<L, R>, AA)> for Enum6<T0, T1, T2, T3, T4, T5> where Self: FromVariant<S0, (L, VA)> + ExchangeFrom<Enum1<S1>, (R, AA)>,` [src]

`fn exchange_from(src: Enum2<S0, S1>) -> Self`[src]

`impl<L, R, S0, S1, T0, T1, T2, T3, T4, T5, T6> ExchangeFrom<Enum2<S0, S1>, (LR<L, R>, AA)> for Enum7<T0, T1, T2, T3, T4, T5, T6> where Self: FromVariant<S0, (L, VA)> + ExchangeFrom<Enum1<S1>, (R, AA)>,` [src]

`fn exchange_from(src: Enum2<S0, S1>) -> Self`[src]

`impl<L, R, S0, S1, T0, T1, T2, T3, T4, T5, T6, T7> ExchangeFrom<Enum2<S0, S1>, (LR<L, R>, AA)> for Enum8<T0, T1, T2, T3, T4, T5, T6, T7> where Self: FromVariant<S0, (L, VA)> + ExchangeFrom<Enum1<S1>, (R, AA)>,` [src]

`fn exchange_from(src: Enum2<S0, S1>) -> Self`[src]

`impl<L, R, S0, S1, T0, T1, T2, T3, T4, T5, T6, T7, T8> ExchangeFrom<Enum2<S0, S1>, (LR<L, R>, AA)> for Enum9<T0, T1, T2, T3, T4, T5, T6, T7, T8> where Self: FromVariant<S0, (L, VA)> + ExchangeFrom<Enum1<S1>, (R, AA)>,` [src]

`fn exchange_from(src: Enum2<S0, S1>) -> Self`[src]

`impl<L, R, S0, S1, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> ExchangeFrom<Enum2<S0, S1>, (LR<L, R>, AA)> for Enum10<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> where Self: FromVariant<S0, (L, VA)> + ExchangeFrom<Enum1<S1>, (R, AA)>,` [src]

`fn exchange_from(src: Enum2<S0, S1>) -> Self`[src]

`impl<L, R, S0, S1, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> ExchangeFrom<Enum2<S0, S1>, (LR<L, R>, AA)> for Enum11<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> where Self: FromVariant<S0, (L, VA)> + ExchangeFrom<Enum1<S1>, (R, AA)>,` [src]

`fn exchange_from(src: Enum2<S0, S1>) -> Self`[src]

`impl<T0, T1> FromVariant<T0, (V0, VA)> for Enum2<T0, T1>`[src]

`fn from_variant(variant: T0) -> Self`[src]

`impl<T0, T1> FromVariant<T1, (V1, VA)> for Enum2<T0, T1>`[src]

`fn from_variant(variant: T1) -> Self`[src]

`impl<T0: Ord, T1: Ord> Ord for Enum2<T0, T1>`[src]

`fn cmp(&self, other: &Enum2<T0, T1>) -> Ordering`[src]

`#[must_use]fn max(self, other: Self) -> Self`1.21.0[src]

`#[must_use]fn min(self, other: Self) -> Self`1.21.0[src]

`#[must_use]fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<T0: PartialEq, T1: PartialEq> PartialEq<Enum2<T0, T1>> for Enum2<T0, T1>`[src]

`fn eq(&self, other: &Enum2<T0, T1>) -> bool`[src]

`fn ne(&self, other: &Enum2<T0, T1>) -> bool`[src]

`impl<T0: PartialOrd, T1: PartialOrd> PartialOrd<Enum2<T0, T1>> for Enum2<T0, T1>`[src]

`fn partial_cmp(&self, other: &Enum2<T0, T1>) -> Option<Ordering>`[src]

`fn lt(&self, other: &Enum2<T0, T1>) -> bool`[src]

`fn le(&self, other: &Enum2<T0, T1>) -> bool`[src]

`fn gt(&self, other: &Enum2<T0, T1>) -> bool`[src]

`fn ge(&self, other: &Enum2<T0, T1>) -> bool`[src]

`impl<T0, T1> StructuralEq for Enum2<T0, T1>`[src]

`impl<T0, T1> StructuralPartialEq for Enum2<T0, T1>`[src]

Auto Trait Implementations

`impl<T0, T1> RefUnwindSafe for Enum2<T0, T1> where T0: RefUnwindSafe, T1: RefUnwindSafe,`

`impl<T0, T1> Send for Enum2<T0, T1> where T0: Send, T1: Send,`

`impl<T0, T1> Sync for Enum2<T0, T1> where T0: Sync, T1: Sync,`

`impl<T0, T1> Unpin for Enum2<T0, T1> where T0: Unpin, T1: Unpin,`

`impl<T0, T1> UnwindSafe for Enum2<T0, T1> where T0: UnwindSafe, T1: UnwindSafe,`

Blanket Implementations

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`fn type_id(&self) -> TypeId`[src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

`fn borrow(&self) -> &T`[src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

`fn borrow_mut(&mut self) -> &mut T`[src]

`impl<Src, Dest, Index> EnumxFrom<Src, (Index, FV)> for Dest where Dest: FromVariant<Src, Index>,` [src]

`fn enumx_from(Src) -> Dest`[src]

`impl<Src, Dest, Indices> EnumxFrom<Src, (Indices, XF)> for Dest where Dest: ExchangeFrom<Src, Indices>,` [src]

`fn enumx_from(Src) -> Dest`[src]

`impl<Src, Dest, Proto, Indices> ExchangeFrom<Src, (Indices, NA)> for Dest where Dest: ExchangeFrom<Proto, (Indices, AA)>, Src: EnumX<Proto = Proto>,` [src]

`fn exchange_from(Src) -> Dest`[src]

`impl<Src, Dest, Indices> ExchangeInto<Dest, (Indices, AA)> for Src where Dest: ExchangeFrom<Src, (Indices, AA)>,` [src]

`fn exchange_into(Self) -> Dest`[src]

`impl<Src, Dest, Proto, Indices> ExchangeInto<Dest, (Indices, AN)> for Src where Dest: EnumX<Proto = Proto>, Src: ExchangeInto<Proto, (Indices, AA)>,` [src]

`fn exchange_into(Self) -> Dest`[src]

`impl<T> From<T> for T`[src]

`fn from(t: T) -> T`[src]

`impl<T, U> Into for T where U: From<T>,` [src]

`fn into(self) -> U`[src]

`impl<Enum, Variant, Index> IntoEnum<Enum, Index> for Variant where Enum: FromVariant<Variant, Index>,` [src]

`fn into_enum(Self) -> Enum`[src]

`impl<Src, Dest, Index> IntoEnumx<Dest, Index> for Src where Dest: EnumxFrom<Src, Index>,` [src]

`fn into_enumx(Self) -> Dest`[src]

`impl<T, U> TryFrom for T where U: Into<T>,` [src]

`type Error = Infallible`

The type returned in the event of a conversion error.

`fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>`[src]

`impl<T, U> TryInto for T where U: TryFrom<T>,` [src]

`type Error = >::Error`

The type returned in the event of a conversion error.

`fn try_into(self) -> Result<U, >::Error>`[src]

[−][src]Enum enumx::Enum2

Variants

Trait Implementations

impl<T0: Debug, T1: Debug> Debug for Enum2<T0, T1>[src]

fn fmt(&self, f: &mut Formatter) -> Result[src]

impl<T0: Eq, T1: Eq> Eq for Enum2<T0, T1>[src]

impl<T0, T1> ExchangeFrom<Enum0, (Nil, AA)> for Enum2<T0, T1>[src]

fn exchange_from(src: Enum0) -> Self[src]

impl<Indices, S0, T0, T1> ExchangeFrom<Enum1<S0>, (Indices, AA)> for Enum2<T0, T1> where Self: FromVariant<S0, (Indices, VA)>, [src]

fn exchange_from(src: Enum1<S0>) -> Self[src]

impl<L, R, S0, S1, T0, T1> ExchangeFrom<Enum2<S0, S1>, (LR<L, R>, AA)> for Enum2<T0, T1> where Self: FromVariant<S0, (L, VA)> + ExchangeFrom<Enum1<S1>, (R, AA)>, [src]

fn exchange_from(src: Enum2<S0, S1>) -> Self[src]

impl<L, R, S0, S1, T0, T1, T2> ExchangeFrom<Enum2<S0, S1>, (LR<L, R>, AA)> for Enum3<T0, T1, T2> where Self: FromVariant<S0, (L, VA)> + ExchangeFrom<Enum1<S1>, (R, AA)>, [src]

fn exchange_from(src: Enum2<S0, S1>) -> Self[src]

impl<L, R, S0, S1, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> ExchangeFrom<Enum2<S0, S1>, (LR<L, R>, AA)> for Enum12<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> where Self: FromVariant<S0, (L, VA)> + ExchangeFrom<Enum1<S1>, (R, AA)>, [src]

fn exchange_from(src: Enum2<S0, S1>) -> Self[src]

impl<L, R, S0, S1, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> ExchangeFrom<Enum2<S0, S1>, (LR<L, R>, AA)> for Enum13<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> where Self: FromVariant<S0, (L, VA)> + ExchangeFrom<Enum1<S1>, (R, AA)>, [src]

fn exchange_from(src: Enum2<S0, S1>) -> Self[src]

impl<L, R, S0, S1, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> ExchangeFrom<Enum2<S0, S1>, (LR<L, R>, AA)> for Enum14<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> where Self: FromVariant<S0, (L, VA)> + ExchangeFrom<Enum1<S1>, (R, AA)>, [src]

fn exchange_from(src: Enum2<S0, S1>) -> Self[src]

impl<L, R, S0, S1, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> ExchangeFrom<Enum2<S0, S1>, (LR<L, R>, AA)> for Enum15<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> where Self: FromVariant<S0, (L, VA)> + ExchangeFrom<Enum1<S1>, (R, AA)>, [src]

fn exchange_from(src: Enum2<S0, S1>) -> Self[src]

impl<L, R, S0, S1, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> ExchangeFrom<Enum2<S0, S1>, (LR<L, R>, AA)> for Enum16<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> where Self: FromVariant<S0, (L, VA)> + ExchangeFrom<Enum1<S1>, (R, AA)>, [src]

fn exchange_from(src: Enum2<S0, S1>) -> Self[src]

impl<L, R, S0, S1, T0, T1, T2, T3> ExchangeFrom<Enum2<S0, S1>, (LR<L, R>, AA)> for Enum4<T0, T1, T2, T3> where Self: FromVariant<S0, (L, VA)> + ExchangeFrom<Enum1<S1>, (R, AA)>, [src]

fn exchange_from(src: Enum2<S0, S1>) -> Self[src]

impl<L, R, S0, S1, T0, T1, T2, T3, T4> ExchangeFrom<Enum2<S0, S1>, (LR<L, R>, AA)> for Enum5<T0, T1, T2, T3, T4> where Self: FromVariant<S0, (L, VA)> + ExchangeFrom<Enum1<S1>, (R, AA)>, [src]

fn exchange_from(src: Enum2<S0, S1>) -> Self[src]

impl<L, R, S0, S1, T0, T1, T2, T3, T4, T5> ExchangeFrom<Enum2<S0, S1>, (LR<L, R>, AA)> for Enum6<T0, T1, T2, T3, T4, T5> where Self: FromVariant<S0, (L, VA)> + ExchangeFrom<Enum1<S1>, (R, AA)>, [src]

fn exchange_from(src: Enum2<S0, S1>) -> Self[src]

impl<L, R, S0, S1, T0, T1, T2, T3, T4, T5, T6> ExchangeFrom<Enum2<S0, S1>, (LR<L, R>, AA)> for Enum7<T0, T1, T2, T3, T4, T5, T6> where Self: FromVariant<S0, (L, VA)> + ExchangeFrom<Enum1<S1>, (R, AA)>, [src]

fn exchange_from(src: Enum2<S0, S1>) -> Self[src]

impl<L, R, S0, S1, T0, T1, T2, T3, T4, T5, T6, T7> ExchangeFrom<Enum2<S0, S1>, (LR<L, R>, AA)> for Enum8<T0, T1, T2, T3, T4, T5, T6, T7> where Self: FromVariant<S0, (L, VA)> + ExchangeFrom<Enum1<S1>, (R, AA)>, [src]

fn exchange_from(src: Enum2<S0, S1>) -> Self[src]

impl<L, R, S0, S1, T0, T1, T2, T3, T4, T5, T6, T7, T8> ExchangeFrom<Enum2<S0, S1>, (LR<L, R>, AA)> for Enum9<T0, T1, T2, T3, T4, T5, T6, T7, T8> where Self: FromVariant<S0, (L, VA)> + ExchangeFrom<Enum1<S1>, (R, AA)>, [src]

fn exchange_from(src: Enum2<S0, S1>) -> Self[src]

impl<L, R, S0, S1, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> ExchangeFrom<Enum2<S0, S1>, (LR<L, R>, AA)> for Enum10<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> where Self: FromVariant<S0, (L, VA)> + ExchangeFrom<Enum1<S1>, (R, AA)>, [src]

fn exchange_from(src: Enum2<S0, S1>) -> Self[src]

impl<L, R, S0, S1, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> ExchangeFrom<Enum2<S0, S1>, (LR<L, R>, AA)> for Enum11<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> where Self: FromVariant<S0, (L, VA)> + ExchangeFrom<Enum1<S1>, (R, AA)>, [src]

fn exchange_from(src: Enum2<S0, S1>) -> Self[src]

impl<T0, T1> FromVariant<T0, (V0, VA)> for Enum2<T0, T1>[src]

fn from_variant(variant: T0) -> Self[src]

impl<T0, T1> FromVariant<T1, (V1, VA)> for Enum2<T0, T1>[src]

fn from_variant(variant: T1) -> Self[src]

impl<T0: Ord, T1: Ord> Ord for Enum2<T0, T1>[src]

fn cmp(&self, other: &Enum2<T0, T1>) -> Ordering[src]

#[must_use]fn max(self, other: Self) -> Self1.21.0[src]

#[must_use]fn min(self, other: Self) -> Self1.21.0[src]

#[must_use]fn clamp(self, min: Self, max: Self) -> Self[src]

impl<T0: PartialEq, T1: PartialEq> PartialEq<Enum2<T0, T1>> for Enum2<T0, T1>[src]

fn eq(&self, other: &Enum2<T0, T1>) -> bool[src]

fn ne(&self, other: &Enum2<T0, T1>) -> bool[src]

impl<T0: PartialOrd, T1: PartialOrd> PartialOrd<Enum2<T0, T1>> for Enum2<T0, T1>[src]

fn partial_cmp(&self, other: &Enum2<T0, T1>) -> Option<Ordering>[src]

fn lt(&self, other: &Enum2<T0, T1>) -> bool[src]

fn le(&self, other: &Enum2<T0, T1>) -> bool[src]

fn gt(&self, other: &Enum2<T0, T1>) -> bool[src]

fn ge(&self, other: &Enum2<T0, T1>) -> bool[src]

impl<T0, T1> StructuralEq for Enum2<T0, T1>[src]

impl<T0, T1> StructuralPartialEq for Enum2<T0, T1>[src]

Auto Trait Implementations

impl<T0, T1> RefUnwindSafe for Enum2<T0, T1> where T0: RefUnwindSafe, T1: RefUnwindSafe,

impl<T0, T1> Send for Enum2<T0, T1> where T0: Send, T1: Send,

impl<T0, T1> Sync for Enum2<T0, T1> where T0: Sync, T1: Sync,

impl<T0, T1> Unpin for Enum2<T0, T1> where T0: Unpin, T1: Unpin,

impl<T0, T1> UnwindSafe for Enum2<T0, T1> where T0: UnwindSafe, T1: UnwindSafe,

Blanket Implementations

impl<T> Any for T where T: 'static + ?Sized, [src]

fn type_id(&self) -> TypeId[src]

impl<T> Borrow<T> for T where T: ?Sized, [src]

fn borrow(&self) -> &T[src]

impl<T> BorrowMut<T> for T where T: ?Sized, [src]

fn borrow_mut(&mut self) -> &mut T[src]

impl<Src, Dest, Index> EnumxFrom<Src, (Index, FV)> for Dest where Dest: FromVariant<Src, Index>, [src]

fn enumx_from(Src) -> Dest[src]

impl<Src, Dest, Indices> EnumxFrom<Src, (Indices, XF)> for Dest where Dest: ExchangeFrom<Src, Indices>, [src]

fn enumx_from(Src) -> Dest[src]

impl<Src, Dest, Proto, Indices> ExchangeFrom<Src, (Indices, NA)> for Dest where Dest: ExchangeFrom<Proto, (Indices, AA)>, Src: EnumX<Proto = Proto>, [src]

fn exchange_from(Src) -> Dest[src]

impl<Src, Dest, Indices> ExchangeInto<Dest, (Indices, AA)> for Src where Dest: ExchangeFrom<Src, (Indices, AA)>, [src]

`impl<T0: Debug, T1: Debug> Debug for Enum2<T0, T1>`[src]

`fn fmt(&self, f: &mut Formatter) -> Result`[src]

`impl<T0: Eq, T1: Eq> Eq for Enum2<T0, T1>`[src]

`impl<T0, T1> ExchangeFrom<Enum0, (Nil, AA)> for Enum2<T0, T1>`[src]

`fn exchange_from(src: Enum0) -> Self`[src]

`impl<Indices, S0, T0, T1> ExchangeFrom<Enum1<S0>, (Indices, AA)> for Enum2<T0, T1> where Self: FromVariant<S0, (Indices, VA)>,` [src]

`fn exchange_from(src: Enum1<S0>) -> Self`[src]

`impl<L, R, S0, S1, T0, T1> ExchangeFrom<Enum2<S0, S1>, (LR<L, R>, AA)> for Enum2<T0, T1> where Self: FromVariant<S0, (L, VA)> + ExchangeFrom<Enum1<S1>, (R, AA)>,` [src]

`fn exchange_from(src: Enum2<S0, S1>) -> Self`[src]

`impl<L, R, S0, S1, T0, T1, T2> ExchangeFrom<Enum2<S0, S1>, (LR<L, R>, AA)> for Enum3<T0, T1, T2> where Self: FromVariant<S0, (L, VA)> + ExchangeFrom<Enum1<S1>, (R, AA)>,` [src]

`fn exchange_from(src: Enum2<S0, S1>) -> Self`[src]

`impl<L, R, S0, S1, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> ExchangeFrom<Enum2<S0, S1>, (LR<L, R>, AA)> for Enum12<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> where Self: FromVariant<S0, (L, VA)> + ExchangeFrom<Enum1<S1>, (R, AA)>,` [src]

`fn exchange_from(src: Enum2<S0, S1>) -> Self`[src]

`impl<L, R, S0, S1, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> ExchangeFrom<Enum2<S0, S1>, (LR<L, R>, AA)> for Enum13<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> where Self: FromVariant<S0, (L, VA)> + ExchangeFrom<Enum1<S1>, (R, AA)>,` [src]

`fn exchange_from(src: Enum2<S0, S1>) -> Self`[src]

`impl<L, R, S0, S1, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> ExchangeFrom<Enum2<S0, S1>, (LR<L, R>, AA)> for Enum14<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> where Self: FromVariant<S0, (L, VA)> + ExchangeFrom<Enum1<S1>, (R, AA)>,` [src]

`fn exchange_from(src: Enum2<S0, S1>) -> Self`[src]

`impl<L, R, S0, S1, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> ExchangeFrom<Enum2<S0, S1>, (LR<L, R>, AA)> for Enum15<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> where Self: FromVariant<S0, (L, VA)> + ExchangeFrom<Enum1<S1>, (R, AA)>,` [src]

`fn exchange_from(src: Enum2<S0, S1>) -> Self`[src]

`impl<L, R, S0, S1, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> ExchangeFrom<Enum2<S0, S1>, (LR<L, R>, AA)> for Enum16<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> where Self: FromVariant<S0, (L, VA)> + ExchangeFrom<Enum1<S1>, (R, AA)>,` [src]

`fn exchange_from(src: Enum2<S0, S1>) -> Self`[src]

`impl<L, R, S0, S1, T0, T1, T2, T3> ExchangeFrom<Enum2<S0, S1>, (LR<L, R>, AA)> for Enum4<T0, T1, T2, T3> where Self: FromVariant<S0, (L, VA)> + ExchangeFrom<Enum1<S1>, (R, AA)>,` [src]

`fn exchange_from(src: Enum2<S0, S1>) -> Self`[src]

`impl<L, R, S0, S1, T0, T1, T2, T3, T4> ExchangeFrom<Enum2<S0, S1>, (LR<L, R>, AA)> for Enum5<T0, T1, T2, T3, T4> where Self: FromVariant<S0, (L, VA)> + ExchangeFrom<Enum1<S1>, (R, AA)>,` [src]

`fn exchange_from(src: Enum2<S0, S1>) -> Self`[src]

`impl<L, R, S0, S1, T0, T1, T2, T3, T4, T5> ExchangeFrom<Enum2<S0, S1>, (LR<L, R>, AA)> for Enum6<T0, T1, T2, T3, T4, T5> where Self: FromVariant<S0, (L, VA)> + ExchangeFrom<Enum1<S1>, (R, AA)>,` [src]

`fn exchange_from(src: Enum2<S0, S1>) -> Self`[src]

`impl<L, R, S0, S1, T0, T1, T2, T3, T4, T5, T6> ExchangeFrom<Enum2<S0, S1>, (LR<L, R>, AA)> for Enum7<T0, T1, T2, T3, T4, T5, T6> where Self: FromVariant<S0, (L, VA)> + ExchangeFrom<Enum1<S1>, (R, AA)>,` [src]

`fn exchange_from(src: Enum2<S0, S1>) -> Self`[src]

`impl<L, R, S0, S1, T0, T1, T2, T3, T4, T5, T6, T7> ExchangeFrom<Enum2<S0, S1>, (LR<L, R>, AA)> for Enum8<T0, T1, T2, T3, T4, T5, T6, T7> where Self: FromVariant<S0, (L, VA)> + ExchangeFrom<Enum1<S1>, (R, AA)>,` [src]

`fn exchange_from(src: Enum2<S0, S1>) -> Self`[src]

`impl<L, R, S0, S1, T0, T1, T2, T3, T4, T5, T6, T7, T8> ExchangeFrom<Enum2<S0, S1>, (LR<L, R>, AA)> for Enum9<T0, T1, T2, T3, T4, T5, T6, T7, T8> where Self: FromVariant<S0, (L, VA)> + ExchangeFrom<Enum1<S1>, (R, AA)>,` [src]

`fn exchange_from(src: Enum2<S0, S1>) -> Self`[src]

`impl<L, R, S0, S1, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> ExchangeFrom<Enum2<S0, S1>, (LR<L, R>, AA)> for Enum10<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> where Self: FromVariant<S0, (L, VA)> + ExchangeFrom<Enum1<S1>, (R, AA)>,` [src]

`fn exchange_from(src: Enum2<S0, S1>) -> Self`[src]

`impl<L, R, S0, S1, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> ExchangeFrom<Enum2<S0, S1>, (LR<L, R>, AA)> for Enum11<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> where Self: FromVariant<S0, (L, VA)> + ExchangeFrom<Enum1<S1>, (R, AA)>,` [src]

`fn exchange_from(src: Enum2<S0, S1>) -> Self`[src]

`impl<T0, T1> FromVariant<T0, (V0, VA)> for Enum2<T0, T1>`[src]

`fn from_variant(variant: T0) -> Self`[src]

`impl<T0, T1> FromVariant<T1, (V1, VA)> for Enum2<T0, T1>`[src]

`fn from_variant(variant: T1) -> Self`[src]

`impl<T0: Ord, T1: Ord> Ord for Enum2<T0, T1>`[src]

`fn cmp(&self, other: &Enum2<T0, T1>) -> Ordering`[src]

`#[must_use]fn max(self, other: Self) -> Self`1.21.0[src]

`#[must_use]fn min(self, other: Self) -> Self`1.21.0[src]

`#[must_use]fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<T0: PartialEq, T1: PartialEq> PartialEq<Enum2<T0, T1>> for Enum2<T0, T1>`[src]

`fn eq(&self, other: &Enum2<T0, T1>) -> bool`[src]

`fn ne(&self, other: &Enum2<T0, T1>) -> bool`[src]

`impl<T0: PartialOrd, T1: PartialOrd> PartialOrd<Enum2<T0, T1>> for Enum2<T0, T1>`[src]

`fn partial_cmp(&self, other: &Enum2<T0, T1>) -> Option<Ordering>`[src]

`fn lt(&self, other: &Enum2<T0, T1>) -> bool`[src]

`fn le(&self, other: &Enum2<T0, T1>) -> bool`[src]

`fn gt(&self, other: &Enum2<T0, T1>) -> bool`[src]

`fn ge(&self, other: &Enum2<T0, T1>) -> bool`[src]

`impl<T0, T1> StructuralEq for Enum2<T0, T1>`[src]

`impl<T0, T1> StructuralPartialEq for Enum2<T0, T1>`[src]

`impl<T0, T1> RefUnwindSafe for Enum2<T0, T1> where T0: RefUnwindSafe, T1: RefUnwindSafe,`

`impl<T0, T1> Send for Enum2<T0, T1> where T0: Send, T1: Send,`

`impl<T0, T1> Sync for Enum2<T0, T1> where T0: Sync, T1: Sync,`

`impl<T0, T1> Unpin for Enum2<T0, T1> where T0: Unpin, T1: Unpin,`

`impl<T0, T1> UnwindSafe for Enum2<T0, T1> where T0: UnwindSafe, T1: UnwindSafe,`

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`fn type_id(&self) -> TypeId`[src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

`fn borrow(&self) -> &T`[src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

`fn borrow_mut(&mut self) -> &mut T`[src]

`impl<Src, Dest, Index> EnumxFrom<Src, (Index, FV)> for Dest where Dest: FromVariant<Src, Index>,` [src]

`fn enumx_from(Src) -> Dest`[src]

`impl<Src, Dest, Indices> EnumxFrom<Src, (Indices, XF)> for Dest where Dest: ExchangeFrom<Src, Indices>,` [src]

`fn enumx_from(Src) -> Dest`[src]

`impl<Src, Dest, Proto, Indices> ExchangeFrom<Src, (Indices, NA)> for Dest where Dest: ExchangeFrom<Proto, (Indices, AA)>, Src: EnumX<Proto = Proto>,` [src]

`fn exchange_from(Src) -> Dest`[src]

`impl<Src, Dest, Indices> ExchangeInto<Dest, (Indices, AA)> for Src where Dest: ExchangeFrom<Src, (Indices, AA)>,` [src]

`fn exchange_into(Self) -> Dest`[src]

`impl<Src, Dest, Proto, Indices> ExchangeInto<Dest, (Indices, AN)> for Src where Dest: EnumX<Proto = Proto>, Src: ExchangeInto<Proto, (Indices, AA)>,` [src]

`fn exchange_into(Self) -> Dest`[src]

`impl<T> From<T> for T`[src]

`fn from(t: T) -> T`[src]