#[derive( Debug, PartialEq, Eq, PartialOrd, Ord )]
pub enum Enum2<T0,T1> { _0(T0), _1(T1) }
impl<T0,T1> ExchangeFrom<Enum0,(Nil,AA)> for Enum2<T0,T1> {
fn exchange_from( src: Enum0 ) -> Self { match src {} }
}
impl<Indices,S0,T0,T1> ExchangeFrom<Enum1<S0>,(Indices,AA)> for Enum2<T0,T1>
where Self : FromVariant<S0,(Indices,VA)>
{
fn exchange_from( src: Enum1<S0> ) -> Self {
match src {
Enum1::_0(v) => <Self as FromVariant<S0,(Indices,VA)>>::from_variant(v),
}
}
}
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)>
{
fn exchange_from( src: Enum2<S0,S1> ) -> Self {
match src {
Enum2::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum2::_1(v) => <Self as ExchangeFrom<Enum1<S1>,(R,AA)>>::exchange_from( Enum1::_0(v) ),
}
}
}
#[derive( Debug, PartialEq, Eq, PartialOrd, Ord )]
pub enum Enum3<T0,T1,T2> { _0(T0), _1(T1), _2(T2) }
impl<T0,T1,T2> ExchangeFrom<Enum0,(Nil,AA)> for Enum3<T0,T1,T2> {
fn exchange_from( src: Enum0 ) -> Self { match src {} }
}
impl<Indices,S0,T0,T1,T2> ExchangeFrom<Enum1<S0>,(Indices,AA)> for Enum3<T0,T1,T2>
where Self : FromVariant<S0,(Indices,VA)>
{
fn exchange_from( src: Enum1<S0> ) -> Self {
match src {
Enum1::_0(v) => <Self as FromVariant<S0,(Indices,VA)>>::from_variant(v),
}
}
}
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)>
{
fn exchange_from( src: Enum2<S0,S1> ) -> Self {
match src {
Enum2::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum2::_1(v) => <Self as ExchangeFrom<Enum1<S1>,(R,AA)>>::exchange_from( Enum1::_0(v) ),
}
}
}
impl<L,R,S0,S1,S2,T0,T1,T2> ExchangeFrom<Enum3<S0,S1,S2>,(LR<L,R>,AA)> for Enum3<T0,T1,T2>
where Self : FromVariant<S0,(L,VA)>
+ ExchangeFrom<Enum2<S1,S2>,(R,AA)>
{
fn exchange_from( src: Enum3<S0,S1,S2> ) -> Self {
match src {
Enum3::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum3::_1(v) => <Self as ExchangeFrom<Enum2<S1,S2>,(R,AA)>>::exchange_from( Enum2::_0(v) ),
Enum3::_2(v) => <Self as ExchangeFrom<Enum2<S1,S2>,(R,AA)>>::exchange_from( Enum2::_1(v) ),
}
}
}
#[derive( Debug, PartialEq, Eq, PartialOrd, Ord )]
pub enum Enum4<T0,T1,T2,T3> { _0(T0), _1(T1), _2(T2), _3(T3) }
impl<T0,T1,T2,T3> ExchangeFrom<Enum0,(Nil,AA)> for Enum4<T0,T1,T2,T3> {
fn exchange_from( src: Enum0 ) -> Self { match src {} }
}
impl<Indices,S0,T0,T1,T2,T3> ExchangeFrom<Enum1<S0>,(Indices,AA)> for Enum4<T0,T1,T2,T3>
where Self : FromVariant<S0,(Indices,VA)>
{
fn exchange_from( src: Enum1<S0> ) -> Self {
match src {
Enum1::_0(v) => <Self as FromVariant<S0,(Indices,VA)>>::from_variant(v),
}
}
}
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)>
{
fn exchange_from( src: Enum2<S0,S1> ) -> Self {
match src {
Enum2::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum2::_1(v) => <Self as ExchangeFrom<Enum1<S1>,(R,AA)>>::exchange_from( Enum1::_0(v) ),
}
}
}
impl<L,R,S0,S1,S2,T0,T1,T2,T3> ExchangeFrom<Enum3<S0,S1,S2>,(LR<L,R>,AA)> for Enum4<T0,T1,T2,T3>
where Self : FromVariant<S0,(L,VA)>
+ ExchangeFrom<Enum2<S1,S2>,(R,AA)>
{
fn exchange_from( src: Enum3<S0,S1,S2> ) -> Self {
match src {
Enum3::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum3::_1(v) => <Self as ExchangeFrom<Enum2<S1,S2>,(R,AA)>>::exchange_from( Enum2::_0(v) ),
Enum3::_2(v) => <Self as ExchangeFrom<Enum2<S1,S2>,(R,AA)>>::exchange_from( Enum2::_1(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,T0,T1,T2,T3> ExchangeFrom<Enum4<S0,S1,S2,S3>,(LR<L,R>,AA)> for Enum4<T0,T1,T2,T3>
where Self : FromVariant<S0,(L,VA)>
+ ExchangeFrom<Enum3<S1,S2,S3>,(R,AA)>
{
fn exchange_from( src: Enum4<S0,S1,S2,S3> ) -> Self {
match src {
Enum4::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum4::_1(v) => <Self as ExchangeFrom<Enum3<S1,S2,S3>,(R,AA)>>::exchange_from( Enum3::_0(v) ),
Enum4::_2(v) => <Self as ExchangeFrom<Enum3<S1,S2,S3>,(R,AA)>>::exchange_from( Enum3::_1(v) ),
Enum4::_3(v) => <Self as ExchangeFrom<Enum3<S1,S2,S3>,(R,AA)>>::exchange_from( Enum3::_2(v) ),
}
}
}
#[derive( Debug, PartialEq, Eq, PartialOrd, Ord )]
pub enum Enum5<T0,T1,T2,T3,T4> { _0(T0), _1(T1), _2(T2), _3(T3), _4(T4) }
impl<T0,T1,T2,T3,T4> ExchangeFrom<Enum0,(Nil,AA)> for Enum5<T0,T1,T2,T3,T4> {
fn exchange_from( src: Enum0 ) -> Self { match src {} }
}
impl<Indices,S0,T0,T1,T2,T3,T4> ExchangeFrom<Enum1<S0>,(Indices,AA)> for Enum5<T0,T1,T2,T3,T4>
where Self : FromVariant<S0,(Indices,VA)>
{
fn exchange_from( src: Enum1<S0> ) -> Self {
match src {
Enum1::_0(v) => <Self as FromVariant<S0,(Indices,VA)>>::from_variant(v),
}
}
}
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)>
{
fn exchange_from( src: Enum2<S0,S1> ) -> Self {
match src {
Enum2::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum2::_1(v) => <Self as ExchangeFrom<Enum1<S1>,(R,AA)>>::exchange_from( Enum1::_0(v) ),
}
}
}
impl<L,R,S0,S1,S2,T0,T1,T2,T3,T4> ExchangeFrom<Enum3<S0,S1,S2>,(LR<L,R>,AA)> for Enum5<T0,T1,T2,T3,T4>
where Self : FromVariant<S0,(L,VA)>
+ ExchangeFrom<Enum2<S1,S2>,(R,AA)>
{
fn exchange_from( src: Enum3<S0,S1,S2> ) -> Self {
match src {
Enum3::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum3::_1(v) => <Self as ExchangeFrom<Enum2<S1,S2>,(R,AA)>>::exchange_from( Enum2::_0(v) ),
Enum3::_2(v) => <Self as ExchangeFrom<Enum2<S1,S2>,(R,AA)>>::exchange_from( Enum2::_1(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,T0,T1,T2,T3,T4> ExchangeFrom<Enum4<S0,S1,S2,S3>,(LR<L,R>,AA)> for Enum5<T0,T1,T2,T3,T4>
where Self : FromVariant<S0,(L,VA)>
+ ExchangeFrom<Enum3<S1,S2,S3>,(R,AA)>
{
fn exchange_from( src: Enum4<S0,S1,S2,S3> ) -> Self {
match src {
Enum4::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum4::_1(v) => <Self as ExchangeFrom<Enum3<S1,S2,S3>,(R,AA)>>::exchange_from( Enum3::_0(v) ),
Enum4::_2(v) => <Self as ExchangeFrom<Enum3<S1,S2,S3>,(R,AA)>>::exchange_from( Enum3::_1(v) ),
Enum4::_3(v) => <Self as ExchangeFrom<Enum3<S1,S2,S3>,(R,AA)>>::exchange_from( Enum3::_2(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,T0,T1,T2,T3,T4> ExchangeFrom<Enum5<S0,S1,S2,S3,S4>,(LR<L,R>,AA)> for Enum5<T0,T1,T2,T3,T4>
where Self : FromVariant<S0,(L,VA)>
+ ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>
{
fn exchange_from( src: Enum5<S0,S1,S2,S3,S4> ) -> Self {
match src {
Enum5::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum5::_1(v) => <Self as ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>>::exchange_from( Enum4::_0(v) ),
Enum5::_2(v) => <Self as ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>>::exchange_from( Enum4::_1(v) ),
Enum5::_3(v) => <Self as ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>>::exchange_from( Enum4::_2(v) ),
Enum5::_4(v) => <Self as ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>>::exchange_from( Enum4::_3(v) ),
}
}
}
#[derive( Debug, PartialEq, Eq, PartialOrd, Ord )]
pub enum Enum6<T0,T1,T2,T3,T4,T5> { _0(T0), _1(T1), _2(T2), _3(T3), _4(T4), _5(T5) }
impl<T0,T1,T2,T3,T4,T5> ExchangeFrom<Enum0,(Nil,AA)> for Enum6<T0,T1,T2,T3,T4,T5> {
fn exchange_from( src: Enum0 ) -> Self { match src {} }
}
impl<Indices,S0,T0,T1,T2,T3,T4,T5> ExchangeFrom<Enum1<S0>,(Indices,AA)> for Enum6<T0,T1,T2,T3,T4,T5>
where Self : FromVariant<S0,(Indices,VA)>
{
fn exchange_from( src: Enum1<S0> ) -> Self {
match src {
Enum1::_0(v) => <Self as FromVariant<S0,(Indices,VA)>>::from_variant(v),
}
}
}
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)>
{
fn exchange_from( src: Enum2<S0,S1> ) -> Self {
match src {
Enum2::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum2::_1(v) => <Self as ExchangeFrom<Enum1<S1>,(R,AA)>>::exchange_from( Enum1::_0(v) ),
}
}
}
impl<L,R,S0,S1,S2,T0,T1,T2,T3,T4,T5> ExchangeFrom<Enum3<S0,S1,S2>,(LR<L,R>,AA)> for Enum6<T0,T1,T2,T3,T4,T5>
where Self : FromVariant<S0,(L,VA)>
+ ExchangeFrom<Enum2<S1,S2>,(R,AA)>
{
fn exchange_from( src: Enum3<S0,S1,S2> ) -> Self {
match src {
Enum3::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum3::_1(v) => <Self as ExchangeFrom<Enum2<S1,S2>,(R,AA)>>::exchange_from( Enum2::_0(v) ),
Enum3::_2(v) => <Self as ExchangeFrom<Enum2<S1,S2>,(R,AA)>>::exchange_from( Enum2::_1(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,T0,T1,T2,T3,T4,T5> ExchangeFrom<Enum4<S0,S1,S2,S3>,(LR<L,R>,AA)> for Enum6<T0,T1,T2,T3,T4,T5>
where Self : FromVariant<S0,(L,VA)>
+ ExchangeFrom<Enum3<S1,S2,S3>,(R,AA)>
{
fn exchange_from( src: Enum4<S0,S1,S2,S3> ) -> Self {
match src {
Enum4::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum4::_1(v) => <Self as ExchangeFrom<Enum3<S1,S2,S3>,(R,AA)>>::exchange_from( Enum3::_0(v) ),
Enum4::_2(v) => <Self as ExchangeFrom<Enum3<S1,S2,S3>,(R,AA)>>::exchange_from( Enum3::_1(v) ),
Enum4::_3(v) => <Self as ExchangeFrom<Enum3<S1,S2,S3>,(R,AA)>>::exchange_from( Enum3::_2(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,T0,T1,T2,T3,T4,T5> ExchangeFrom<Enum5<S0,S1,S2,S3,S4>,(LR<L,R>,AA)> for Enum6<T0,T1,T2,T3,T4,T5>
where Self : FromVariant<S0,(L,VA)>
+ ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>
{
fn exchange_from( src: Enum5<S0,S1,S2,S3,S4> ) -> Self {
match src {
Enum5::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum5::_1(v) => <Self as ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>>::exchange_from( Enum4::_0(v) ),
Enum5::_2(v) => <Self as ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>>::exchange_from( Enum4::_1(v) ),
Enum5::_3(v) => <Self as ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>>::exchange_from( Enum4::_2(v) ),
Enum5::_4(v) => <Self as ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>>::exchange_from( Enum4::_3(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,T0,T1,T2,T3,T4,T5> ExchangeFrom<Enum6<S0,S1,S2,S3,S4,S5>,(LR<L,R>,AA)> for Enum6<T0,T1,T2,T3,T4,T5>
where Self : FromVariant<S0,(L,VA)>
+ ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>
{
fn exchange_from( src: Enum6<S0,S1,S2,S3,S4,S5> ) -> Self {
match src {
Enum6::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum6::_1(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_0(v) ),
Enum6::_2(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_1(v) ),
Enum6::_3(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_2(v) ),
Enum6::_4(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_3(v) ),
Enum6::_5(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_4(v) ),
}
}
}
#[derive( Debug, PartialEq, Eq, PartialOrd, Ord )]
pub enum Enum7<T0,T1,T2,T3,T4,T5,T6> { _0(T0), _1(T1), _2(T2), _3(T3), _4(T4), _5(T5), _6(T6) }
impl<T0,T1,T2,T3,T4,T5,T6> ExchangeFrom<Enum0,(Nil,AA)> for Enum7<T0,T1,T2,T3,T4,T5,T6> {
fn exchange_from( src: Enum0 ) -> Self { match src {} }
}
impl<Indices,S0,T0,T1,T2,T3,T4,T5,T6> ExchangeFrom<Enum1<S0>,(Indices,AA)> for Enum7<T0,T1,T2,T3,T4,T5,T6>
where Self : FromVariant<S0,(Indices,VA)>
{
fn exchange_from( src: Enum1<S0> ) -> Self {
match src {
Enum1::_0(v) => <Self as FromVariant<S0,(Indices,VA)>>::from_variant(v),
}
}
}
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)>
{
fn exchange_from( src: Enum2<S0,S1> ) -> Self {
match src {
Enum2::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum2::_1(v) => <Self as ExchangeFrom<Enum1<S1>,(R,AA)>>::exchange_from( Enum1::_0(v) ),
}
}
}
impl<L,R,S0,S1,S2,T0,T1,T2,T3,T4,T5,T6> ExchangeFrom<Enum3<S0,S1,S2>,(LR<L,R>,AA)> for Enum7<T0,T1,T2,T3,T4,T5,T6>
where Self : FromVariant<S0,(L,VA)>
+ ExchangeFrom<Enum2<S1,S2>,(R,AA)>
{
fn exchange_from( src: Enum3<S0,S1,S2> ) -> Self {
match src {
Enum3::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum3::_1(v) => <Self as ExchangeFrom<Enum2<S1,S2>,(R,AA)>>::exchange_from( Enum2::_0(v) ),
Enum3::_2(v) => <Self as ExchangeFrom<Enum2<S1,S2>,(R,AA)>>::exchange_from( Enum2::_1(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,T0,T1,T2,T3,T4,T5,T6> ExchangeFrom<Enum4<S0,S1,S2,S3>,(LR<L,R>,AA)> for Enum7<T0,T1,T2,T3,T4,T5,T6>
where Self : FromVariant<S0,(L,VA)>
+ ExchangeFrom<Enum3<S1,S2,S3>,(R,AA)>
{
fn exchange_from( src: Enum4<S0,S1,S2,S3> ) -> Self {
match src {
Enum4::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum4::_1(v) => <Self as ExchangeFrom<Enum3<S1,S2,S3>,(R,AA)>>::exchange_from( Enum3::_0(v) ),
Enum4::_2(v) => <Self as ExchangeFrom<Enum3<S1,S2,S3>,(R,AA)>>::exchange_from( Enum3::_1(v) ),
Enum4::_3(v) => <Self as ExchangeFrom<Enum3<S1,S2,S3>,(R,AA)>>::exchange_from( Enum3::_2(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,T0,T1,T2,T3,T4,T5,T6> ExchangeFrom<Enum5<S0,S1,S2,S3,S4>,(LR<L,R>,AA)> for Enum7<T0,T1,T2,T3,T4,T5,T6>
where Self : FromVariant<S0,(L,VA)>
+ ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>
{
fn exchange_from( src: Enum5<S0,S1,S2,S3,S4> ) -> Self {
match src {
Enum5::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum5::_1(v) => <Self as ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>>::exchange_from( Enum4::_0(v) ),
Enum5::_2(v) => <Self as ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>>::exchange_from( Enum4::_1(v) ),
Enum5::_3(v) => <Self as ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>>::exchange_from( Enum4::_2(v) ),
Enum5::_4(v) => <Self as ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>>::exchange_from( Enum4::_3(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,T0,T1,T2,T3,T4,T5,T6> ExchangeFrom<Enum6<S0,S1,S2,S3,S4,S5>,(LR<L,R>,AA)> for Enum7<T0,T1,T2,T3,T4,T5,T6>
where Self : FromVariant<S0,(L,VA)>
+ ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>
{
fn exchange_from( src: Enum6<S0,S1,S2,S3,S4,S5> ) -> Self {
match src {
Enum6::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum6::_1(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_0(v) ),
Enum6::_2(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_1(v) ),
Enum6::_3(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_2(v) ),
Enum6::_4(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_3(v) ),
Enum6::_5(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_4(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,T0,T1,T2,T3,T4,T5,T6> ExchangeFrom<Enum7<S0,S1,S2,S3,S4,S5,S6>,(LR<L,R>,AA)> for Enum7<T0,T1,T2,T3,T4,T5,T6>
where Self : FromVariant<S0,(L,VA)>
+ ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>
{
fn exchange_from( src: Enum7<S0,S1,S2,S3,S4,S5,S6> ) -> Self {
match src {
Enum7::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum7::_1(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_0(v) ),
Enum7::_2(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_1(v) ),
Enum7::_3(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_2(v) ),
Enum7::_4(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_3(v) ),
Enum7::_5(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_4(v) ),
Enum7::_6(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_5(v) ),
}
}
}
#[derive( Debug, PartialEq, Eq, PartialOrd, Ord )]
pub enum Enum8<T0,T1,T2,T3,T4,T5,T6,T7> { _0(T0), _1(T1), _2(T2), _3(T3), _4(T4), _5(T5), _6(T6), _7(T7) }
impl<T0,T1,T2,T3,T4,T5,T6,T7> ExchangeFrom<Enum0,(Nil,AA)> for Enum8<T0,T1,T2,T3,T4,T5,T6,T7> {
fn exchange_from( src: Enum0 ) -> Self { match src {} }
}
impl<Indices,S0,T0,T1,T2,T3,T4,T5,T6,T7> ExchangeFrom<Enum1<S0>,(Indices,AA)> for Enum8<T0,T1,T2,T3,T4,T5,T6,T7>
where Self : FromVariant<S0,(Indices,VA)>
{
fn exchange_from( src: Enum1<S0> ) -> Self {
match src {
Enum1::_0(v) => <Self as FromVariant<S0,(Indices,VA)>>::from_variant(v),
}
}
}
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)>
{
fn exchange_from( src: Enum2<S0,S1> ) -> Self {
match src {
Enum2::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum2::_1(v) => <Self as ExchangeFrom<Enum1<S1>,(R,AA)>>::exchange_from( Enum1::_0(v) ),
}
}
}
impl<L,R,S0,S1,S2,T0,T1,T2,T3,T4,T5,T6,T7> ExchangeFrom<Enum3<S0,S1,S2>,(LR<L,R>,AA)> for Enum8<T0,T1,T2,T3,T4,T5,T6,T7>
where Self : FromVariant<S0,(L,VA)>
+ ExchangeFrom<Enum2<S1,S2>,(R,AA)>
{
fn exchange_from( src: Enum3<S0,S1,S2> ) -> Self {
match src {
Enum3::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum3::_1(v) => <Self as ExchangeFrom<Enum2<S1,S2>,(R,AA)>>::exchange_from( Enum2::_0(v) ),
Enum3::_2(v) => <Self as ExchangeFrom<Enum2<S1,S2>,(R,AA)>>::exchange_from( Enum2::_1(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,T0,T1,T2,T3,T4,T5,T6,T7> ExchangeFrom<Enum4<S0,S1,S2,S3>,(LR<L,R>,AA)> for Enum8<T0,T1,T2,T3,T4,T5,T6,T7>
where Self : FromVariant<S0,(L,VA)>
+ ExchangeFrom<Enum3<S1,S2,S3>,(R,AA)>
{
fn exchange_from( src: Enum4<S0,S1,S2,S3> ) -> Self {
match src {
Enum4::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum4::_1(v) => <Self as ExchangeFrom<Enum3<S1,S2,S3>,(R,AA)>>::exchange_from( Enum3::_0(v) ),
Enum4::_2(v) => <Self as ExchangeFrom<Enum3<S1,S2,S3>,(R,AA)>>::exchange_from( Enum3::_1(v) ),
Enum4::_3(v) => <Self as ExchangeFrom<Enum3<S1,S2,S3>,(R,AA)>>::exchange_from( Enum3::_2(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,T0,T1,T2,T3,T4,T5,T6,T7> ExchangeFrom<Enum5<S0,S1,S2,S3,S4>,(LR<L,R>,AA)> for Enum8<T0,T1,T2,T3,T4,T5,T6,T7>
where Self : FromVariant<S0,(L,VA)>
+ ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>
{
fn exchange_from( src: Enum5<S0,S1,S2,S3,S4> ) -> Self {
match src {
Enum5::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum5::_1(v) => <Self as ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>>::exchange_from( Enum4::_0(v) ),
Enum5::_2(v) => <Self as ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>>::exchange_from( Enum4::_1(v) ),
Enum5::_3(v) => <Self as ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>>::exchange_from( Enum4::_2(v) ),
Enum5::_4(v) => <Self as ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>>::exchange_from( Enum4::_3(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,T0,T1,T2,T3,T4,T5,T6,T7> ExchangeFrom<Enum6<S0,S1,S2,S3,S4,S5>,(LR<L,R>,AA)> for Enum8<T0,T1,T2,T3,T4,T5,T6,T7>
where Self : FromVariant<S0,(L,VA)>
+ ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>
{
fn exchange_from( src: Enum6<S0,S1,S2,S3,S4,S5> ) -> Self {
match src {
Enum6::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum6::_1(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_0(v) ),
Enum6::_2(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_1(v) ),
Enum6::_3(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_2(v) ),
Enum6::_4(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_3(v) ),
Enum6::_5(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_4(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,T0,T1,T2,T3,T4,T5,T6,T7> ExchangeFrom<Enum7<S0,S1,S2,S3,S4,S5,S6>,(LR<L,R>,AA)> for Enum8<T0,T1,T2,T3,T4,T5,T6,T7>
where Self : FromVariant<S0,(L,VA)>
+ ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>
{
fn exchange_from( src: Enum7<S0,S1,S2,S3,S4,S5,S6> ) -> Self {
match src {
Enum7::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum7::_1(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_0(v) ),
Enum7::_2(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_1(v) ),
Enum7::_3(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_2(v) ),
Enum7::_4(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_3(v) ),
Enum7::_5(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_4(v) ),
Enum7::_6(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_5(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,S7,T0,T1,T2,T3,T4,T5,T6,T7> ExchangeFrom<Enum8<S0,S1,S2,S3,S4,S5,S6,S7>,(LR<L,R>,AA)> for Enum8<T0,T1,T2,T3,T4,T5,T6,T7>
where Self : FromVariant<S0,(L,VA)>
+ ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>
{
fn exchange_from( src: Enum8<S0,S1,S2,S3,S4,S5,S6,S7> ) -> Self {
match src {
Enum8::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum8::_1(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_0(v) ),
Enum8::_2(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_1(v) ),
Enum8::_3(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_2(v) ),
Enum8::_4(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_3(v) ),
Enum8::_5(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_4(v) ),
Enum8::_6(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_5(v) ),
Enum8::_7(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_6(v) ),
}
}
}
#[derive( Debug, PartialEq, Eq, PartialOrd, Ord )]
pub enum Enum9<T0,T1,T2,T3,T4,T5,T6,T7,T8> { _0(T0), _1(T1), _2(T2), _3(T3), _4(T4), _5(T5), _6(T6), _7(T7), _8(T8) }
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8> ExchangeFrom<Enum0,(Nil,AA)> for Enum9<T0,T1,T2,T3,T4,T5,T6,T7,T8> {
fn exchange_from( src: Enum0 ) -> Self { match src {} }
}
impl<Indices,S0,T0,T1,T2,T3,T4,T5,T6,T7,T8> ExchangeFrom<Enum1<S0>,(Indices,AA)> for Enum9<T0,T1,T2,T3,T4,T5,T6,T7,T8>
where Self : FromVariant<S0,(Indices,VA)>
{
fn exchange_from( src: Enum1<S0> ) -> Self {
match src {
Enum1::_0(v) => <Self as FromVariant<S0,(Indices,VA)>>::from_variant(v),
}
}
}
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)>
{
fn exchange_from( src: Enum2<S0,S1> ) -> Self {
match src {
Enum2::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum2::_1(v) => <Self as ExchangeFrom<Enum1<S1>,(R,AA)>>::exchange_from( Enum1::_0(v) ),
}
}
}
impl<L,R,S0,S1,S2,T0,T1,T2,T3,T4,T5,T6,T7,T8> ExchangeFrom<Enum3<S0,S1,S2>,(LR<L,R>,AA)> for Enum9<T0,T1,T2,T3,T4,T5,T6,T7,T8>
where Self : FromVariant<S0,(L,VA)>
+ ExchangeFrom<Enum2<S1,S2>,(R,AA)>
{
fn exchange_from( src: Enum3<S0,S1,S2> ) -> Self {
match src {
Enum3::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum3::_1(v) => <Self as ExchangeFrom<Enum2<S1,S2>,(R,AA)>>::exchange_from( Enum2::_0(v) ),
Enum3::_2(v) => <Self as ExchangeFrom<Enum2<S1,S2>,(R,AA)>>::exchange_from( Enum2::_1(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,T0,T1,T2,T3,T4,T5,T6,T7,T8> ExchangeFrom<Enum4<S0,S1,S2,S3>,(LR<L,R>,AA)> for Enum9<T0,T1,T2,T3,T4,T5,T6,T7,T8>
where Self : FromVariant<S0,(L,VA)>
+ ExchangeFrom<Enum3<S1,S2,S3>,(R,AA)>
{
fn exchange_from( src: Enum4<S0,S1,S2,S3> ) -> Self {
match src {
Enum4::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum4::_1(v) => <Self as ExchangeFrom<Enum3<S1,S2,S3>,(R,AA)>>::exchange_from( Enum3::_0(v) ),
Enum4::_2(v) => <Self as ExchangeFrom<Enum3<S1,S2,S3>,(R,AA)>>::exchange_from( Enum3::_1(v) ),
Enum4::_3(v) => <Self as ExchangeFrom<Enum3<S1,S2,S3>,(R,AA)>>::exchange_from( Enum3::_2(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,T0,T1,T2,T3,T4,T5,T6,T7,T8> ExchangeFrom<Enum5<S0,S1,S2,S3,S4>,(LR<L,R>,AA)> for Enum9<T0,T1,T2,T3,T4,T5,T6,T7,T8>
where Self : FromVariant<S0,(L,VA)>
+ ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>
{
fn exchange_from( src: Enum5<S0,S1,S2,S3,S4> ) -> Self {
match src {
Enum5::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum5::_1(v) => <Self as ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>>::exchange_from( Enum4::_0(v) ),
Enum5::_2(v) => <Self as ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>>::exchange_from( Enum4::_1(v) ),
Enum5::_3(v) => <Self as ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>>::exchange_from( Enum4::_2(v) ),
Enum5::_4(v) => <Self as ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>>::exchange_from( Enum4::_3(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,T0,T1,T2,T3,T4,T5,T6,T7,T8> ExchangeFrom<Enum6<S0,S1,S2,S3,S4,S5>,(LR<L,R>,AA)> for Enum9<T0,T1,T2,T3,T4,T5,T6,T7,T8>
where Self : FromVariant<S0,(L,VA)>
+ ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>
{
fn exchange_from( src: Enum6<S0,S1,S2,S3,S4,S5> ) -> Self {
match src {
Enum6::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum6::_1(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_0(v) ),
Enum6::_2(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_1(v) ),
Enum6::_3(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_2(v) ),
Enum6::_4(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_3(v) ),
Enum6::_5(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_4(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,T0,T1,T2,T3,T4,T5,T6,T7,T8> ExchangeFrom<Enum7<S0,S1,S2,S3,S4,S5,S6>,(LR<L,R>,AA)> for Enum9<T0,T1,T2,T3,T4,T5,T6,T7,T8>
where Self : FromVariant<S0,(L,VA)>
+ ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>
{
fn exchange_from( src: Enum7<S0,S1,S2,S3,S4,S5,S6> ) -> Self {
match src {
Enum7::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum7::_1(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_0(v) ),
Enum7::_2(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_1(v) ),
Enum7::_3(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_2(v) ),
Enum7::_4(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_3(v) ),
Enum7::_5(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_4(v) ),
Enum7::_6(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_5(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,S7,T0,T1,T2,T3,T4,T5,T6,T7,T8> ExchangeFrom<Enum8<S0,S1,S2,S3,S4,S5,S6,S7>,(LR<L,R>,AA)> for Enum9<T0,T1,T2,T3,T4,T5,T6,T7,T8>
where Self : FromVariant<S0,(L,VA)>
+ ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>
{
fn exchange_from( src: Enum8<S0,S1,S2,S3,S4,S5,S6,S7> ) -> Self {
match src {
Enum8::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum8::_1(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_0(v) ),
Enum8::_2(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_1(v) ),
Enum8::_3(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_2(v) ),
Enum8::_4(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_3(v) ),
Enum8::_5(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_4(v) ),
Enum8::_6(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_5(v) ),
Enum8::_7(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_6(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,S7,S8,T0,T1,T2,T3,T4,T5,T6,T7,T8> ExchangeFrom<Enum9<S0,S1,S2,S3,S4,S5,S6,S7,S8>,(LR<L,R>,AA)> for Enum9<T0,T1,T2,T3,T4,T5,T6,T7,T8>
where Self : FromVariant<S0,(L,VA)>
+ ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>
{
fn exchange_from( src: Enum9<S0,S1,S2,S3,S4,S5,S6,S7,S8> ) -> Self {
match src {
Enum9::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum9::_1(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_0(v) ),
Enum9::_2(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_1(v) ),
Enum9::_3(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_2(v) ),
Enum9::_4(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_3(v) ),
Enum9::_5(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_4(v) ),
Enum9::_6(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_5(v) ),
Enum9::_7(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_6(v) ),
Enum9::_8(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_7(v) ),
}
}
}
#[derive( Debug, PartialEq, Eq, PartialOrd, Ord )]
pub enum Enum10<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9> { _0(T0), _1(T1), _2(T2), _3(T3), _4(T4), _5(T5), _6(T6), _7(T7), _8(T8), _9(T9) }
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9> ExchangeFrom<Enum0,(Nil,AA)> for Enum10<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9> {
fn exchange_from( src: Enum0 ) -> Self { match src {} }
}
impl<Indices,S0,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9> ExchangeFrom<Enum1<S0>,(Indices,AA)> for Enum10<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9>
where Self : FromVariant<S0,(Indices,VA)>
{
fn exchange_from( src: Enum1<S0> ) -> Self {
match src {
Enum1::_0(v) => <Self as FromVariant<S0,(Indices,VA)>>::from_variant(v),
}
}
}
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)>
{
fn exchange_from( src: Enum2<S0,S1> ) -> Self {
match src {
Enum2::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum2::_1(v) => <Self as ExchangeFrom<Enum1<S1>,(R,AA)>>::exchange_from( Enum1::_0(v) ),
}
}
}
impl<L,R,S0,S1,S2,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9> ExchangeFrom<Enum3<S0,S1,S2>,(LR<L,R>,AA)> for Enum10<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9>
where Self : FromVariant<S0,(L,VA)>
+ ExchangeFrom<Enum2<S1,S2>,(R,AA)>
{
fn exchange_from( src: Enum3<S0,S1,S2> ) -> Self {
match src {
Enum3::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum3::_1(v) => <Self as ExchangeFrom<Enum2<S1,S2>,(R,AA)>>::exchange_from( Enum2::_0(v) ),
Enum3::_2(v) => <Self as ExchangeFrom<Enum2<S1,S2>,(R,AA)>>::exchange_from( Enum2::_1(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9> ExchangeFrom<Enum4<S0,S1,S2,S3>,(LR<L,R>,AA)> for Enum10<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9>
where Self : FromVariant<S0,(L,VA)>
+ ExchangeFrom<Enum3<S1,S2,S3>,(R,AA)>
{
fn exchange_from( src: Enum4<S0,S1,S2,S3> ) -> Self {
match src {
Enum4::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum4::_1(v) => <Self as ExchangeFrom<Enum3<S1,S2,S3>,(R,AA)>>::exchange_from( Enum3::_0(v) ),
Enum4::_2(v) => <Self as ExchangeFrom<Enum3<S1,S2,S3>,(R,AA)>>::exchange_from( Enum3::_1(v) ),
Enum4::_3(v) => <Self as ExchangeFrom<Enum3<S1,S2,S3>,(R,AA)>>::exchange_from( Enum3::_2(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9> ExchangeFrom<Enum5<S0,S1,S2,S3,S4>,(LR<L,R>,AA)> for Enum10<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9>
where Self : FromVariant<S0,(L,VA)>
+ ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>
{
fn exchange_from( src: Enum5<S0,S1,S2,S3,S4> ) -> Self {
match src {
Enum5::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum5::_1(v) => <Self as ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>>::exchange_from( Enum4::_0(v) ),
Enum5::_2(v) => <Self as ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>>::exchange_from( Enum4::_1(v) ),
Enum5::_3(v) => <Self as ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>>::exchange_from( Enum4::_2(v) ),
Enum5::_4(v) => <Self as ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>>::exchange_from( Enum4::_3(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9> ExchangeFrom<Enum6<S0,S1,S2,S3,S4,S5>,(LR<L,R>,AA)> for Enum10<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9>
where Self : FromVariant<S0,(L,VA)>
+ ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>
{
fn exchange_from( src: Enum6<S0,S1,S2,S3,S4,S5> ) -> Self {
match src {
Enum6::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum6::_1(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_0(v) ),
Enum6::_2(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_1(v) ),
Enum6::_3(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_2(v) ),
Enum6::_4(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_3(v) ),
Enum6::_5(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_4(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9> ExchangeFrom<Enum7<S0,S1,S2,S3,S4,S5,S6>,(LR<L,R>,AA)> for Enum10<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9>
where Self : FromVariant<S0,(L,VA)>
+ ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>
{
fn exchange_from( src: Enum7<S0,S1,S2,S3,S4,S5,S6> ) -> Self {
match src {
Enum7::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum7::_1(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_0(v) ),
Enum7::_2(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_1(v) ),
Enum7::_3(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_2(v) ),
Enum7::_4(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_3(v) ),
Enum7::_5(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_4(v) ),
Enum7::_6(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_5(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,S7,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9> ExchangeFrom<Enum8<S0,S1,S2,S3,S4,S5,S6,S7>,(LR<L,R>,AA)> for Enum10<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9>
where Self : FromVariant<S0,(L,VA)>
+ ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>
{
fn exchange_from( src: Enum8<S0,S1,S2,S3,S4,S5,S6,S7> ) -> Self {
match src {
Enum8::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum8::_1(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_0(v) ),
Enum8::_2(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_1(v) ),
Enum8::_3(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_2(v) ),
Enum8::_4(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_3(v) ),
Enum8::_5(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_4(v) ),
Enum8::_6(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_5(v) ),
Enum8::_7(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_6(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,S7,S8,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9> ExchangeFrom<Enum9<S0,S1,S2,S3,S4,S5,S6,S7,S8>,(LR<L,R>,AA)> for Enum10<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9>
where Self : FromVariant<S0,(L,VA)>
+ ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>
{
fn exchange_from( src: Enum9<S0,S1,S2,S3,S4,S5,S6,S7,S8> ) -> Self {
match src {
Enum9::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum9::_1(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_0(v) ),
Enum9::_2(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_1(v) ),
Enum9::_3(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_2(v) ),
Enum9::_4(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_3(v) ),
Enum9::_5(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_4(v) ),
Enum9::_6(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_5(v) ),
Enum9::_7(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_6(v) ),
Enum9::_8(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_7(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9> ExchangeFrom<Enum10<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9>,(LR<L,R>,AA)> for Enum10<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9>
where Self : FromVariant<S0,(L,VA)>
+ ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>
{
fn exchange_from( src: Enum10<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9> ) -> Self {
match src {
Enum10::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum10::_1(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_0(v) ),
Enum10::_2(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_1(v) ),
Enum10::_3(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_2(v) ),
Enum10::_4(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_3(v) ),
Enum10::_5(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_4(v) ),
Enum10::_6(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_5(v) ),
Enum10::_7(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_6(v) ),
Enum10::_8(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_7(v) ),
Enum10::_9(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_8(v) ),
}
}
}
#[derive( Debug, PartialEq, Eq, PartialOrd, Ord )]
pub enum Enum11<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> { _0(T0), _1(T1), _2(T2), _3(T3), _4(T4), _5(T5), _6(T6), _7(T7), _8(T8), _9(T9), _10(T10) }
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> ExchangeFrom<Enum0,(Nil,AA)> for Enum11<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> {
fn exchange_from( src: Enum0 ) -> Self { match src {} }
}
impl<Indices,S0,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> ExchangeFrom<Enum1<S0>,(Indices,AA)> for Enum11<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>
where Self : FromVariant<S0,(Indices,VA)>
{
fn exchange_from( src: Enum1<S0> ) -> Self {
match src {
Enum1::_0(v) => <Self as FromVariant<S0,(Indices,VA)>>::from_variant(v),
}
}
}
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)>
{
fn exchange_from( src: Enum2<S0,S1> ) -> Self {
match src {
Enum2::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum2::_1(v) => <Self as ExchangeFrom<Enum1<S1>,(R,AA)>>::exchange_from( Enum1::_0(v) ),
}
}
}
impl<L,R,S0,S1,S2,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> ExchangeFrom<Enum3<S0,S1,S2>,(LR<L,R>,AA)> for Enum11<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>
where Self : FromVariant<S0,(L,VA)>
+ ExchangeFrom<Enum2<S1,S2>,(R,AA)>
{
fn exchange_from( src: Enum3<S0,S1,S2> ) -> Self {
match src {
Enum3::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum3::_1(v) => <Self as ExchangeFrom<Enum2<S1,S2>,(R,AA)>>::exchange_from( Enum2::_0(v) ),
Enum3::_2(v) => <Self as ExchangeFrom<Enum2<S1,S2>,(R,AA)>>::exchange_from( Enum2::_1(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> ExchangeFrom<Enum4<S0,S1,S2,S3>,(LR<L,R>,AA)> for Enum11<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>
where Self : FromVariant<S0,(L,VA)>
+ ExchangeFrom<Enum3<S1,S2,S3>,(R,AA)>
{
fn exchange_from( src: Enum4<S0,S1,S2,S3> ) -> Self {
match src {
Enum4::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum4::_1(v) => <Self as ExchangeFrom<Enum3<S1,S2,S3>,(R,AA)>>::exchange_from( Enum3::_0(v) ),
Enum4::_2(v) => <Self as ExchangeFrom<Enum3<S1,S2,S3>,(R,AA)>>::exchange_from( Enum3::_1(v) ),
Enum4::_3(v) => <Self as ExchangeFrom<Enum3<S1,S2,S3>,(R,AA)>>::exchange_from( Enum3::_2(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> ExchangeFrom<Enum5<S0,S1,S2,S3,S4>,(LR<L,R>,AA)> for Enum11<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>
where Self : FromVariant<S0,(L,VA)>
+ ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>
{
fn exchange_from( src: Enum5<S0,S1,S2,S3,S4> ) -> Self {
match src {
Enum5::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum5::_1(v) => <Self as ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>>::exchange_from( Enum4::_0(v) ),
Enum5::_2(v) => <Self as ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>>::exchange_from( Enum4::_1(v) ),
Enum5::_3(v) => <Self as ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>>::exchange_from( Enum4::_2(v) ),
Enum5::_4(v) => <Self as ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>>::exchange_from( Enum4::_3(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> ExchangeFrom<Enum6<S0,S1,S2,S3,S4,S5>,(LR<L,R>,AA)> for Enum11<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>
where Self : FromVariant<S0,(L,VA)>
+ ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>
{
fn exchange_from( src: Enum6<S0,S1,S2,S3,S4,S5> ) -> Self {
match src {
Enum6::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum6::_1(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_0(v) ),
Enum6::_2(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_1(v) ),
Enum6::_3(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_2(v) ),
Enum6::_4(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_3(v) ),
Enum6::_5(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_4(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> ExchangeFrom<Enum7<S0,S1,S2,S3,S4,S5,S6>,(LR<L,R>,AA)> for Enum11<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>
where Self : FromVariant<S0,(L,VA)>
+ ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>
{
fn exchange_from( src: Enum7<S0,S1,S2,S3,S4,S5,S6> ) -> Self {
match src {
Enum7::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum7::_1(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_0(v) ),
Enum7::_2(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_1(v) ),
Enum7::_3(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_2(v) ),
Enum7::_4(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_3(v) ),
Enum7::_5(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_4(v) ),
Enum7::_6(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_5(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,S7,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> ExchangeFrom<Enum8<S0,S1,S2,S3,S4,S5,S6,S7>,(LR<L,R>,AA)> for Enum11<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>
where Self : FromVariant<S0,(L,VA)>
+ ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>
{
fn exchange_from( src: Enum8<S0,S1,S2,S3,S4,S5,S6,S7> ) -> Self {
match src {
Enum8::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum8::_1(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_0(v) ),
Enum8::_2(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_1(v) ),
Enum8::_3(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_2(v) ),
Enum8::_4(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_3(v) ),
Enum8::_5(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_4(v) ),
Enum8::_6(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_5(v) ),
Enum8::_7(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_6(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,S7,S8,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> ExchangeFrom<Enum9<S0,S1,S2,S3,S4,S5,S6,S7,S8>,(LR<L,R>,AA)> for Enum11<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>
where Self : FromVariant<S0,(L,VA)>
+ ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>
{
fn exchange_from( src: Enum9<S0,S1,S2,S3,S4,S5,S6,S7,S8> ) -> Self {
match src {
Enum9::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum9::_1(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_0(v) ),
Enum9::_2(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_1(v) ),
Enum9::_3(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_2(v) ),
Enum9::_4(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_3(v) ),
Enum9::_5(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_4(v) ),
Enum9::_6(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_5(v) ),
Enum9::_7(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_6(v) ),
Enum9::_8(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_7(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> ExchangeFrom<Enum10<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9>,(LR<L,R>,AA)> for Enum11<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>
where Self : FromVariant<S0,(L,VA)>
+ ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>
{
fn exchange_from( src: Enum10<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9> ) -> Self {
match src {
Enum10::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum10::_1(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_0(v) ),
Enum10::_2(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_1(v) ),
Enum10::_3(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_2(v) ),
Enum10::_4(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_3(v) ),
Enum10::_5(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_4(v) ),
Enum10::_6(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_5(v) ),
Enum10::_7(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_6(v) ),
Enum10::_8(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_7(v) ),
Enum10::_9(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_8(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> ExchangeFrom<Enum11<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(LR<L,R>,AA)> for Enum11<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>
where Self : FromVariant<S0,(L,VA)>
+ ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>
{
fn exchange_from( src: Enum11<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10> ) -> Self {
match src {
Enum11::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum11::_1(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_0(v) ),
Enum11::_2(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_1(v) ),
Enum11::_3(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_2(v) ),
Enum11::_4(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_3(v) ),
Enum11::_5(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_4(v) ),
Enum11::_6(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_5(v) ),
Enum11::_7(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_6(v) ),
Enum11::_8(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_7(v) ),
Enum11::_9(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_8(v) ),
Enum11::_10(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_9(v) ),
}
}
}
#[derive( Debug, PartialEq, Eq, PartialOrd, Ord )]
pub enum Enum12<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> { _0(T0), _1(T1), _2(T2), _3(T3), _4(T4), _5(T5), _6(T6), _7(T7), _8(T8), _9(T9), _10(T10), _11(T11) }
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> ExchangeFrom<Enum0,(Nil,AA)> for Enum12<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> {
fn exchange_from( src: Enum0 ) -> Self { match src {} }
}
impl<Indices,S0,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> ExchangeFrom<Enum1<S0>,(Indices,AA)> for Enum12<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>
where Self : FromVariant<S0,(Indices,VA)>
{
fn exchange_from( src: Enum1<S0> ) -> Self {
match src {
Enum1::_0(v) => <Self as FromVariant<S0,(Indices,VA)>>::from_variant(v),
}
}
}
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)>
{
fn exchange_from( src: Enum2<S0,S1> ) -> Self {
match src {
Enum2::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum2::_1(v) => <Self as ExchangeFrom<Enum1<S1>,(R,AA)>>::exchange_from( Enum1::_0(v) ),
}
}
}
impl<L,R,S0,S1,S2,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> ExchangeFrom<Enum3<S0,S1,S2>,(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<Enum2<S1,S2>,(R,AA)>
{
fn exchange_from( src: Enum3<S0,S1,S2> ) -> Self {
match src {
Enum3::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum3::_1(v) => <Self as ExchangeFrom<Enum2<S1,S2>,(R,AA)>>::exchange_from( Enum2::_0(v) ),
Enum3::_2(v) => <Self as ExchangeFrom<Enum2<S1,S2>,(R,AA)>>::exchange_from( Enum2::_1(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> ExchangeFrom<Enum4<S0,S1,S2,S3>,(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<Enum3<S1,S2,S3>,(R,AA)>
{
fn exchange_from( src: Enum4<S0,S1,S2,S3> ) -> Self {
match src {
Enum4::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum4::_1(v) => <Self as ExchangeFrom<Enum3<S1,S2,S3>,(R,AA)>>::exchange_from( Enum3::_0(v) ),
Enum4::_2(v) => <Self as ExchangeFrom<Enum3<S1,S2,S3>,(R,AA)>>::exchange_from( Enum3::_1(v) ),
Enum4::_3(v) => <Self as ExchangeFrom<Enum3<S1,S2,S3>,(R,AA)>>::exchange_from( Enum3::_2(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> ExchangeFrom<Enum5<S0,S1,S2,S3,S4>,(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<Enum4<S1,S2,S3,S4>,(R,AA)>
{
fn exchange_from( src: Enum5<S0,S1,S2,S3,S4> ) -> Self {
match src {
Enum5::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum5::_1(v) => <Self as ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>>::exchange_from( Enum4::_0(v) ),
Enum5::_2(v) => <Self as ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>>::exchange_from( Enum4::_1(v) ),
Enum5::_3(v) => <Self as ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>>::exchange_from( Enum4::_2(v) ),
Enum5::_4(v) => <Self as ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>>::exchange_from( Enum4::_3(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> ExchangeFrom<Enum6<S0,S1,S2,S3,S4,S5>,(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<Enum5<S1,S2,S3,S4,S5>,(R,AA)>
{
fn exchange_from( src: Enum6<S0,S1,S2,S3,S4,S5> ) -> Self {
match src {
Enum6::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum6::_1(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_0(v) ),
Enum6::_2(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_1(v) ),
Enum6::_3(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_2(v) ),
Enum6::_4(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_3(v) ),
Enum6::_5(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_4(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> ExchangeFrom<Enum7<S0,S1,S2,S3,S4,S5,S6>,(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<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>
{
fn exchange_from( src: Enum7<S0,S1,S2,S3,S4,S5,S6> ) -> Self {
match src {
Enum7::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum7::_1(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_0(v) ),
Enum7::_2(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_1(v) ),
Enum7::_3(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_2(v) ),
Enum7::_4(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_3(v) ),
Enum7::_5(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_4(v) ),
Enum7::_6(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_5(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,S7,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> ExchangeFrom<Enum8<S0,S1,S2,S3,S4,S5,S6,S7>,(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<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>
{
fn exchange_from( src: Enum8<S0,S1,S2,S3,S4,S5,S6,S7> ) -> Self {
match src {
Enum8::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum8::_1(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_0(v) ),
Enum8::_2(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_1(v) ),
Enum8::_3(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_2(v) ),
Enum8::_4(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_3(v) ),
Enum8::_5(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_4(v) ),
Enum8::_6(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_5(v) ),
Enum8::_7(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_6(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,S7,S8,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> ExchangeFrom<Enum9<S0,S1,S2,S3,S4,S5,S6,S7,S8>,(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<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>
{
fn exchange_from( src: Enum9<S0,S1,S2,S3,S4,S5,S6,S7,S8> ) -> Self {
match src {
Enum9::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum9::_1(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_0(v) ),
Enum9::_2(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_1(v) ),
Enum9::_3(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_2(v) ),
Enum9::_4(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_3(v) ),
Enum9::_5(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_4(v) ),
Enum9::_6(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_5(v) ),
Enum9::_7(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_6(v) ),
Enum9::_8(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_7(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> ExchangeFrom<Enum10<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9>,(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<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>
{
fn exchange_from( src: Enum10<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9> ) -> Self {
match src {
Enum10::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum10::_1(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_0(v) ),
Enum10::_2(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_1(v) ),
Enum10::_3(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_2(v) ),
Enum10::_4(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_3(v) ),
Enum10::_5(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_4(v) ),
Enum10::_6(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_5(v) ),
Enum10::_7(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_6(v) ),
Enum10::_8(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_7(v) ),
Enum10::_9(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_8(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> ExchangeFrom<Enum11<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(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<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>
{
fn exchange_from( src: Enum11<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10> ) -> Self {
match src {
Enum11::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum11::_1(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_0(v) ),
Enum11::_2(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_1(v) ),
Enum11::_3(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_2(v) ),
Enum11::_4(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_3(v) ),
Enum11::_5(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_4(v) ),
Enum11::_6(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_5(v) ),
Enum11::_7(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_6(v) ),
Enum11::_8(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_7(v) ),
Enum11::_9(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_8(v) ),
Enum11::_10(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_9(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> ExchangeFrom<Enum12<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(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<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>
{
fn exchange_from( src: Enum12<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11> ) -> Self {
match src {
Enum12::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum12::_1(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_0(v) ),
Enum12::_2(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_1(v) ),
Enum12::_3(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_2(v) ),
Enum12::_4(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_3(v) ),
Enum12::_5(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_4(v) ),
Enum12::_6(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_5(v) ),
Enum12::_7(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_6(v) ),
Enum12::_8(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_7(v) ),
Enum12::_9(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_8(v) ),
Enum12::_10(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_9(v) ),
Enum12::_11(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_10(v) ),
}
}
}
#[derive( Debug, PartialEq, Eq, PartialOrd, Ord )]
pub enum Enum13<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> { _0(T0), _1(T1), _2(T2), _3(T3), _4(T4), _5(T5), _6(T6), _7(T7), _8(T8), _9(T9), _10(T10), _11(T11), _12(T12) }
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> ExchangeFrom<Enum0,(Nil,AA)> for Enum13<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> {
fn exchange_from( src: Enum0 ) -> Self { match src {} }
}
impl<Indices,S0,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> ExchangeFrom<Enum1<S0>,(Indices,AA)> for Enum13<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>
where Self : FromVariant<S0,(Indices,VA)>
{
fn exchange_from( src: Enum1<S0> ) -> Self {
match src {
Enum1::_0(v) => <Self as FromVariant<S0,(Indices,VA)>>::from_variant(v),
}
}
}
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)>
{
fn exchange_from( src: Enum2<S0,S1> ) -> Self {
match src {
Enum2::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum2::_1(v) => <Self as ExchangeFrom<Enum1<S1>,(R,AA)>>::exchange_from( Enum1::_0(v) ),
}
}
}
impl<L,R,S0,S1,S2,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> ExchangeFrom<Enum3<S0,S1,S2>,(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<Enum2<S1,S2>,(R,AA)>
{
fn exchange_from( src: Enum3<S0,S1,S2> ) -> Self {
match src {
Enum3::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum3::_1(v) => <Self as ExchangeFrom<Enum2<S1,S2>,(R,AA)>>::exchange_from( Enum2::_0(v) ),
Enum3::_2(v) => <Self as ExchangeFrom<Enum2<S1,S2>,(R,AA)>>::exchange_from( Enum2::_1(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> ExchangeFrom<Enum4<S0,S1,S2,S3>,(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<Enum3<S1,S2,S3>,(R,AA)>
{
fn exchange_from( src: Enum4<S0,S1,S2,S3> ) -> Self {
match src {
Enum4::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum4::_1(v) => <Self as ExchangeFrom<Enum3<S1,S2,S3>,(R,AA)>>::exchange_from( Enum3::_0(v) ),
Enum4::_2(v) => <Self as ExchangeFrom<Enum3<S1,S2,S3>,(R,AA)>>::exchange_from( Enum3::_1(v) ),
Enum4::_3(v) => <Self as ExchangeFrom<Enum3<S1,S2,S3>,(R,AA)>>::exchange_from( Enum3::_2(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> ExchangeFrom<Enum5<S0,S1,S2,S3,S4>,(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<Enum4<S1,S2,S3,S4>,(R,AA)>
{
fn exchange_from( src: Enum5<S0,S1,S2,S3,S4> ) -> Self {
match src {
Enum5::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum5::_1(v) => <Self as ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>>::exchange_from( Enum4::_0(v) ),
Enum5::_2(v) => <Self as ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>>::exchange_from( Enum4::_1(v) ),
Enum5::_3(v) => <Self as ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>>::exchange_from( Enum4::_2(v) ),
Enum5::_4(v) => <Self as ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>>::exchange_from( Enum4::_3(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> ExchangeFrom<Enum6<S0,S1,S2,S3,S4,S5>,(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<Enum5<S1,S2,S3,S4,S5>,(R,AA)>
{
fn exchange_from( src: Enum6<S0,S1,S2,S3,S4,S5> ) -> Self {
match src {
Enum6::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum6::_1(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_0(v) ),
Enum6::_2(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_1(v) ),
Enum6::_3(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_2(v) ),
Enum6::_4(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_3(v) ),
Enum6::_5(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_4(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> ExchangeFrom<Enum7<S0,S1,S2,S3,S4,S5,S6>,(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<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>
{
fn exchange_from( src: Enum7<S0,S1,S2,S3,S4,S5,S6> ) -> Self {
match src {
Enum7::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum7::_1(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_0(v) ),
Enum7::_2(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_1(v) ),
Enum7::_3(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_2(v) ),
Enum7::_4(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_3(v) ),
Enum7::_5(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_4(v) ),
Enum7::_6(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_5(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,S7,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> ExchangeFrom<Enum8<S0,S1,S2,S3,S4,S5,S6,S7>,(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<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>
{
fn exchange_from( src: Enum8<S0,S1,S2,S3,S4,S5,S6,S7> ) -> Self {
match src {
Enum8::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum8::_1(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_0(v) ),
Enum8::_2(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_1(v) ),
Enum8::_3(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_2(v) ),
Enum8::_4(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_3(v) ),
Enum8::_5(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_4(v) ),
Enum8::_6(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_5(v) ),
Enum8::_7(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_6(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,S7,S8,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> ExchangeFrom<Enum9<S0,S1,S2,S3,S4,S5,S6,S7,S8>,(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<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>
{
fn exchange_from( src: Enum9<S0,S1,S2,S3,S4,S5,S6,S7,S8> ) -> Self {
match src {
Enum9::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum9::_1(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_0(v) ),
Enum9::_2(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_1(v) ),
Enum9::_3(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_2(v) ),
Enum9::_4(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_3(v) ),
Enum9::_5(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_4(v) ),
Enum9::_6(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_5(v) ),
Enum9::_7(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_6(v) ),
Enum9::_8(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_7(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> ExchangeFrom<Enum10<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9>,(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<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>
{
fn exchange_from( src: Enum10<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9> ) -> Self {
match src {
Enum10::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum10::_1(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_0(v) ),
Enum10::_2(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_1(v) ),
Enum10::_3(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_2(v) ),
Enum10::_4(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_3(v) ),
Enum10::_5(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_4(v) ),
Enum10::_6(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_5(v) ),
Enum10::_7(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_6(v) ),
Enum10::_8(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_7(v) ),
Enum10::_9(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_8(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> ExchangeFrom<Enum11<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(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<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>
{
fn exchange_from( src: Enum11<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10> ) -> Self {
match src {
Enum11::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum11::_1(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_0(v) ),
Enum11::_2(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_1(v) ),
Enum11::_3(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_2(v) ),
Enum11::_4(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_3(v) ),
Enum11::_5(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_4(v) ),
Enum11::_6(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_5(v) ),
Enum11::_7(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_6(v) ),
Enum11::_8(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_7(v) ),
Enum11::_9(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_8(v) ),
Enum11::_10(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_9(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> ExchangeFrom<Enum12<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(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<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>
{
fn exchange_from( src: Enum12<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11> ) -> Self {
match src {
Enum12::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum12::_1(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_0(v) ),
Enum12::_2(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_1(v) ),
Enum12::_3(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_2(v) ),
Enum12::_4(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_3(v) ),
Enum12::_5(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_4(v) ),
Enum12::_6(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_5(v) ),
Enum12::_7(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_6(v) ),
Enum12::_8(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_7(v) ),
Enum12::_9(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_8(v) ),
Enum12::_10(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_9(v) ),
Enum12::_11(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_10(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> ExchangeFrom<Enum13<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(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<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>
{
fn exchange_from( src: Enum13<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12> ) -> Self {
match src {
Enum13::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum13::_1(v) => <Self as ExchangeFrom<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>>::exchange_from( Enum12::_0(v) ),
Enum13::_2(v) => <Self as ExchangeFrom<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>>::exchange_from( Enum12::_1(v) ),
Enum13::_3(v) => <Self as ExchangeFrom<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>>::exchange_from( Enum12::_2(v) ),
Enum13::_4(v) => <Self as ExchangeFrom<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>>::exchange_from( Enum12::_3(v) ),
Enum13::_5(v) => <Self as ExchangeFrom<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>>::exchange_from( Enum12::_4(v) ),
Enum13::_6(v) => <Self as ExchangeFrom<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>>::exchange_from( Enum12::_5(v) ),
Enum13::_7(v) => <Self as ExchangeFrom<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>>::exchange_from( Enum12::_6(v) ),
Enum13::_8(v) => <Self as ExchangeFrom<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>>::exchange_from( Enum12::_7(v) ),
Enum13::_9(v) => <Self as ExchangeFrom<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>>::exchange_from( Enum12::_8(v) ),
Enum13::_10(v) => <Self as ExchangeFrom<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>>::exchange_from( Enum12::_9(v) ),
Enum13::_11(v) => <Self as ExchangeFrom<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>>::exchange_from( Enum12::_10(v) ),
Enum13::_12(v) => <Self as ExchangeFrom<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>>::exchange_from( Enum12::_11(v) ),
}
}
}
#[derive( Debug, PartialEq, Eq, PartialOrd, Ord )]
pub enum Enum14<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> { _0(T0), _1(T1), _2(T2), _3(T3), _4(T4), _5(T5), _6(T6), _7(T7), _8(T8), _9(T9), _10(T10), _11(T11), _12(T12), _13(T13) }
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> ExchangeFrom<Enum0,(Nil,AA)> for Enum14<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> {
fn exchange_from( src: Enum0 ) -> Self { match src {} }
}
impl<Indices,S0,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> ExchangeFrom<Enum1<S0>,(Indices,AA)> for Enum14<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>
where Self : FromVariant<S0,(Indices,VA)>
{
fn exchange_from( src: Enum1<S0> ) -> Self {
match src {
Enum1::_0(v) => <Self as FromVariant<S0,(Indices,VA)>>::from_variant(v),
}
}
}
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)>
{
fn exchange_from( src: Enum2<S0,S1> ) -> Self {
match src {
Enum2::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum2::_1(v) => <Self as ExchangeFrom<Enum1<S1>,(R,AA)>>::exchange_from( Enum1::_0(v) ),
}
}
}
impl<L,R,S0,S1,S2,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> ExchangeFrom<Enum3<S0,S1,S2>,(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<Enum2<S1,S2>,(R,AA)>
{
fn exchange_from( src: Enum3<S0,S1,S2> ) -> Self {
match src {
Enum3::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum3::_1(v) => <Self as ExchangeFrom<Enum2<S1,S2>,(R,AA)>>::exchange_from( Enum2::_0(v) ),
Enum3::_2(v) => <Self as ExchangeFrom<Enum2<S1,S2>,(R,AA)>>::exchange_from( Enum2::_1(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> ExchangeFrom<Enum4<S0,S1,S2,S3>,(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<Enum3<S1,S2,S3>,(R,AA)>
{
fn exchange_from( src: Enum4<S0,S1,S2,S3> ) -> Self {
match src {
Enum4::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum4::_1(v) => <Self as ExchangeFrom<Enum3<S1,S2,S3>,(R,AA)>>::exchange_from( Enum3::_0(v) ),
Enum4::_2(v) => <Self as ExchangeFrom<Enum3<S1,S2,S3>,(R,AA)>>::exchange_from( Enum3::_1(v) ),
Enum4::_3(v) => <Self as ExchangeFrom<Enum3<S1,S2,S3>,(R,AA)>>::exchange_from( Enum3::_2(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> ExchangeFrom<Enum5<S0,S1,S2,S3,S4>,(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<Enum4<S1,S2,S3,S4>,(R,AA)>
{
fn exchange_from( src: Enum5<S0,S1,S2,S3,S4> ) -> Self {
match src {
Enum5::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum5::_1(v) => <Self as ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>>::exchange_from( Enum4::_0(v) ),
Enum5::_2(v) => <Self as ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>>::exchange_from( Enum4::_1(v) ),
Enum5::_3(v) => <Self as ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>>::exchange_from( Enum4::_2(v) ),
Enum5::_4(v) => <Self as ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>>::exchange_from( Enum4::_3(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> ExchangeFrom<Enum6<S0,S1,S2,S3,S4,S5>,(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<Enum5<S1,S2,S3,S4,S5>,(R,AA)>
{
fn exchange_from( src: Enum6<S0,S1,S2,S3,S4,S5> ) -> Self {
match src {
Enum6::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum6::_1(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_0(v) ),
Enum6::_2(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_1(v) ),
Enum6::_3(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_2(v) ),
Enum6::_4(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_3(v) ),
Enum6::_5(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_4(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> ExchangeFrom<Enum7<S0,S1,S2,S3,S4,S5,S6>,(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<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>
{
fn exchange_from( src: Enum7<S0,S1,S2,S3,S4,S5,S6> ) -> Self {
match src {
Enum7::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum7::_1(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_0(v) ),
Enum7::_2(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_1(v) ),
Enum7::_3(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_2(v) ),
Enum7::_4(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_3(v) ),
Enum7::_5(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_4(v) ),
Enum7::_6(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_5(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,S7,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> ExchangeFrom<Enum8<S0,S1,S2,S3,S4,S5,S6,S7>,(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<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>
{
fn exchange_from( src: Enum8<S0,S1,S2,S3,S4,S5,S6,S7> ) -> Self {
match src {
Enum8::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum8::_1(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_0(v) ),
Enum8::_2(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_1(v) ),
Enum8::_3(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_2(v) ),
Enum8::_4(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_3(v) ),
Enum8::_5(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_4(v) ),
Enum8::_6(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_5(v) ),
Enum8::_7(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_6(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,S7,S8,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> ExchangeFrom<Enum9<S0,S1,S2,S3,S4,S5,S6,S7,S8>,(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<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>
{
fn exchange_from( src: Enum9<S0,S1,S2,S3,S4,S5,S6,S7,S8> ) -> Self {
match src {
Enum9::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum9::_1(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_0(v) ),
Enum9::_2(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_1(v) ),
Enum9::_3(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_2(v) ),
Enum9::_4(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_3(v) ),
Enum9::_5(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_4(v) ),
Enum9::_6(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_5(v) ),
Enum9::_7(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_6(v) ),
Enum9::_8(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_7(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> ExchangeFrom<Enum10<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9>,(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<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>
{
fn exchange_from( src: Enum10<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9> ) -> Self {
match src {
Enum10::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum10::_1(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_0(v) ),
Enum10::_2(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_1(v) ),
Enum10::_3(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_2(v) ),
Enum10::_4(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_3(v) ),
Enum10::_5(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_4(v) ),
Enum10::_6(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_5(v) ),
Enum10::_7(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_6(v) ),
Enum10::_8(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_7(v) ),
Enum10::_9(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_8(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> ExchangeFrom<Enum11<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(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<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>
{
fn exchange_from( src: Enum11<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10> ) -> Self {
match src {
Enum11::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum11::_1(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_0(v) ),
Enum11::_2(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_1(v) ),
Enum11::_3(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_2(v) ),
Enum11::_4(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_3(v) ),
Enum11::_5(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_4(v) ),
Enum11::_6(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_5(v) ),
Enum11::_7(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_6(v) ),
Enum11::_8(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_7(v) ),
Enum11::_9(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_8(v) ),
Enum11::_10(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_9(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> ExchangeFrom<Enum12<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(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<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>
{
fn exchange_from( src: Enum12<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11> ) -> Self {
match src {
Enum12::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum12::_1(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_0(v) ),
Enum12::_2(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_1(v) ),
Enum12::_3(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_2(v) ),
Enum12::_4(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_3(v) ),
Enum12::_5(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_4(v) ),
Enum12::_6(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_5(v) ),
Enum12::_7(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_6(v) ),
Enum12::_8(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_7(v) ),
Enum12::_9(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_8(v) ),
Enum12::_10(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_9(v) ),
Enum12::_11(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_10(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> ExchangeFrom<Enum13<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(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<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>
{
fn exchange_from( src: Enum13<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12> ) -> Self {
match src {
Enum13::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum13::_1(v) => <Self as ExchangeFrom<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>>::exchange_from( Enum12::_0(v) ),
Enum13::_2(v) => <Self as ExchangeFrom<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>>::exchange_from( Enum12::_1(v) ),
Enum13::_3(v) => <Self as ExchangeFrom<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>>::exchange_from( Enum12::_2(v) ),
Enum13::_4(v) => <Self as ExchangeFrom<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>>::exchange_from( Enum12::_3(v) ),
Enum13::_5(v) => <Self as ExchangeFrom<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>>::exchange_from( Enum12::_4(v) ),
Enum13::_6(v) => <Self as ExchangeFrom<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>>::exchange_from( Enum12::_5(v) ),
Enum13::_7(v) => <Self as ExchangeFrom<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>>::exchange_from( Enum12::_6(v) ),
Enum13::_8(v) => <Self as ExchangeFrom<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>>::exchange_from( Enum12::_7(v) ),
Enum13::_9(v) => <Self as ExchangeFrom<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>>::exchange_from( Enum12::_8(v) ),
Enum13::_10(v) => <Self as ExchangeFrom<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>>::exchange_from( Enum12::_9(v) ),
Enum13::_11(v) => <Self as ExchangeFrom<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>>::exchange_from( Enum12::_10(v) ),
Enum13::_12(v) => <Self as ExchangeFrom<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>>::exchange_from( Enum12::_11(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> ExchangeFrom<Enum14<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13>,(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<Enum13<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13>,(R,AA)>
{
fn exchange_from( src: Enum14<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13> ) -> Self {
match src {
Enum14::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum14::_1(v) => <Self as ExchangeFrom<Enum13<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13>,(R,AA)>>::exchange_from( Enum13::_0(v) ),
Enum14::_2(v) => <Self as ExchangeFrom<Enum13<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13>,(R,AA)>>::exchange_from( Enum13::_1(v) ),
Enum14::_3(v) => <Self as ExchangeFrom<Enum13<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13>,(R,AA)>>::exchange_from( Enum13::_2(v) ),
Enum14::_4(v) => <Self as ExchangeFrom<Enum13<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13>,(R,AA)>>::exchange_from( Enum13::_3(v) ),
Enum14::_5(v) => <Self as ExchangeFrom<Enum13<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13>,(R,AA)>>::exchange_from( Enum13::_4(v) ),
Enum14::_6(v) => <Self as ExchangeFrom<Enum13<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13>,(R,AA)>>::exchange_from( Enum13::_5(v) ),
Enum14::_7(v) => <Self as ExchangeFrom<Enum13<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13>,(R,AA)>>::exchange_from( Enum13::_6(v) ),
Enum14::_8(v) => <Self as ExchangeFrom<Enum13<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13>,(R,AA)>>::exchange_from( Enum13::_7(v) ),
Enum14::_9(v) => <Self as ExchangeFrom<Enum13<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13>,(R,AA)>>::exchange_from( Enum13::_8(v) ),
Enum14::_10(v) => <Self as ExchangeFrom<Enum13<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13>,(R,AA)>>::exchange_from( Enum13::_9(v) ),
Enum14::_11(v) => <Self as ExchangeFrom<Enum13<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13>,(R,AA)>>::exchange_from( Enum13::_10(v) ),
Enum14::_12(v) => <Self as ExchangeFrom<Enum13<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13>,(R,AA)>>::exchange_from( Enum13::_11(v) ),
Enum14::_13(v) => <Self as ExchangeFrom<Enum13<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13>,(R,AA)>>::exchange_from( Enum13::_12(v) ),
}
}
}
#[derive( Debug, PartialEq, Eq, PartialOrd, Ord )]
pub enum Enum15<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> { _0(T0), _1(T1), _2(T2), _3(T3), _4(T4), _5(T5), _6(T6), _7(T7), _8(T8), _9(T9), _10(T10), _11(T11), _12(T12), _13(T13), _14(T14) }
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> ExchangeFrom<Enum0,(Nil,AA)> for Enum15<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> {
fn exchange_from( src: Enum0 ) -> Self { match src {} }
}
impl<Indices,S0,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> ExchangeFrom<Enum1<S0>,(Indices,AA)> for Enum15<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>
where Self : FromVariant<S0,(Indices,VA)>
{
fn exchange_from( src: Enum1<S0> ) -> Self {
match src {
Enum1::_0(v) => <Self as FromVariant<S0,(Indices,VA)>>::from_variant(v),
}
}
}
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)>
{
fn exchange_from( src: Enum2<S0,S1> ) -> Self {
match src {
Enum2::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum2::_1(v) => <Self as ExchangeFrom<Enum1<S1>,(R,AA)>>::exchange_from( Enum1::_0(v) ),
}
}
}
impl<L,R,S0,S1,S2,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> ExchangeFrom<Enum3<S0,S1,S2>,(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<Enum2<S1,S2>,(R,AA)>
{
fn exchange_from( src: Enum3<S0,S1,S2> ) -> Self {
match src {
Enum3::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum3::_1(v) => <Self as ExchangeFrom<Enum2<S1,S2>,(R,AA)>>::exchange_from( Enum2::_0(v) ),
Enum3::_2(v) => <Self as ExchangeFrom<Enum2<S1,S2>,(R,AA)>>::exchange_from( Enum2::_1(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> ExchangeFrom<Enum4<S0,S1,S2,S3>,(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<Enum3<S1,S2,S3>,(R,AA)>
{
fn exchange_from( src: Enum4<S0,S1,S2,S3> ) -> Self {
match src {
Enum4::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum4::_1(v) => <Self as ExchangeFrom<Enum3<S1,S2,S3>,(R,AA)>>::exchange_from( Enum3::_0(v) ),
Enum4::_2(v) => <Self as ExchangeFrom<Enum3<S1,S2,S3>,(R,AA)>>::exchange_from( Enum3::_1(v) ),
Enum4::_3(v) => <Self as ExchangeFrom<Enum3<S1,S2,S3>,(R,AA)>>::exchange_from( Enum3::_2(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> ExchangeFrom<Enum5<S0,S1,S2,S3,S4>,(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<Enum4<S1,S2,S3,S4>,(R,AA)>
{
fn exchange_from( src: Enum5<S0,S1,S2,S3,S4> ) -> Self {
match src {
Enum5::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum5::_1(v) => <Self as ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>>::exchange_from( Enum4::_0(v) ),
Enum5::_2(v) => <Self as ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>>::exchange_from( Enum4::_1(v) ),
Enum5::_3(v) => <Self as ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>>::exchange_from( Enum4::_2(v) ),
Enum5::_4(v) => <Self as ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>>::exchange_from( Enum4::_3(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> ExchangeFrom<Enum6<S0,S1,S2,S3,S4,S5>,(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<Enum5<S1,S2,S3,S4,S5>,(R,AA)>
{
fn exchange_from( src: Enum6<S0,S1,S2,S3,S4,S5> ) -> Self {
match src {
Enum6::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum6::_1(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_0(v) ),
Enum6::_2(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_1(v) ),
Enum6::_3(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_2(v) ),
Enum6::_4(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_3(v) ),
Enum6::_5(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_4(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> ExchangeFrom<Enum7<S0,S1,S2,S3,S4,S5,S6>,(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<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>
{
fn exchange_from( src: Enum7<S0,S1,S2,S3,S4,S5,S6> ) -> Self {
match src {
Enum7::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum7::_1(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_0(v) ),
Enum7::_2(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_1(v) ),
Enum7::_3(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_2(v) ),
Enum7::_4(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_3(v) ),
Enum7::_5(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_4(v) ),
Enum7::_6(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_5(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,S7,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> ExchangeFrom<Enum8<S0,S1,S2,S3,S4,S5,S6,S7>,(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<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>
{
fn exchange_from( src: Enum8<S0,S1,S2,S3,S4,S5,S6,S7> ) -> Self {
match src {
Enum8::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum8::_1(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_0(v) ),
Enum8::_2(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_1(v) ),
Enum8::_3(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_2(v) ),
Enum8::_4(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_3(v) ),
Enum8::_5(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_4(v) ),
Enum8::_6(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_5(v) ),
Enum8::_7(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_6(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,S7,S8,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> ExchangeFrom<Enum9<S0,S1,S2,S3,S4,S5,S6,S7,S8>,(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<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>
{
fn exchange_from( src: Enum9<S0,S1,S2,S3,S4,S5,S6,S7,S8> ) -> Self {
match src {
Enum9::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum9::_1(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_0(v) ),
Enum9::_2(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_1(v) ),
Enum9::_3(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_2(v) ),
Enum9::_4(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_3(v) ),
Enum9::_5(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_4(v) ),
Enum9::_6(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_5(v) ),
Enum9::_7(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_6(v) ),
Enum9::_8(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_7(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> ExchangeFrom<Enum10<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9>,(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<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>
{
fn exchange_from( src: Enum10<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9> ) -> Self {
match src {
Enum10::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum10::_1(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_0(v) ),
Enum10::_2(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_1(v) ),
Enum10::_3(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_2(v) ),
Enum10::_4(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_3(v) ),
Enum10::_5(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_4(v) ),
Enum10::_6(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_5(v) ),
Enum10::_7(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_6(v) ),
Enum10::_8(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_7(v) ),
Enum10::_9(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_8(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> ExchangeFrom<Enum11<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(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<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>
{
fn exchange_from( src: Enum11<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10> ) -> Self {
match src {
Enum11::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum11::_1(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_0(v) ),
Enum11::_2(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_1(v) ),
Enum11::_3(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_2(v) ),
Enum11::_4(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_3(v) ),
Enum11::_5(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_4(v) ),
Enum11::_6(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_5(v) ),
Enum11::_7(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_6(v) ),
Enum11::_8(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_7(v) ),
Enum11::_9(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_8(v) ),
Enum11::_10(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_9(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> ExchangeFrom<Enum12<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(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<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>
{
fn exchange_from( src: Enum12<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11> ) -> Self {
match src {
Enum12::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum12::_1(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_0(v) ),
Enum12::_2(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_1(v) ),
Enum12::_3(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_2(v) ),
Enum12::_4(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_3(v) ),
Enum12::_5(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_4(v) ),
Enum12::_6(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_5(v) ),
Enum12::_7(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_6(v) ),
Enum12::_8(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_7(v) ),
Enum12::_9(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_8(v) ),
Enum12::_10(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_9(v) ),
Enum12::_11(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_10(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> ExchangeFrom<Enum13<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(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<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>
{
fn exchange_from( src: Enum13<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12> ) -> Self {
match src {
Enum13::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum13::_1(v) => <Self as ExchangeFrom<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>>::exchange_from( Enum12::_0(v) ),
Enum13::_2(v) => <Self as ExchangeFrom<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>>::exchange_from( Enum12::_1(v) ),
Enum13::_3(v) => <Self as ExchangeFrom<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>>::exchange_from( Enum12::_2(v) ),
Enum13::_4(v) => <Self as ExchangeFrom<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>>::exchange_from( Enum12::_3(v) ),
Enum13::_5(v) => <Self as ExchangeFrom<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>>::exchange_from( Enum12::_4(v) ),
Enum13::_6(v) => <Self as ExchangeFrom<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>>::exchange_from( Enum12::_5(v) ),
Enum13::_7(v) => <Self as ExchangeFrom<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>>::exchange_from( Enum12::_6(v) ),
Enum13::_8(v) => <Self as ExchangeFrom<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>>::exchange_from( Enum12::_7(v) ),
Enum13::_9(v) => <Self as ExchangeFrom<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>>::exchange_from( Enum12::_8(v) ),
Enum13::_10(v) => <Self as ExchangeFrom<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>>::exchange_from( Enum12::_9(v) ),
Enum13::_11(v) => <Self as ExchangeFrom<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>>::exchange_from( Enum12::_10(v) ),
Enum13::_12(v) => <Self as ExchangeFrom<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>>::exchange_from( Enum12::_11(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> ExchangeFrom<Enum14<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13>,(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<Enum13<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13>,(R,AA)>
{
fn exchange_from( src: Enum14<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13> ) -> Self {
match src {
Enum14::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum14::_1(v) => <Self as ExchangeFrom<Enum13<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13>,(R,AA)>>::exchange_from( Enum13::_0(v) ),
Enum14::_2(v) => <Self as ExchangeFrom<Enum13<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13>,(R,AA)>>::exchange_from( Enum13::_1(v) ),
Enum14::_3(v) => <Self as ExchangeFrom<Enum13<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13>,(R,AA)>>::exchange_from( Enum13::_2(v) ),
Enum14::_4(v) => <Self as ExchangeFrom<Enum13<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13>,(R,AA)>>::exchange_from( Enum13::_3(v) ),
Enum14::_5(v) => <Self as ExchangeFrom<Enum13<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13>,(R,AA)>>::exchange_from( Enum13::_4(v) ),
Enum14::_6(v) => <Self as ExchangeFrom<Enum13<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13>,(R,AA)>>::exchange_from( Enum13::_5(v) ),
Enum14::_7(v) => <Self as ExchangeFrom<Enum13<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13>,(R,AA)>>::exchange_from( Enum13::_6(v) ),
Enum14::_8(v) => <Self as ExchangeFrom<Enum13<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13>,(R,AA)>>::exchange_from( Enum13::_7(v) ),
Enum14::_9(v) => <Self as ExchangeFrom<Enum13<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13>,(R,AA)>>::exchange_from( Enum13::_8(v) ),
Enum14::_10(v) => <Self as ExchangeFrom<Enum13<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13>,(R,AA)>>::exchange_from( Enum13::_9(v) ),
Enum14::_11(v) => <Self as ExchangeFrom<Enum13<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13>,(R,AA)>>::exchange_from( Enum13::_10(v) ),
Enum14::_12(v) => <Self as ExchangeFrom<Enum13<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13>,(R,AA)>>::exchange_from( Enum13::_11(v) ),
Enum14::_13(v) => <Self as ExchangeFrom<Enum13<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13>,(R,AA)>>::exchange_from( Enum13::_12(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> ExchangeFrom<Enum15<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14>,(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<Enum14<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14>,(R,AA)>
{
fn exchange_from( src: Enum15<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14> ) -> Self {
match src {
Enum15::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum15::_1(v) => <Self as ExchangeFrom<Enum14<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14>,(R,AA)>>::exchange_from( Enum14::_0(v) ),
Enum15::_2(v) => <Self as ExchangeFrom<Enum14<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14>,(R,AA)>>::exchange_from( Enum14::_1(v) ),
Enum15::_3(v) => <Self as ExchangeFrom<Enum14<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14>,(R,AA)>>::exchange_from( Enum14::_2(v) ),
Enum15::_4(v) => <Self as ExchangeFrom<Enum14<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14>,(R,AA)>>::exchange_from( Enum14::_3(v) ),
Enum15::_5(v) => <Self as ExchangeFrom<Enum14<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14>,(R,AA)>>::exchange_from( Enum14::_4(v) ),
Enum15::_6(v) => <Self as ExchangeFrom<Enum14<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14>,(R,AA)>>::exchange_from( Enum14::_5(v) ),
Enum15::_7(v) => <Self as ExchangeFrom<Enum14<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14>,(R,AA)>>::exchange_from( Enum14::_6(v) ),
Enum15::_8(v) => <Self as ExchangeFrom<Enum14<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14>,(R,AA)>>::exchange_from( Enum14::_7(v) ),
Enum15::_9(v) => <Self as ExchangeFrom<Enum14<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14>,(R,AA)>>::exchange_from( Enum14::_8(v) ),
Enum15::_10(v) => <Self as ExchangeFrom<Enum14<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14>,(R,AA)>>::exchange_from( Enum14::_9(v) ),
Enum15::_11(v) => <Self as ExchangeFrom<Enum14<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14>,(R,AA)>>::exchange_from( Enum14::_10(v) ),
Enum15::_12(v) => <Self as ExchangeFrom<Enum14<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14>,(R,AA)>>::exchange_from( Enum14::_11(v) ),
Enum15::_13(v) => <Self as ExchangeFrom<Enum14<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14>,(R,AA)>>::exchange_from( Enum14::_12(v) ),
Enum15::_14(v) => <Self as ExchangeFrom<Enum14<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14>,(R,AA)>>::exchange_from( Enum14::_13(v) ),
}
}
}
#[derive( Debug, PartialEq, Eq, PartialOrd, Ord )]
pub enum Enum16<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> { _0(T0), _1(T1), _2(T2), _3(T3), _4(T4), _5(T5), _6(T6), _7(T7), _8(T8), _9(T9), _10(T10), _11(T11), _12(T12), _13(T13), _14(T14), _15(T15) }
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> ExchangeFrom<Enum0,(Nil,AA)> for Enum16<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> {
fn exchange_from( src: Enum0 ) -> Self { match src {} }
}
impl<Indices,S0,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> ExchangeFrom<Enum1<S0>,(Indices,AA)> for Enum16<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>
where Self : FromVariant<S0,(Indices,VA)>
{
fn exchange_from( src: Enum1<S0> ) -> Self {
match src {
Enum1::_0(v) => <Self as FromVariant<S0,(Indices,VA)>>::from_variant(v),
}
}
}
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)>
{
fn exchange_from( src: Enum2<S0,S1> ) -> Self {
match src {
Enum2::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum2::_1(v) => <Self as ExchangeFrom<Enum1<S1>,(R,AA)>>::exchange_from( Enum1::_0(v) ),
}
}
}
impl<L,R,S0,S1,S2,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> ExchangeFrom<Enum3<S0,S1,S2>,(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<Enum2<S1,S2>,(R,AA)>
{
fn exchange_from( src: Enum3<S0,S1,S2> ) -> Self {
match src {
Enum3::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum3::_1(v) => <Self as ExchangeFrom<Enum2<S1,S2>,(R,AA)>>::exchange_from( Enum2::_0(v) ),
Enum3::_2(v) => <Self as ExchangeFrom<Enum2<S1,S2>,(R,AA)>>::exchange_from( Enum2::_1(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> ExchangeFrom<Enum4<S0,S1,S2,S3>,(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<Enum3<S1,S2,S3>,(R,AA)>
{
fn exchange_from( src: Enum4<S0,S1,S2,S3> ) -> Self {
match src {
Enum4::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum4::_1(v) => <Self as ExchangeFrom<Enum3<S1,S2,S3>,(R,AA)>>::exchange_from( Enum3::_0(v) ),
Enum4::_2(v) => <Self as ExchangeFrom<Enum3<S1,S2,S3>,(R,AA)>>::exchange_from( Enum3::_1(v) ),
Enum4::_3(v) => <Self as ExchangeFrom<Enum3<S1,S2,S3>,(R,AA)>>::exchange_from( Enum3::_2(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> ExchangeFrom<Enum5<S0,S1,S2,S3,S4>,(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<Enum4<S1,S2,S3,S4>,(R,AA)>
{
fn exchange_from( src: Enum5<S0,S1,S2,S3,S4> ) -> Self {
match src {
Enum5::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum5::_1(v) => <Self as ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>>::exchange_from( Enum4::_0(v) ),
Enum5::_2(v) => <Self as ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>>::exchange_from( Enum4::_1(v) ),
Enum5::_3(v) => <Self as ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>>::exchange_from( Enum4::_2(v) ),
Enum5::_4(v) => <Self as ExchangeFrom<Enum4<S1,S2,S3,S4>,(R,AA)>>::exchange_from( Enum4::_3(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> ExchangeFrom<Enum6<S0,S1,S2,S3,S4,S5>,(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<Enum5<S1,S2,S3,S4,S5>,(R,AA)>
{
fn exchange_from( src: Enum6<S0,S1,S2,S3,S4,S5> ) -> Self {
match src {
Enum6::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum6::_1(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_0(v) ),
Enum6::_2(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_1(v) ),
Enum6::_3(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_2(v) ),
Enum6::_4(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_3(v) ),
Enum6::_5(v) => <Self as ExchangeFrom<Enum5<S1,S2,S3,S4,S5>,(R,AA)>>::exchange_from( Enum5::_4(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> ExchangeFrom<Enum7<S0,S1,S2,S3,S4,S5,S6>,(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<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>
{
fn exchange_from( src: Enum7<S0,S1,S2,S3,S4,S5,S6> ) -> Self {
match src {
Enum7::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum7::_1(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_0(v) ),
Enum7::_2(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_1(v) ),
Enum7::_3(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_2(v) ),
Enum7::_4(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_3(v) ),
Enum7::_5(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_4(v) ),
Enum7::_6(v) => <Self as ExchangeFrom<Enum6<S1,S2,S3,S4,S5,S6>,(R,AA)>>::exchange_from( Enum6::_5(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,S7,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> ExchangeFrom<Enum8<S0,S1,S2,S3,S4,S5,S6,S7>,(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<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>
{
fn exchange_from( src: Enum8<S0,S1,S2,S3,S4,S5,S6,S7> ) -> Self {
match src {
Enum8::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum8::_1(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_0(v) ),
Enum8::_2(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_1(v) ),
Enum8::_3(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_2(v) ),
Enum8::_4(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_3(v) ),
Enum8::_5(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_4(v) ),
Enum8::_6(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_5(v) ),
Enum8::_7(v) => <Self as ExchangeFrom<Enum7<S1,S2,S3,S4,S5,S6,S7>,(R,AA)>>::exchange_from( Enum7::_6(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,S7,S8,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> ExchangeFrom<Enum9<S0,S1,S2,S3,S4,S5,S6,S7,S8>,(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<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>
{
fn exchange_from( src: Enum9<S0,S1,S2,S3,S4,S5,S6,S7,S8> ) -> Self {
match src {
Enum9::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum9::_1(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_0(v) ),
Enum9::_2(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_1(v) ),
Enum9::_3(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_2(v) ),
Enum9::_4(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_3(v) ),
Enum9::_5(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_4(v) ),
Enum9::_6(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_5(v) ),
Enum9::_7(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_6(v) ),
Enum9::_8(v) => <Self as ExchangeFrom<Enum8<S1,S2,S3,S4,S5,S6,S7,S8>,(R,AA)>>::exchange_from( Enum8::_7(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> ExchangeFrom<Enum10<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9>,(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<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>
{
fn exchange_from( src: Enum10<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9> ) -> Self {
match src {
Enum10::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum10::_1(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_0(v) ),
Enum10::_2(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_1(v) ),
Enum10::_3(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_2(v) ),
Enum10::_4(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_3(v) ),
Enum10::_5(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_4(v) ),
Enum10::_6(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_5(v) ),
Enum10::_7(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_6(v) ),
Enum10::_8(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_7(v) ),
Enum10::_9(v) => <Self as ExchangeFrom<Enum9<S1,S2,S3,S4,S5,S6,S7,S8,S9>,(R,AA)>>::exchange_from( Enum9::_8(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> ExchangeFrom<Enum11<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(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<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>
{
fn exchange_from( src: Enum11<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10> ) -> Self {
match src {
Enum11::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum11::_1(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_0(v) ),
Enum11::_2(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_1(v) ),
Enum11::_3(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_2(v) ),
Enum11::_4(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_3(v) ),
Enum11::_5(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_4(v) ),
Enum11::_6(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_5(v) ),
Enum11::_7(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_6(v) ),
Enum11::_8(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_7(v) ),
Enum11::_9(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_8(v) ),
Enum11::_10(v) => <Self as ExchangeFrom<Enum10<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>,(R,AA)>>::exchange_from( Enum10::_9(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> ExchangeFrom<Enum12<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(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<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>
{
fn exchange_from( src: Enum12<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11> ) -> Self {
match src {
Enum12::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum12::_1(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_0(v) ),
Enum12::_2(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_1(v) ),
Enum12::_3(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_2(v) ),
Enum12::_4(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_3(v) ),
Enum12::_5(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_4(v) ),
Enum12::_6(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_5(v) ),
Enum12::_7(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_6(v) ),
Enum12::_8(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_7(v) ),
Enum12::_9(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_8(v) ),
Enum12::_10(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_9(v) ),
Enum12::_11(v) => <Self as ExchangeFrom<Enum11<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11>,(R,AA)>>::exchange_from( Enum11::_10(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> ExchangeFrom<Enum13<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(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<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>
{
fn exchange_from( src: Enum13<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12> ) -> Self {
match src {
Enum13::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum13::_1(v) => <Self as ExchangeFrom<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>>::exchange_from( Enum12::_0(v) ),
Enum13::_2(v) => <Self as ExchangeFrom<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>>::exchange_from( Enum12::_1(v) ),
Enum13::_3(v) => <Self as ExchangeFrom<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>>::exchange_from( Enum12::_2(v) ),
Enum13::_4(v) => <Self as ExchangeFrom<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>>::exchange_from( Enum12::_3(v) ),
Enum13::_5(v) => <Self as ExchangeFrom<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>>::exchange_from( Enum12::_4(v) ),
Enum13::_6(v) => <Self as ExchangeFrom<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>>::exchange_from( Enum12::_5(v) ),
Enum13::_7(v) => <Self as ExchangeFrom<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>>::exchange_from( Enum12::_6(v) ),
Enum13::_8(v) => <Self as ExchangeFrom<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>>::exchange_from( Enum12::_7(v) ),
Enum13::_9(v) => <Self as ExchangeFrom<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>>::exchange_from( Enum12::_8(v) ),
Enum13::_10(v) => <Self as ExchangeFrom<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>>::exchange_from( Enum12::_9(v) ),
Enum13::_11(v) => <Self as ExchangeFrom<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>>::exchange_from( Enum12::_10(v) ),
Enum13::_12(v) => <Self as ExchangeFrom<Enum12<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12>,(R,AA)>>::exchange_from( Enum12::_11(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> ExchangeFrom<Enum14<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13>,(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<Enum13<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13>,(R,AA)>
{
fn exchange_from( src: Enum14<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13> ) -> Self {
match src {
Enum14::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum14::_1(v) => <Self as ExchangeFrom<Enum13<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13>,(R,AA)>>::exchange_from( Enum13::_0(v) ),
Enum14::_2(v) => <Self as ExchangeFrom<Enum13<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13>,(R,AA)>>::exchange_from( Enum13::_1(v) ),
Enum14::_3(v) => <Self as ExchangeFrom<Enum13<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13>,(R,AA)>>::exchange_from( Enum13::_2(v) ),
Enum14::_4(v) => <Self as ExchangeFrom<Enum13<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13>,(R,AA)>>::exchange_from( Enum13::_3(v) ),
Enum14::_5(v) => <Self as ExchangeFrom<Enum13<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13>,(R,AA)>>::exchange_from( Enum13::_4(v) ),
Enum14::_6(v) => <Self as ExchangeFrom<Enum13<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13>,(R,AA)>>::exchange_from( Enum13::_5(v) ),
Enum14::_7(v) => <Self as ExchangeFrom<Enum13<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13>,(R,AA)>>::exchange_from( Enum13::_6(v) ),
Enum14::_8(v) => <Self as ExchangeFrom<Enum13<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13>,(R,AA)>>::exchange_from( Enum13::_7(v) ),
Enum14::_9(v) => <Self as ExchangeFrom<Enum13<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13>,(R,AA)>>::exchange_from( Enum13::_8(v) ),
Enum14::_10(v) => <Self as ExchangeFrom<Enum13<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13>,(R,AA)>>::exchange_from( Enum13::_9(v) ),
Enum14::_11(v) => <Self as ExchangeFrom<Enum13<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13>,(R,AA)>>::exchange_from( Enum13::_10(v) ),
Enum14::_12(v) => <Self as ExchangeFrom<Enum13<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13>,(R,AA)>>::exchange_from( Enum13::_11(v) ),
Enum14::_13(v) => <Self as ExchangeFrom<Enum13<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13>,(R,AA)>>::exchange_from( Enum13::_12(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> ExchangeFrom<Enum15<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14>,(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<Enum14<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14>,(R,AA)>
{
fn exchange_from( src: Enum15<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14> ) -> Self {
match src {
Enum15::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum15::_1(v) => <Self as ExchangeFrom<Enum14<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14>,(R,AA)>>::exchange_from( Enum14::_0(v) ),
Enum15::_2(v) => <Self as ExchangeFrom<Enum14<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14>,(R,AA)>>::exchange_from( Enum14::_1(v) ),
Enum15::_3(v) => <Self as ExchangeFrom<Enum14<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14>,(R,AA)>>::exchange_from( Enum14::_2(v) ),
Enum15::_4(v) => <Self as ExchangeFrom<Enum14<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14>,(R,AA)>>::exchange_from( Enum14::_3(v) ),
Enum15::_5(v) => <Self as ExchangeFrom<Enum14<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14>,(R,AA)>>::exchange_from( Enum14::_4(v) ),
Enum15::_6(v) => <Self as ExchangeFrom<Enum14<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14>,(R,AA)>>::exchange_from( Enum14::_5(v) ),
Enum15::_7(v) => <Self as ExchangeFrom<Enum14<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14>,(R,AA)>>::exchange_from( Enum14::_6(v) ),
Enum15::_8(v) => <Self as ExchangeFrom<Enum14<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14>,(R,AA)>>::exchange_from( Enum14::_7(v) ),
Enum15::_9(v) => <Self as ExchangeFrom<Enum14<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14>,(R,AA)>>::exchange_from( Enum14::_8(v) ),
Enum15::_10(v) => <Self as ExchangeFrom<Enum14<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14>,(R,AA)>>::exchange_from( Enum14::_9(v) ),
Enum15::_11(v) => <Self as ExchangeFrom<Enum14<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14>,(R,AA)>>::exchange_from( Enum14::_10(v) ),
Enum15::_12(v) => <Self as ExchangeFrom<Enum14<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14>,(R,AA)>>::exchange_from( Enum14::_11(v) ),
Enum15::_13(v) => <Self as ExchangeFrom<Enum14<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14>,(R,AA)>>::exchange_from( Enum14::_12(v) ),
Enum15::_14(v) => <Self as ExchangeFrom<Enum14<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14>,(R,AA)>>::exchange_from( Enum14::_13(v) ),
}
}
}
impl<L,R,S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14,S15,T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> ExchangeFrom<Enum16<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14,S15>,(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<Enum15<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14,S15>,(R,AA)>
{
fn exchange_from( src: Enum16<S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14,S15> ) -> Self {
match src {
Enum16::_0(v) => <Self as FromVariant<S0,(L,VA)>>::from_variant(v),
Enum16::_1(v) => <Self as ExchangeFrom<Enum15<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14,S15>,(R,AA)>>::exchange_from( Enum15::_0(v) ),
Enum16::_2(v) => <Self as ExchangeFrom<Enum15<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14,S15>,(R,AA)>>::exchange_from( Enum15::_1(v) ),
Enum16::_3(v) => <Self as ExchangeFrom<Enum15<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14,S15>,(R,AA)>>::exchange_from( Enum15::_2(v) ),
Enum16::_4(v) => <Self as ExchangeFrom<Enum15<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14,S15>,(R,AA)>>::exchange_from( Enum15::_3(v) ),
Enum16::_5(v) => <Self as ExchangeFrom<Enum15<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14,S15>,(R,AA)>>::exchange_from( Enum15::_4(v) ),
Enum16::_6(v) => <Self as ExchangeFrom<Enum15<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14,S15>,(R,AA)>>::exchange_from( Enum15::_5(v) ),
Enum16::_7(v) => <Self as ExchangeFrom<Enum15<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14,S15>,(R,AA)>>::exchange_from( Enum15::_6(v) ),
Enum16::_8(v) => <Self as ExchangeFrom<Enum15<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14,S15>,(R,AA)>>::exchange_from( Enum15::_7(v) ),
Enum16::_9(v) => <Self as ExchangeFrom<Enum15<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14,S15>,(R,AA)>>::exchange_from( Enum15::_8(v) ),
Enum16::_10(v) => <Self as ExchangeFrom<Enum15<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14,S15>,(R,AA)>>::exchange_from( Enum15::_9(v) ),
Enum16::_11(v) => <Self as ExchangeFrom<Enum15<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14,S15>,(R,AA)>>::exchange_from( Enum15::_10(v) ),
Enum16::_12(v) => <Self as ExchangeFrom<Enum15<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14,S15>,(R,AA)>>::exchange_from( Enum15::_11(v) ),
Enum16::_13(v) => <Self as ExchangeFrom<Enum15<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14,S15>,(R,AA)>>::exchange_from( Enum15::_12(v) ),
Enum16::_14(v) => <Self as ExchangeFrom<Enum15<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14,S15>,(R,AA)>>::exchange_from( Enum15::_13(v) ),
Enum16::_15(v) => <Self as ExchangeFrom<Enum15<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14,S15>,(R,AA)>>::exchange_from( Enum15::_14(v) ),
}
}
}
pub struct V1;
pub struct V2;
pub struct V3;
pub struct V4;
pub struct V5;
pub struct V6;
pub struct V7;
pub struct V8;
pub struct V9;
pub struct V10;
pub struct V11;
pub struct V12;
pub struct V13;
pub struct V14;
pub struct V15;
impl<T0,T1> FromVariant<T0,(V0,VA)> for Enum2<T0,T1> {
fn from_variant( variant: T0 ) -> Self {
Enum2::_0( variant )
}
}
impl<T0,T1> FromVariant<T1,(V1,VA)> for Enum2<T0,T1> {
fn from_variant( variant: T1 ) -> Self {
Enum2::_1( variant )
}
}
impl<T0,T1,T2> FromVariant<T0,(V0,VA)> for Enum3<T0,T1,T2> {
fn from_variant( variant: T0 ) -> Self {
Enum3::_0( variant )
}
}
impl<T0,T1,T2> FromVariant<T1,(V1,VA)> for Enum3<T0,T1,T2> {
fn from_variant( variant: T1 ) -> Self {
Enum3::_1( variant )
}
}
impl<T0,T1,T2> FromVariant<T2,(V2,VA)> for Enum3<T0,T1,T2> {
fn from_variant( variant: T2 ) -> Self {
Enum3::_2( variant )
}
}
impl<T0,T1,T2,T3> FromVariant<T0,(V0,VA)> for Enum4<T0,T1,T2,T3> {
fn from_variant( variant: T0 ) -> Self {
Enum4::_0( variant )
}
}
impl<T0,T1,T2,T3> FromVariant<T1,(V1,VA)> for Enum4<T0,T1,T2,T3> {
fn from_variant( variant: T1 ) -> Self {
Enum4::_1( variant )
}
}
impl<T0,T1,T2,T3> FromVariant<T2,(V2,VA)> for Enum4<T0,T1,T2,T3> {
fn from_variant( variant: T2 ) -> Self {
Enum4::_2( variant )
}
}
impl<T0,T1,T2,T3> FromVariant<T3,(V3,VA)> for Enum4<T0,T1,T2,T3> {
fn from_variant( variant: T3 ) -> Self {
Enum4::_3( variant )
}
}
impl<T0,T1,T2,T3,T4> FromVariant<T0,(V0,VA)> for Enum5<T0,T1,T2,T3,T4> {
fn from_variant( variant: T0 ) -> Self {
Enum5::_0( variant )
}
}
impl<T0,T1,T2,T3,T4> FromVariant<T1,(V1,VA)> for Enum5<T0,T1,T2,T3,T4> {
fn from_variant( variant: T1 ) -> Self {
Enum5::_1( variant )
}
}
impl<T0,T1,T2,T3,T4> FromVariant<T2,(V2,VA)> for Enum5<T0,T1,T2,T3,T4> {
fn from_variant( variant: T2 ) -> Self {
Enum5::_2( variant )
}
}
impl<T0,T1,T2,T3,T4> FromVariant<T3,(V3,VA)> for Enum5<T0,T1,T2,T3,T4> {
fn from_variant( variant: T3 ) -> Self {
Enum5::_3( variant )
}
}
impl<T0,T1,T2,T3,T4> FromVariant<T4,(V4,VA)> for Enum5<T0,T1,T2,T3,T4> {
fn from_variant( variant: T4 ) -> Self {
Enum5::_4( variant )
}
}
impl<T0,T1,T2,T3,T4,T5> FromVariant<T0,(V0,VA)> for Enum6<T0,T1,T2,T3,T4,T5> {
fn from_variant( variant: T0 ) -> Self {
Enum6::_0( variant )
}
}
impl<T0,T1,T2,T3,T4,T5> FromVariant<T1,(V1,VA)> for Enum6<T0,T1,T2,T3,T4,T5> {
fn from_variant( variant: T1 ) -> Self {
Enum6::_1( variant )
}
}
impl<T0,T1,T2,T3,T4,T5> FromVariant<T2,(V2,VA)> for Enum6<T0,T1,T2,T3,T4,T5> {
fn from_variant( variant: T2 ) -> Self {
Enum6::_2( variant )
}
}
impl<T0,T1,T2,T3,T4,T5> FromVariant<T3,(V3,VA)> for Enum6<T0,T1,T2,T3,T4,T5> {
fn from_variant( variant: T3 ) -> Self {
Enum6::_3( variant )
}
}
impl<T0,T1,T2,T3,T4,T5> FromVariant<T4,(V4,VA)> for Enum6<T0,T1,T2,T3,T4,T5> {
fn from_variant( variant: T4 ) -> Self {
Enum6::_4( variant )
}
}
impl<T0,T1,T2,T3,T4,T5> FromVariant<T5,(V5,VA)> for Enum6<T0,T1,T2,T3,T4,T5> {
fn from_variant( variant: T5 ) -> Self {
Enum6::_5( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6> FromVariant<T0,(V0,VA)> for Enum7<T0,T1,T2,T3,T4,T5,T6> {
fn from_variant( variant: T0 ) -> Self {
Enum7::_0( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6> FromVariant<T1,(V1,VA)> for Enum7<T0,T1,T2,T3,T4,T5,T6> {
fn from_variant( variant: T1 ) -> Self {
Enum7::_1( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6> FromVariant<T2,(V2,VA)> for Enum7<T0,T1,T2,T3,T4,T5,T6> {
fn from_variant( variant: T2 ) -> Self {
Enum7::_2( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6> FromVariant<T3,(V3,VA)> for Enum7<T0,T1,T2,T3,T4,T5,T6> {
fn from_variant( variant: T3 ) -> Self {
Enum7::_3( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6> FromVariant<T4,(V4,VA)> for Enum7<T0,T1,T2,T3,T4,T5,T6> {
fn from_variant( variant: T4 ) -> Self {
Enum7::_4( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6> FromVariant<T5,(V5,VA)> for Enum7<T0,T1,T2,T3,T4,T5,T6> {
fn from_variant( variant: T5 ) -> Self {
Enum7::_5( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6> FromVariant<T6,(V6,VA)> for Enum7<T0,T1,T2,T3,T4,T5,T6> {
fn from_variant( variant: T6 ) -> Self {
Enum7::_6( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7> FromVariant<T0,(V0,VA)> for Enum8<T0,T1,T2,T3,T4,T5,T6,T7> {
fn from_variant( variant: T0 ) -> Self {
Enum8::_0( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7> FromVariant<T1,(V1,VA)> for Enum8<T0,T1,T2,T3,T4,T5,T6,T7> {
fn from_variant( variant: T1 ) -> Self {
Enum8::_1( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7> FromVariant<T2,(V2,VA)> for Enum8<T0,T1,T2,T3,T4,T5,T6,T7> {
fn from_variant( variant: T2 ) -> Self {
Enum8::_2( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7> FromVariant<T3,(V3,VA)> for Enum8<T0,T1,T2,T3,T4,T5,T6,T7> {
fn from_variant( variant: T3 ) -> Self {
Enum8::_3( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7> FromVariant<T4,(V4,VA)> for Enum8<T0,T1,T2,T3,T4,T5,T6,T7> {
fn from_variant( variant: T4 ) -> Self {
Enum8::_4( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7> FromVariant<T5,(V5,VA)> for Enum8<T0,T1,T2,T3,T4,T5,T6,T7> {
fn from_variant( variant: T5 ) -> Self {
Enum8::_5( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7> FromVariant<T6,(V6,VA)> for Enum8<T0,T1,T2,T3,T4,T5,T6,T7> {
fn from_variant( variant: T6 ) -> Self {
Enum8::_6( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7> FromVariant<T7,(V7,VA)> for Enum8<T0,T1,T2,T3,T4,T5,T6,T7> {
fn from_variant( variant: T7 ) -> Self {
Enum8::_7( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8> FromVariant<T0,(V0,VA)> for Enum9<T0,T1,T2,T3,T4,T5,T6,T7,T8> {
fn from_variant( variant: T0 ) -> Self {
Enum9::_0( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8> FromVariant<T1,(V1,VA)> for Enum9<T0,T1,T2,T3,T4,T5,T6,T7,T8> {
fn from_variant( variant: T1 ) -> Self {
Enum9::_1( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8> FromVariant<T2,(V2,VA)> for Enum9<T0,T1,T2,T3,T4,T5,T6,T7,T8> {
fn from_variant( variant: T2 ) -> Self {
Enum9::_2( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8> FromVariant<T3,(V3,VA)> for Enum9<T0,T1,T2,T3,T4,T5,T6,T7,T8> {
fn from_variant( variant: T3 ) -> Self {
Enum9::_3( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8> FromVariant<T4,(V4,VA)> for Enum9<T0,T1,T2,T3,T4,T5,T6,T7,T8> {
fn from_variant( variant: T4 ) -> Self {
Enum9::_4( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8> FromVariant<T5,(V5,VA)> for Enum9<T0,T1,T2,T3,T4,T5,T6,T7,T8> {
fn from_variant( variant: T5 ) -> Self {
Enum9::_5( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8> FromVariant<T6,(V6,VA)> for Enum9<T0,T1,T2,T3,T4,T5,T6,T7,T8> {
fn from_variant( variant: T6 ) -> Self {
Enum9::_6( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8> FromVariant<T7,(V7,VA)> for Enum9<T0,T1,T2,T3,T4,T5,T6,T7,T8> {
fn from_variant( variant: T7 ) -> Self {
Enum9::_7( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8> FromVariant<T8,(V8,VA)> for Enum9<T0,T1,T2,T3,T4,T5,T6,T7,T8> {
fn from_variant( variant: T8 ) -> Self {
Enum9::_8( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9> FromVariant<T0,(V0,VA)> for Enum10<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9> {
fn from_variant( variant: T0 ) -> Self {
Enum10::_0( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9> FromVariant<T1,(V1,VA)> for Enum10<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9> {
fn from_variant( variant: T1 ) -> Self {
Enum10::_1( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9> FromVariant<T2,(V2,VA)> for Enum10<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9> {
fn from_variant( variant: T2 ) -> Self {
Enum10::_2( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9> FromVariant<T3,(V3,VA)> for Enum10<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9> {
fn from_variant( variant: T3 ) -> Self {
Enum10::_3( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9> FromVariant<T4,(V4,VA)> for Enum10<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9> {
fn from_variant( variant: T4 ) -> Self {
Enum10::_4( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9> FromVariant<T5,(V5,VA)> for Enum10<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9> {
fn from_variant( variant: T5 ) -> Self {
Enum10::_5( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9> FromVariant<T6,(V6,VA)> for Enum10<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9> {
fn from_variant( variant: T6 ) -> Self {
Enum10::_6( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9> FromVariant<T7,(V7,VA)> for Enum10<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9> {
fn from_variant( variant: T7 ) -> Self {
Enum10::_7( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9> FromVariant<T8,(V8,VA)> for Enum10<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9> {
fn from_variant( variant: T8 ) -> Self {
Enum10::_8( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9> FromVariant<T9,(V9,VA)> for Enum10<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9> {
fn from_variant( variant: T9 ) -> Self {
Enum10::_9( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> FromVariant<T0,(V0,VA)> for Enum11<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> {
fn from_variant( variant: T0 ) -> Self {
Enum11::_0( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> FromVariant<T1,(V1,VA)> for Enum11<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> {
fn from_variant( variant: T1 ) -> Self {
Enum11::_1( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> FromVariant<T2,(V2,VA)> for Enum11<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> {
fn from_variant( variant: T2 ) -> Self {
Enum11::_2( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> FromVariant<T3,(V3,VA)> for Enum11<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> {
fn from_variant( variant: T3 ) -> Self {
Enum11::_3( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> FromVariant<T4,(V4,VA)> for Enum11<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> {
fn from_variant( variant: T4 ) -> Self {
Enum11::_4( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> FromVariant<T5,(V5,VA)> for Enum11<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> {
fn from_variant( variant: T5 ) -> Self {
Enum11::_5( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> FromVariant<T6,(V6,VA)> for Enum11<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> {
fn from_variant( variant: T6 ) -> Self {
Enum11::_6( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> FromVariant<T7,(V7,VA)> for Enum11<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> {
fn from_variant( variant: T7 ) -> Self {
Enum11::_7( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> FromVariant<T8,(V8,VA)> for Enum11<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> {
fn from_variant( variant: T8 ) -> Self {
Enum11::_8( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> FromVariant<T9,(V9,VA)> for Enum11<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> {
fn from_variant( variant: T9 ) -> Self {
Enum11::_9( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> FromVariant<T10,(V10,VA)> for Enum11<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> {
fn from_variant( variant: T10 ) -> Self {
Enum11::_10( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> FromVariant<T0,(V0,VA)> for Enum12<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> {
fn from_variant( variant: T0 ) -> Self {
Enum12::_0( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> FromVariant<T1,(V1,VA)> for Enum12<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> {
fn from_variant( variant: T1 ) -> Self {
Enum12::_1( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> FromVariant<T2,(V2,VA)> for Enum12<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> {
fn from_variant( variant: T2 ) -> Self {
Enum12::_2( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> FromVariant<T3,(V3,VA)> for Enum12<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> {
fn from_variant( variant: T3 ) -> Self {
Enum12::_3( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> FromVariant<T4,(V4,VA)> for Enum12<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> {
fn from_variant( variant: T4 ) -> Self {
Enum12::_4( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> FromVariant<T5,(V5,VA)> for Enum12<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> {
fn from_variant( variant: T5 ) -> Self {
Enum12::_5( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> FromVariant<T6,(V6,VA)> for Enum12<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> {
fn from_variant( variant: T6 ) -> Self {
Enum12::_6( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> FromVariant<T7,(V7,VA)> for Enum12<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> {
fn from_variant( variant: T7 ) -> Self {
Enum12::_7( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> FromVariant<T8,(V8,VA)> for Enum12<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> {
fn from_variant( variant: T8 ) -> Self {
Enum12::_8( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> FromVariant<T9,(V9,VA)> for Enum12<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> {
fn from_variant( variant: T9 ) -> Self {
Enum12::_9( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> FromVariant<T10,(V10,VA)> for Enum12<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> {
fn from_variant( variant: T10 ) -> Self {
Enum12::_10( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> FromVariant<T11,(V11,VA)> for Enum12<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> {
fn from_variant( variant: T11 ) -> Self {
Enum12::_11( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> FromVariant<T0,(V0,VA)> for Enum13<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> {
fn from_variant( variant: T0 ) -> Self {
Enum13::_0( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> FromVariant<T1,(V1,VA)> for Enum13<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> {
fn from_variant( variant: T1 ) -> Self {
Enum13::_1( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> FromVariant<T2,(V2,VA)> for Enum13<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> {
fn from_variant( variant: T2 ) -> Self {
Enum13::_2( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> FromVariant<T3,(V3,VA)> for Enum13<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> {
fn from_variant( variant: T3 ) -> Self {
Enum13::_3( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> FromVariant<T4,(V4,VA)> for Enum13<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> {
fn from_variant( variant: T4 ) -> Self {
Enum13::_4( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> FromVariant<T5,(V5,VA)> for Enum13<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> {
fn from_variant( variant: T5 ) -> Self {
Enum13::_5( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> FromVariant<T6,(V6,VA)> for Enum13<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> {
fn from_variant( variant: T6 ) -> Self {
Enum13::_6( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> FromVariant<T7,(V7,VA)> for Enum13<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> {
fn from_variant( variant: T7 ) -> Self {
Enum13::_7( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> FromVariant<T8,(V8,VA)> for Enum13<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> {
fn from_variant( variant: T8 ) -> Self {
Enum13::_8( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> FromVariant<T9,(V9,VA)> for Enum13<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> {
fn from_variant( variant: T9 ) -> Self {
Enum13::_9( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> FromVariant<T10,(V10,VA)> for Enum13<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> {
fn from_variant( variant: T10 ) -> Self {
Enum13::_10( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> FromVariant<T11,(V11,VA)> for Enum13<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> {
fn from_variant( variant: T11 ) -> Self {
Enum13::_11( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> FromVariant<T12,(V12,VA)> for Enum13<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> {
fn from_variant( variant: T12 ) -> Self {
Enum13::_12( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> FromVariant<T0,(V0,VA)> for Enum14<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> {
fn from_variant( variant: T0 ) -> Self {
Enum14::_0( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> FromVariant<T1,(V1,VA)> for Enum14<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> {
fn from_variant( variant: T1 ) -> Self {
Enum14::_1( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> FromVariant<T2,(V2,VA)> for Enum14<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> {
fn from_variant( variant: T2 ) -> Self {
Enum14::_2( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> FromVariant<T3,(V3,VA)> for Enum14<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> {
fn from_variant( variant: T3 ) -> Self {
Enum14::_3( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> FromVariant<T4,(V4,VA)> for Enum14<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> {
fn from_variant( variant: T4 ) -> Self {
Enum14::_4( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> FromVariant<T5,(V5,VA)> for Enum14<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> {
fn from_variant( variant: T5 ) -> Self {
Enum14::_5( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> FromVariant<T6,(V6,VA)> for Enum14<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> {
fn from_variant( variant: T6 ) -> Self {
Enum14::_6( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> FromVariant<T7,(V7,VA)> for Enum14<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> {
fn from_variant( variant: T7 ) -> Self {
Enum14::_7( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> FromVariant<T8,(V8,VA)> for Enum14<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> {
fn from_variant( variant: T8 ) -> Self {
Enum14::_8( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> FromVariant<T9,(V9,VA)> for Enum14<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> {
fn from_variant( variant: T9 ) -> Self {
Enum14::_9( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> FromVariant<T10,(V10,VA)> for Enum14<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> {
fn from_variant( variant: T10 ) -> Self {
Enum14::_10( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> FromVariant<T11,(V11,VA)> for Enum14<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> {
fn from_variant( variant: T11 ) -> Self {
Enum14::_11( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> FromVariant<T12,(V12,VA)> for Enum14<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> {
fn from_variant( variant: T12 ) -> Self {
Enum14::_12( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> FromVariant<T13,(V13,VA)> for Enum14<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> {
fn from_variant( variant: T13 ) -> Self {
Enum14::_13( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> FromVariant<T0,(V0,VA)> for Enum15<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> {
fn from_variant( variant: T0 ) -> Self {
Enum15::_0( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> FromVariant<T1,(V1,VA)> for Enum15<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> {
fn from_variant( variant: T1 ) -> Self {
Enum15::_1( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> FromVariant<T2,(V2,VA)> for Enum15<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> {
fn from_variant( variant: T2 ) -> Self {
Enum15::_2( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> FromVariant<T3,(V3,VA)> for Enum15<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> {
fn from_variant( variant: T3 ) -> Self {
Enum15::_3( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> FromVariant<T4,(V4,VA)> for Enum15<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> {
fn from_variant( variant: T4 ) -> Self {
Enum15::_4( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> FromVariant<T5,(V5,VA)> for Enum15<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> {
fn from_variant( variant: T5 ) -> Self {
Enum15::_5( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> FromVariant<T6,(V6,VA)> for Enum15<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> {
fn from_variant( variant: T6 ) -> Self {
Enum15::_6( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> FromVariant<T7,(V7,VA)> for Enum15<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> {
fn from_variant( variant: T7 ) -> Self {
Enum15::_7( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> FromVariant<T8,(V8,VA)> for Enum15<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> {
fn from_variant( variant: T8 ) -> Self {
Enum15::_8( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> FromVariant<T9,(V9,VA)> for Enum15<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> {
fn from_variant( variant: T9 ) -> Self {
Enum15::_9( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> FromVariant<T10,(V10,VA)> for Enum15<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> {
fn from_variant( variant: T10 ) -> Self {
Enum15::_10( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> FromVariant<T11,(V11,VA)> for Enum15<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> {
fn from_variant( variant: T11 ) -> Self {
Enum15::_11( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> FromVariant<T12,(V12,VA)> for Enum15<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> {
fn from_variant( variant: T12 ) -> Self {
Enum15::_12( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> FromVariant<T13,(V13,VA)> for Enum15<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> {
fn from_variant( variant: T13 ) -> Self {
Enum15::_13( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> FromVariant<T14,(V14,VA)> for Enum15<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> {
fn from_variant( variant: T14 ) -> Self {
Enum15::_14( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> FromVariant<T0,(V0,VA)> for Enum16<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> {
fn from_variant( variant: T0 ) -> Self {
Enum16::_0( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> FromVariant<T1,(V1,VA)> for Enum16<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> {
fn from_variant( variant: T1 ) -> Self {
Enum16::_1( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> FromVariant<T2,(V2,VA)> for Enum16<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> {
fn from_variant( variant: T2 ) -> Self {
Enum16::_2( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> FromVariant<T3,(V3,VA)> for Enum16<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> {
fn from_variant( variant: T3 ) -> Self {
Enum16::_3( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> FromVariant<T4,(V4,VA)> for Enum16<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> {
fn from_variant( variant: T4 ) -> Self {
Enum16::_4( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> FromVariant<T5,(V5,VA)> for Enum16<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> {
fn from_variant( variant: T5 ) -> Self {
Enum16::_5( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> FromVariant<T6,(V6,VA)> for Enum16<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> {
fn from_variant( variant: T6 ) -> Self {
Enum16::_6( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> FromVariant<T7,(V7,VA)> for Enum16<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> {
fn from_variant( variant: T7 ) -> Self {
Enum16::_7( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> FromVariant<T8,(V8,VA)> for Enum16<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> {
fn from_variant( variant: T8 ) -> Self {
Enum16::_8( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> FromVariant<T9,(V9,VA)> for Enum16<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> {
fn from_variant( variant: T9 ) -> Self {
Enum16::_9( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> FromVariant<T10,(V10,VA)> for Enum16<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> {
fn from_variant( variant: T10 ) -> Self {
Enum16::_10( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> FromVariant<T11,(V11,VA)> for Enum16<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> {
fn from_variant( variant: T11 ) -> Self {
Enum16::_11( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> FromVariant<T12,(V12,VA)> for Enum16<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> {
fn from_variant( variant: T12 ) -> Self {
Enum16::_12( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> FromVariant<T13,(V13,VA)> for Enum16<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> {
fn from_variant( variant: T13 ) -> Self {
Enum16::_13( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> FromVariant<T14,(V14,VA)> for Enum16<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> {
fn from_variant( variant: T14 ) -> Self {
Enum16::_14( variant )
}
}
impl<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> FromVariant<T15,(V15,VA)> for Enum16<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> {
fn from_variant( variant: T15 ) -> Self {
Enum16::_15( variant )
}
}
#[macro_export]
macro_rules! Enum {
( $t0:ty ) => { Enum1<$t0> };
( $t0:ty, $t1:ty ) => { Enum2<$t0,$t1> };
( $t0:ty, $t1:ty, $t2:ty ) => { Enum3<$t0,$t1,$t2> };
( $t0:ty, $t1:ty, $t2:ty, $t3:ty ) => { Enum4<$t0,$t1,$t2,$t3> };
( $t0:ty, $t1:ty, $t2:ty, $t3:ty, $t4:ty ) => { Enum5<$t0,$t1,$t2,$t3,$t4> };
( $t0:ty, $t1:ty, $t2:ty, $t3:ty, $t4:ty, $t5:ty ) => { Enum6<$t0,$t1,$t2,$t3,$t4,$t5> };
( $t0:ty, $t1:ty, $t2:ty, $t3:ty, $t4:ty, $t5:ty, $t6:ty ) => { Enum7<$t0,$t1,$t2,$t3,$t4,$t5,$t6> };
( $t0:ty, $t1:ty, $t2:ty, $t3:ty, $t4:ty, $t5:ty, $t6:ty, $t7:ty ) => { Enum8<$t0,$t1,$t2,$t3,$t4,$t5,$t6,$t7> };
( $t0:ty, $t1:ty, $t2:ty, $t3:ty, $t4:ty, $t5:ty, $t6:ty, $t7:ty, $t8:ty ) => { Enum9<$t0,$t1,$t2,$t3,$t4,$t5,$t6,$t7,$t8> };
( $t0:ty, $t1:ty, $t2:ty, $t3:ty, $t4:ty, $t5:ty, $t6:ty, $t7:ty, $t8:ty, $t9:ty ) => { Enum10<$t0,$t1,$t2,$t3,$t4,$t5,$t6,$t7,$t8,$t9> };
( $t0:ty, $t1:ty, $t2:ty, $t3:ty, $t4:ty, $t5:ty, $t6:ty, $t7:ty, $t8:ty, $t9:ty, $t10:ty ) => { Enum11<$t0,$t1,$t2,$t3,$t4,$t5,$t6,$t7,$t8,$t9,$t10> };
( $t0:ty, $t1:ty, $t2:ty, $t3:ty, $t4:ty, $t5:ty, $t6:ty, $t7:ty, $t8:ty, $t9:ty, $t10:ty, $t11:ty ) => { Enum12<$t0,$t1,$t2,$t3,$t4,$t5,$t6,$t7,$t8,$t9,$t10,$t11> };
( $t0:ty, $t1:ty, $t2:ty, $t3:ty, $t4:ty, $t5:ty, $t6:ty, $t7:ty, $t8:ty, $t9:ty, $t10:ty, $t11:ty, $t12:ty ) => { Enum13<$t0,$t1,$t2,$t3,$t4,$t5,$t6,$t7,$t8,$t9,$t10,$t11,$t12> };
( $t0:ty, $t1:ty, $t2:ty, $t3:ty, $t4:ty, $t5:ty, $t6:ty, $t7:ty, $t8:ty, $t9:ty, $t10:ty, $t11:ty, $t12:ty, $t13:ty ) => { Enum14<$t0,$t1,$t2,$t3,$t4,$t5,$t6,$t7,$t8,$t9,$t10,$t11,$t12,$t13> };
( $t0:ty, $t1:ty, $t2:ty, $t3:ty, $t4:ty, $t5:ty, $t6:ty, $t7:ty, $t8:ty, $t9:ty, $t10:ty, $t11:ty, $t12:ty, $t13:ty, $t14:ty ) => { Enum15<$t0,$t1,$t2,$t3,$t4,$t5,$t6,$t7,$t8,$t9,$t10,$t11,$t12,$t13,$t14> };
}
pub mod prelude {
pub use super::EnumX;
pub use super::ExchangeFrom;
pub use super::ExchangeInto;
pub use super::FromVariant;
pub use super::IntoEnum;
pub use super::EnumxFrom;
pub use super::IntoEnumx;
pub use super::Enum0;
pub use super::Enum1;
pub use super::Enum2;
pub use super::Enum3;
pub use super::Enum4;
pub use super::Enum5;
pub use super::Enum6;
pub use super::Enum7;
pub use super::Enum8;
pub use super::Enum9;
pub use super::Enum10;
pub use super::Enum11;
pub use super::Enum12;
pub use super::Enum13;
pub use super::Enum14;
pub use super::Enum15;
pub use super::Enum16;
}