1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
use crate::cmp::Ordering::*;
use crate::cmp::*;
macro_rules! tuple_impls {
    
    ($T:ident) => {
        tuple_impls!(@impl $T);
    };
    
    ($T:ident $( $U:ident )+) => {
        tuple_impls!($( $U )+);
        tuple_impls!(@impl $T $( $U )+);
    };
    
    (@impl $( $T:ident )+) => {
        #[stable(feature = "rust1", since = "1.0.0")]
        impl<$($T:PartialEq),+> PartialEq for ($($T,)+)
        where
            last_type!($($T,)+): ?Sized
        {
            #[inline]
            fn eq(&self, other: &($($T,)+)) -> bool {
                $( ${ignore(T)} self.${index()} == other.${index()} )&&+
            }
            #[inline]
            fn ne(&self, other: &($($T,)+)) -> bool {
                $( ${ignore(T)} self.${index()} != other.${index()} )||+
            }
        }
        #[stable(feature = "rust1", since = "1.0.0")]
        impl<$($T:Eq),+> Eq for ($($T,)+)
        where
            last_type!($($T,)+): ?Sized
        {}
        #[stable(feature = "rust1", since = "1.0.0")]
        impl<$($T:PartialOrd + PartialEq),+> PartialOrd for ($($T,)+)
        where
            last_type!($($T,)+): ?Sized
        {
            #[inline]
            fn partial_cmp(&self, other: &($($T,)+)) -> Option<Ordering> {
                lexical_partial_cmp!($( ${ignore(T)} self.${index()}, other.${index()} ),+)
            }
            #[inline]
            fn lt(&self, other: &($($T,)+)) -> bool {
                lexical_ord!(lt, $( ${ignore(T)} self.${index()}, other.${index()} ),+)
            }
            #[inline]
            fn le(&self, other: &($($T,)+)) -> bool {
                lexical_ord!(le, $( ${ignore(T)} self.${index()}, other.${index()} ),+)
            }
            #[inline]
            fn ge(&self, other: &($($T,)+)) -> bool {
                lexical_ord!(ge, $( ${ignore(T)} self.${index()}, other.${index()} ),+)
            }
            #[inline]
            fn gt(&self, other: &($($T,)+)) -> bool {
                lexical_ord!(gt, $( ${ignore(T)} self.${index()}, other.${index()} ),+)
            }
        }
        #[stable(feature = "rust1", since = "1.0.0")]
        impl<$($T:Ord),+> Ord for ($($T,)+)
        where
            last_type!($($T,)+): ?Sized
        {
            #[inline]
            fn cmp(&self, other: &($($T,)+)) -> Ordering {
                lexical_cmp!($( ${ignore(T)} self.${index()}, other.${index()} ),+)
            }
        }
        #[stable(feature = "rust1", since = "1.0.0")]
        impl<$($T:Default),+> Default for ($($T,)+) {
            #[inline]
            fn default() -> ($($T,)+) {
                ($({ let x: $T = Default::default(); x},)+)
            }
        }
    }
}
macro_rules! lexical_ord {
    ($rel: ident, $a:expr, $b:expr, $($rest_a:expr, $rest_b:expr),+) => {
        if $a != $b { lexical_ord!($rel, $a, $b) }
        else { lexical_ord!($rel, $($rest_a, $rest_b),+) }
    };
    ($rel: ident, $a:expr, $b:expr) => { ($a) . $rel (& $b) };
}
macro_rules! lexical_partial_cmp {
    ($a:expr, $b:expr, $($rest_a:expr, $rest_b:expr),+) => {
        match ($a).partial_cmp(&$b) {
            Some(Equal) => lexical_partial_cmp!($($rest_a, $rest_b),+),
            ordering   => ordering
        }
    };
    ($a:expr, $b:expr) => { ($a).partial_cmp(&$b) };
}
macro_rules! lexical_cmp {
    ($a:expr, $b:expr, $($rest_a:expr, $rest_b:expr),+) => {
        match ($a).cmp(&$b) {
            Equal => lexical_cmp!($($rest_a, $rest_b),+),
            ordering   => ordering
        }
    };
    ($a:expr, $b:expr) => { ($a).cmp(&$b) };
}
macro_rules! last_type {
    ($a:ident,) => { $a };
    ($a:ident, $($rest_a:ident,)+) => { last_type!($($rest_a,)+) };
}
tuple_impls!(A B C D E F G H I J K L);