Compiler Explorer

Source code

#![feature(prelude_import, structural_match, core_intrinsics)]
#![allow(warnings)]
#[prelude_import]
use std::prelude::rust_2021::*;
extern crate core;

use std::cmp::Ordering;
pub enum FE<T> {
    A(T),
    B,
}
#[automatically_derived]
impl<T> ::core::marker::StructuralPartialEq for FE<T> {}
#[automatically_derived]
impl<T: ::core::cmp::PartialEq> ::core::cmp::PartialEq for FE<T> {
    #[inline]
    fn eq(&self, other: &FE<T>) -> bool {
        let __self_tag = ::core::intrinsics::discriminant_value(self);
        let __arg1_tag = ::core::intrinsics::discriminant_value(other);
        __self_tag == __arg1_tag
            && match (self, other) {
                (FE::A(__self_0), FE::A(__arg1_0)) => *__self_0 == *__arg1_0,
                _ => true,
            }
    }
}
#[automatically_derived]
impl<T: ::core::cmp::PartialOrd> ::core::cmp::PartialOrd for FE<T> {
    #[inline]
    fn partial_cmp(
        &self,
        other: &FE<T>,
    ) -> ::core::option::Option<::core::cmp::Ordering> {
        let __self_tag = ::core::intrinsics::discriminant_value(self);
        let __arg1_tag = ::core::intrinsics::discriminant_value(other);
        match (self, other) {
            (FE::A(__self_0), FE::A(__arg1_0)) => {
                ::core::cmp::PartialOrd::partial_cmp(__self_0, __arg1_0)
            }
            _ => ::core::cmp::PartialOrd::partial_cmp(&__self_tag, &__arg1_tag),
        }
    }
}
pub enum EF<T> {
    A,
    B(T),
}
#[automatically_derived]
impl<T> ::core::marker::StructuralPartialEq for EF<T> {}
#[automatically_derived]
impl<T: ::core::cmp::PartialEq> ::core::cmp::PartialEq for EF<T> {
    #[inline]
    fn eq(&self, other: &EF<T>) -> bool {
        let __self_tag = ::core::intrinsics::discriminant_value(self);
        let __arg1_tag = ::core::intrinsics::discriminant_value(other);
        __self_tag == __arg1_tag
            && match (self, other) {
                (EF::B(__self_0), EF::B(__arg1_0)) => *__self_0 == *__arg1_0,
                _ => true,
            }
    }
}
#[automatically_derived]
impl<T: ::core::cmp::PartialOrd> ::core::cmp::PartialOrd for EF<T> {
    #[inline]
    fn partial_cmp(
        &self,
        other: &EF<T>,
    ) -> ::core::option::Option<::core::cmp::Ordering> {
        let __self_tag = ::core::intrinsics::discriminant_value(self);
        let __arg1_tag = ::core::intrinsics::discriminant_value(other);
        match (self, other) {
            (EF::B(__self_0), EF::B(__arg1_0)) => {
                ::core::cmp::PartialOrd::partial_cmp(__self_0, __arg1_0)
            }
            _ => ::core::cmp::PartialOrd::partial_cmp(&__self_tag, &__arg1_tag),
        }
    }
}
pub enum FEF<T> {
    A(T),
    B,
    C(T),
}
#[automatically_derived]
impl<T> ::core::marker::StructuralPartialEq for FEF<T> {}
#[automatically_derived]
impl<T: ::core::cmp::PartialEq> ::core::cmp::PartialEq for FEF<T> {
    #[inline]
    fn eq(&self, other: &FEF<T>) -> bool {
        let __self_tag = ::core::intrinsics::discriminant_value(self);
        let __arg1_tag = ::core::intrinsics::discriminant_value(other);
        __self_tag == __arg1_tag
            && match (self, other) {
                (FEF::A(__self_0), FEF::A(__arg1_0)) => *__self_0 == *__arg1_0,
                (FEF::C(__self_0), FEF::C(__arg1_0)) => *__self_0 == *__arg1_0,
                _ => true,
            }
    }
}
#[automatically_derived]
impl<T: ::core::cmp::PartialOrd> ::core::cmp::PartialOrd for FEF<T> {
    #[inline]
    fn partial_cmp(
        &self,
        other: &FEF<T>,
    ) -> ::core::option::Option<::core::cmp::Ordering> {
        let __self_tag = ::core::intrinsics::discriminant_value(self);
        let __arg1_tag = ::core::intrinsics::discriminant_value(other);
        match (self, other) {
            (FEF::A(__self_0), FEF::A(__arg1_0)) => {
                ::core::cmp::PartialOrd::partial_cmp(__self_0, __arg1_0)
            }
            (FEF::C(__self_0), FEF::C(__arg1_0)) => {
                ::core::cmp::PartialOrd::partial_cmp(__self_0, __arg1_0)
            }
            _ => ::core::cmp::PartialOrd::partial_cmp(&__self_tag, &__arg1_tag),
        }
    }
}
pub enum EFE<T> {
    A,
    B(T),
    C,
}
#[automatically_derived]
impl<T> ::core::marker::StructuralPartialEq for EFE<T> {}
#[automatically_derived]
impl<T: ::core::cmp::PartialEq> ::core::cmp::PartialEq for EFE<T> {
    #[inline]
    fn eq(&self, other: &EFE<T>) -> bool {
        let __self_tag = ::core::intrinsics::discriminant_value(self);
        let __arg1_tag = ::core::intrinsics::discriminant_value(other);
        __self_tag == __arg1_tag
            && match (self, other) {
                (EFE::B(__self_0), EFE::B(__arg1_0)) => *__self_0 == *__arg1_0,
                _ => true,
            }
    }
}
#[automatically_derived]
impl<T: ::core::cmp::PartialOrd> ::core::cmp::PartialOrd for EFE<T> {
    #[inline]
    fn partial_cmp(
        &self,
        other: &EFE<T>,
    ) -> ::core::option::Option<::core::cmp::Ordering> {
        let __self_tag = ::core::intrinsics::discriminant_value(self);
        let __arg1_tag = ::core::intrinsics::discriminant_value(other);
        match (self, other) {
            (EFE::B(__self_0), EFE::B(__arg1_0)) => {
                ::core::cmp::PartialOrd::partial_cmp(__self_0, __arg1_0)
            }
            _ => ::core::cmp::PartialOrd::partial_cmp(&__self_tag, &__arg1_tag),
        }
    }
}
pub enum FEEF<T> {
    A(T),
    B,
    C,
    D(T),
}
#[automatically_derived]
impl<T> ::core::marker::StructuralPartialEq for FEEF<T> {}
#[automatically_derived]
impl<T: ::core::cmp::PartialEq> ::core::cmp::PartialEq for FEEF<T> {
    #[inline]
    fn eq(&self, other: &FEEF<T>) -> bool {
        let __self_tag = ::core::intrinsics::discriminant_value(self);
        let __arg1_tag = ::core::intrinsics::discriminant_value(other);
        __self_tag == __arg1_tag
            && match (self, other) {
                (FEEF::A(__self_0), FEEF::A(__arg1_0)) => *__self_0 == *__arg1_0,
                (FEEF::D(__self_0), FEEF::D(__arg1_0)) => *__self_0 == *__arg1_0,
                _ => true,
            }
    }
}
#[automatically_derived]
impl<T: ::core::cmp::PartialOrd> ::core::cmp::PartialOrd for FEEF<T> {
    #[inline]
    fn partial_cmp(
        &self,
        other: &FEEF<T>,
    ) -> ::core::option::Option<::core::cmp::Ordering> {
        let __self_tag = ::core::intrinsics::discriminant_value(self);
        let __arg1_tag = ::core::intrinsics::discriminant_value(other);
        match (self, other) {
            (FEEF::A(__self_0), FEEF::A(__arg1_0)) => {
                ::core::cmp::PartialOrd::partial_cmp(__self_0, __arg1_0)
            }
            (FEEF::D(__self_0), FEEF::D(__arg1_0)) => {
                ::core::cmp::PartialOrd::partial_cmp(__self_0, __arg1_0)
            }
            _ => ::core::cmp::PartialOrd::partial_cmp(&__self_tag, &__arg1_tag),
        }
    }
}
pub enum EFFE<T> {
    A,
    B(T),
    C(T),
    D,
}
#[automatically_derived]
impl<T> ::core::marker::StructuralPartialEq for EFFE<T> {}
#[automatically_derived]
impl<T: ::core::cmp::PartialEq> ::core::cmp::PartialEq for EFFE<T> {
    #[inline]
    fn eq(&self, other: &EFFE<T>) -> bool {
        let __self_tag = ::core::intrinsics::discriminant_value(self);
        let __arg1_tag = ::core::intrinsics::discriminant_value(other);
        __self_tag == __arg1_tag
            && match (self, other) {
                (EFFE::B(__self_0), EFFE::B(__arg1_0)) => *__self_0 == *__arg1_0,
                (EFFE::C(__self_0), EFFE::C(__arg1_0)) => *__self_0 == *__arg1_0,
                _ => true,
            }
    }
}
#[automatically_derived]
impl<T: ::core::cmp::PartialOrd> ::core::cmp::PartialOrd for EFFE<T> {
    #[inline]
    fn partial_cmp(
        &self,
        other: &EFFE<T>,
    ) -> ::core::option::Option<::core::cmp::Ordering> {
        let __self_tag = ::core::intrinsics::discriminant_value(self);
        let __arg1_tag = ::core::intrinsics::discriminant_value(other);
        match (self, other) {
            (EFFE::B(__self_0), EFFE::B(__arg1_0)) => {
                ::core::cmp::PartialOrd::partial_cmp(__self_0, __arg1_0)
            }
            (EFFE::C(__self_0), EFFE::C(__arg1_0)) => {
                ::core::cmp::PartialOrd::partial_cmp(__self_0, __arg1_0)
            }
            _ => ::core::cmp::PartialOrd::partial_cmp(&__self_tag, &__arg1_tag),
        }
    }
}
pub fn FE(l: FE<usize>, r: FE<usize>) -> Option<Ordering> {
    l.partial_cmp(&r)
}
pub fn EF(l: EF<usize>, r: EF<usize>) -> Option<Ordering> {
    l.partial_cmp(&r)
}
pub fn FEF(l: FEF<usize>, r: FEF<usize>) -> Option<Ordering> {
    l.partial_cmp(&r)
}
pub fn EFE(l: EFE<usize>, r: EFE<usize>) -> Option<Ordering> {
    l.partial_cmp(&r)
}
pub fn FEEF(l: FEEF<usize>, r: FEEF<usize>) -> Option<Ordering> {
    l.partial_cmp(&r)
}
pub fn EFFE(l: EFFE<usize>, r: EFFE<usize>) -> Option<Ordering> {
    l.partial_cmp(&r)
}