tuple - Rust (original) (raw)
Primitive Type tuple1.0.0 [−]
A finite heterogeneous sequence, (T, U, ..).
Let's cover each of those in turn:
Tuples are finite. In other words, a tuple has a length. Here's a tuple of length 3:
("hello", 5, 'c');Run
'Length' is also sometimes called 'arity' here; each tuple of a different length is a different, distinct type.
Tuples are heterogeneous. This means that each element of the tuple can have a different type. In that tuple above, it has the type:
(&'static str, i32, char)Run
Tuples are a sequence. This means that they can be accessed by position; this is called 'tuple indexing', and it looks like this:
let tuple = ("hello", 5, 'c');
assert_eq!(tuple.0, "hello"); assert_eq!(tuple.1, 5); assert_eq!(tuple.2, 'c');Run
For more about tuples, see the book.
If every type inside a tuple implements one of the following traits, then a tuple itself also implements it.
Due to a temporary restriction in Rust's type system, these traits are only implemented on tuples of arity 12 or less. In the future, this may change.
Basic usage:
let tuple = ("hello", 5, 'c');
assert_eq!(tuple.0, "hello");Run
Tuples are often used as a return type when you want to return more than one value:
fn calculate_point() -> (i32, i32) {
(4, 5)}
let point = calculate_point();
assert_eq!(point.0, 4); assert_eq!(point.1, 5);
let (x, y) = calculate_point();
assert_eq!(x, 4); assert_eq!(y, 5);Run
`impl<T5, T6, T7, T8, T9, T10, T11> Debug for (T5, T6, T7, T8, T9, T10, T11) where
T10: Debug,
T11: Debug + ?Sized,
T5: Debug,
T6: Debug,
T7: Debug,
T8: Debug,
T9: Debug, `[src]
`impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Debug for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) where
T0: Debug,
T1: Debug,
T10: Debug,
T11: Debug + ?Sized,
T2: Debug,
T3: Debug,
T4: Debug,
T5: Debug,
T6: Debug,
T7: Debug,
T8: Debug,
T9: Debug, `[src]
`impl<T7, T8, T9, T10, T11> Debug for (T7, T8, T9, T10, T11) where
T10: Debug,
T11: Debug + ?Sized,
T7: Debug,
T8: Debug,
T9: Debug, `[src]
`impl Debug for (T11,) where
`impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Debug for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) where
T1: Debug,
T10: Debug,
T11: Debug + ?Sized,
T2: Debug,
T3: Debug,
T4: Debug,
T5: Debug,
T6: Debug,
T7: Debug,
T8: Debug,
T9: Debug, `[src]
`impl<T10, T11> Debug for (T10, T11) where
T10: Debug,
T11: Debug + ?Sized, `[src]
`impl<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Debug for (T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) where
T10: Debug,
T11: Debug + ?Sized,
T2: Debug,
T3: Debug,
T4: Debug,
T5: Debug,
T6: Debug,
T7: Debug,
T8: Debug,
T9: Debug, `[src]
`impl<T8, T9, T10, T11> Debug for (T8, T9, T10, T11) where
T10: Debug,
T11: Debug + ?Sized,
T8: Debug,
T9: Debug, `[src]
`impl<T4, T5, T6, T7, T8, T9, T10, T11> Debug for (T4, T5, T6, T7, T8, T9, T10, T11) where
T10: Debug,
T11: Debug + ?Sized,
T4: Debug,
T5: Debug,
T6: Debug,
T7: Debug,
T8: Debug,
T9: Debug, `[src]
`impl<T3, T4, T5, T6, T7, T8, T9, T10, T11> Debug for (T3, T4, T5, T6, T7, T8, T9, T10, T11) where
T10: Debug,
T11: Debug + ?Sized,
T3: Debug,
T4: Debug,
T5: Debug,
T6: Debug,
T7: Debug,
T8: Debug,
T9: Debug, `[src]
`impl<T6, T7, T8, T9, T10, T11> Debug for (T6, T7, T8, T9, T10, T11) where
T10: Debug,
T11: Debug + ?Sized,
T6: Debug,
T7: Debug,
T8: Debug,
T9: Debug, `[src]
`impl<T9, T10, T11> Debug for (T9, T10, T11) where
T10: Debug,
T11: Debug + ?Sized,
T9: Debug, `[src]
`impl<A, B, C, D, E, F, G, H, I, J, K, L> Hash for (A, B, C, D, E, F, G, H, I, J, K, L) where
A: Hash,
B: Hash,
C: Hash,
D: Hash,
E: Hash,
F: Hash,
G: Hash,
H: Hash,
I: Hash,
J: Hash,
K: Hash,
L: Hash + ?Sized, `[src]
`impl<A, B, C> Hash for (A, B, C) where
A: Hash,
B: Hash,
C: Hash + ?Sized, `[src]
`impl<A, B, C, D, E, F, G, H, I> Hash for (A, B, C, D, E, F, G, H, I) where
A: Hash,
B: Hash,
C: Hash,
D: Hash,
E: Hash,
F: Hash,
G: Hash,
H: Hash,
I: Hash + ?Sized, `[src]
`impl<A, B, C, D> Hash for (A, B, C, D) where
A: Hash,
B: Hash,
C: Hash,
D: Hash + ?Sized, `[src]
`impl<A, B, C, D, E, F> Hash for (A, B, C, D, E, F) where
A: Hash,
B: Hash,
C: Hash,
D: Hash,
E: Hash,
F: Hash + ?Sized, `[src]
`impl Hash for (A,) where
`impl<A, B> Hash for (A, B) where
A: Hash,
B: Hash + ?Sized, `[src]
`impl<A, B, C, D, E, F, G, H> Hash for (A, B, C, D, E, F, G, H) where
A: Hash,
B: Hash,
C: Hash,
D: Hash,
E: Hash,
F: Hash,
G: Hash,
H: Hash + ?Sized, `[src]
`impl<A, B, C, D, E> Hash for (A, B, C, D, E) where
A: Hash,
B: Hash,
C: Hash,
D: Hash,
E: Hash + ?Sized, `[src]
`impl<A, B, C, D, E, F, G> Hash for (A, B, C, D, E, F, G) where
A: Hash,
B: Hash,
C: Hash,
D: Hash,
E: Hash,
F: Hash,
G: Hash + ?Sized, `[src]
`impl<A, B, C, D, E, F, G, H, I, J> Hash for (A, B, C, D, E, F, G, H, I, J) where
A: Hash,
B: Hash,
C: Hash,
D: Hash,
E: Hash,
F: Hash,
G: Hash,
H: Hash,
I: Hash,
J: Hash + ?Sized, `[src]
`impl<A, B, C, D, E, F, G, H, I, J, K> Hash for (A, B, C, D, E, F, G, H, I, J, K) where
A: Hash,
B: Hash,
C: Hash,
D: Hash,
E: Hash,
F: Hash,
G: Hash,
H: Hash,
I: Hash,
J: Hash,
K: Hash + ?Sized, `[src]
`impl<A, B, C, D> Default for (A, B, C, D) where
A: Default,
B: Default,
C: Default,
D: Default, `[src]
`impl<A, B, C, D, E, F, G, H, I> Default for (A, B, C, D, E, F, G, H, I) where
A: Default,
B: Default,
C: Default,
D: Default,
E: Default,
F: Default,
G: Default,
H: Default,
I: Default, `[src]
`impl<A, B, C, D, E, F> Default for (A, B, C, D, E, F) where
A: Default,
B: Default,
C: Default,
D: Default,
E: Default,
F: Default, `[src]
`impl<A, B> Default for (A, B) where
A: Default,
B: Default, `[src]
`impl<A, B, C> Default for (A, B, C) where
A: Default,
B: Default,
C: Default, `[src]
`impl<A, B, C, D, E, F, G, H, I, J, K, L> Default for (A, B, C, D, E, F, G, H, I, J, K, L) where
A: Default,
B: Default,
C: Default,
D: Default,
E: Default,
F: Default,
G: Default,
H: Default,
I: Default,
J: Default,
K: Default,
L: Default, `[src]
fn [default](../std/default/trait.Default.html#tymethod.default)() -> [(](primitive.tuple.html)A, B, C, D, E, F, G, H, I, J, K, L[)](primitive.tuple.html)[src]
Returns the "default value" for a type. Read more
`impl<A, B, C, D, E, F, G> Default for (A, B, C, D, E, F, G) where
A: Default,
B: Default,
C: Default,
D: Default,
E: Default,
F: Default,
G: Default, `[src]
`impl Default for (A,) where
`impl<A, B, C, D, E, F, G, H, I, J> Default for (A, B, C, D, E, F, G, H, I, J) where
A: Default,
B: Default,
C: Default,
D: Default,
E: Default,
F: Default,
G: Default,
H: Default,
I: Default,
J: Default, `[src]
`impl<A, B, C, D, E, F, G, H, I, J, K> Default for (A, B, C, D, E, F, G, H, I, J, K) where
A: Default,
B: Default,
C: Default,
D: Default,
E: Default,
F: Default,
G: Default,
H: Default,
I: Default,
J: Default,
K: Default, `[src]
fn [default](../std/default/trait.Default.html#tymethod.default)() -> [(](primitive.tuple.html)A, B, C, D, E, F, G, H, I, J, K[)](primitive.tuple.html)[src]
Returns the "default value" for a type. Read more
`impl<A, B, C, D, E> Default for (A, B, C, D, E) where
A: Default,
B: Default,
C: Default,
D: Default,
E: Default, `[src]
`impl<A, B, C, D, E, F, G, H> Default for (A, B, C, D, E, F, G, H) where
A: Default,
B: Default,
C: Default,
D: Default,
E: Default,
F: Default,
G: Default,
H: Default, `[src]
`impl<A, B, C, D, E, F> PartialOrd<(A, B, C, D, E, F)> for (A, B, C, D, E, F) where
A: PartialEq + PartialOrd,
B: PartialEq + PartialOrd,
C: PartialEq + PartialOrd,
D: PartialEq + PartialOrd,
E: PartialEq + PartialOrd,
F: PartialEq + PartialOrd + ?Sized, `[src]
fn [partial_cmp](../std/cmp/trait.PartialOrd.html#tymethod.partial%5Fcmp)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F[)](primitive.tuple.html)) -> [Option](../std/option/enum.Option.html "enum std::option::Option")<[Ordering](../std/cmp/enum.Ordering.html "enum std::cmp::Ordering")>[src]
This method returns an ordering between self and other values if one exists. Read more
fn [lt](../std/cmp/trait.PartialOrd.html#method.lt)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests less than (for self and other) and is used by the < operator. Read more
fn [le](../std/cmp/trait.PartialOrd.html#method.le)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
fn [ge](../std/cmp/trait.PartialOrd.html#method.ge)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more
fn [gt](../std/cmp/trait.PartialOrd.html#method.gt)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests greater than (for self and other) and is used by the > operator. Read more
`impl<A, B, C, D, E, F, G, H> PartialOrd<(A, B, C, D, E, F, G, H)> for (A, B, C, D, E, F, G, H) where
A: PartialEq + PartialOrd,
B: PartialEq + PartialOrd,
C: PartialEq + PartialOrd,
D: PartialEq + PartialOrd,
E: PartialEq + PartialOrd,
F: PartialEq + PartialOrd,
G: PartialEq + PartialOrd,
H: PartialEq + PartialOrd + ?Sized, `[src]
fn [partial_cmp](../std/cmp/trait.PartialOrd.html#tymethod.partial%5Fcmp)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F, G, H[)](primitive.tuple.html)) -> [Option](../std/option/enum.Option.html "enum std::option::Option")<[Ordering](../std/cmp/enum.Ordering.html "enum std::cmp::Ordering")>[src]
This method returns an ordering between self and other values if one exists. Read more
fn [lt](../std/cmp/trait.PartialOrd.html#method.lt)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F, G, H[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests less than (for self and other) and is used by the < operator. Read more
fn [le](../std/cmp/trait.PartialOrd.html#method.le)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F, G, H[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
fn [ge](../std/cmp/trait.PartialOrd.html#method.ge)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F, G, H[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more
fn [gt](../std/cmp/trait.PartialOrd.html#method.gt)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F, G, H[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests greater than (for self and other) and is used by the > operator. Read more
`impl<A, B, C, D, E, F, G> PartialOrd<(A, B, C, D, E, F, G)> for (A, B, C, D, E, F, G) where
A: PartialEq + PartialOrd,
B: PartialEq + PartialOrd,
C: PartialEq + PartialOrd,
D: PartialEq + PartialOrd,
E: PartialEq + PartialOrd,
F: PartialEq + PartialOrd,
G: PartialEq + PartialOrd + ?Sized, `[src]
fn [partial_cmp](../std/cmp/trait.PartialOrd.html#tymethod.partial%5Fcmp)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F, G[)](primitive.tuple.html)) -> [Option](../std/option/enum.Option.html "enum std::option::Option")<[Ordering](../std/cmp/enum.Ordering.html "enum std::cmp::Ordering")>[src]
This method returns an ordering between self and other values if one exists. Read more
fn [lt](../std/cmp/trait.PartialOrd.html#method.lt)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F, G[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests less than (for self and other) and is used by the < operator. Read more
fn [le](../std/cmp/trait.PartialOrd.html#method.le)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F, G[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
fn [ge](../std/cmp/trait.PartialOrd.html#method.ge)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F, G[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more
fn [gt](../std/cmp/trait.PartialOrd.html#method.gt)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F, G[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests greater than (for self and other) and is used by the > operator. Read more
`impl<A, B> PartialOrd<(A, B)> for (A, B) where
A: PartialEq + PartialOrd,
B: PartialEq + PartialOrd + ?Sized, `[src]
fn [partial_cmp](../std/cmp/trait.PartialOrd.html#tymethod.partial%5Fcmp)(&self, other: &[(](primitive.tuple.html)A, B[)](primitive.tuple.html)) -> [Option](../std/option/enum.Option.html "enum std::option::Option")<[Ordering](../std/cmp/enum.Ordering.html "enum std::cmp::Ordering")>[src]
This method returns an ordering between self and other values if one exists. Read more
fn [lt](../std/cmp/trait.PartialOrd.html#method.lt)(&self, other: &[(](primitive.tuple.html)A, B[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests less than (for self and other) and is used by the < operator. Read more
fn [le](../std/cmp/trait.PartialOrd.html#method.le)(&self, other: &[(](primitive.tuple.html)A, B[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
fn [ge](../std/cmp/trait.PartialOrd.html#method.ge)(&self, other: &[(](primitive.tuple.html)A, B[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more
fn [gt](../std/cmp/trait.PartialOrd.html#method.gt)(&self, other: &[(](primitive.tuple.html)A, B[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests greater than (for self and other) and is used by the > operator. Read more
`impl<A, B, C, D, E> PartialOrd<(A, B, C, D, E)> for (A, B, C, D, E) where
A: PartialEq + PartialOrd,
B: PartialEq + PartialOrd,
C: PartialEq + PartialOrd,
D: PartialEq + PartialOrd,
E: PartialEq + PartialOrd + ?Sized, `[src]
fn [partial_cmp](../std/cmp/trait.PartialOrd.html#tymethod.partial%5Fcmp)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E[)](primitive.tuple.html)) -> [Option](../std/option/enum.Option.html "enum std::option::Option")<[Ordering](../std/cmp/enum.Ordering.html "enum std::cmp::Ordering")>[src]
This method returns an ordering between self and other values if one exists. Read more
fn [lt](../std/cmp/trait.PartialOrd.html#method.lt)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests less than (for self and other) and is used by the < operator. Read more
fn [le](../std/cmp/trait.PartialOrd.html#method.le)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
fn [ge](../std/cmp/trait.PartialOrd.html#method.ge)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more
fn [gt](../std/cmp/trait.PartialOrd.html#method.gt)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests greater than (for self and other) and is used by the > operator. Read more
`impl PartialOrd<(A,)> for (A,) where
A: PartialEq + PartialOrd + ?Sized, `[src]
fn [partial_cmp](../std/cmp/trait.PartialOrd.html#tymethod.partial%5Fcmp)(&self, other: &[(](primitive.tuple.html)A[,)](primitive.tuple.html)) -> [Option](../std/option/enum.Option.html "enum std::option::Option")<[Ordering](../std/cmp/enum.Ordering.html "enum std::cmp::Ordering")>[src]
This method returns an ordering between self and other values if one exists. Read more
fn [lt](../std/cmp/trait.PartialOrd.html#method.lt)(&self, other: &[(](primitive.tuple.html)A[,)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests less than (for self and other) and is used by the < operator. Read more
fn [le](../std/cmp/trait.PartialOrd.html#method.le)(&self, other: &[(](primitive.tuple.html)A[,)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
fn [ge](../std/cmp/trait.PartialOrd.html#method.ge)(&self, other: &[(](primitive.tuple.html)A[,)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more
fn [gt](../std/cmp/trait.PartialOrd.html#method.gt)(&self, other: &[(](primitive.tuple.html)A[,)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests greater than (for self and other) and is used by the > operator. Read more
`impl<A, B, C, D, E, F, G, H, I, J> PartialOrd<(A, B, C, D, E, F, G, H, I, J)> for (A, B, C, D, E, F, G, H, I, J) where
A: PartialEq + PartialOrd,
B: PartialEq + PartialOrd,
C: PartialEq + PartialOrd,
D: PartialEq + PartialOrd,
E: PartialEq + PartialOrd,
F: PartialEq + PartialOrd,
G: PartialEq + PartialOrd,
H: PartialEq + PartialOrd,
I: PartialEq + PartialOrd,
J: PartialEq + PartialOrd + ?Sized, `[src]
`fn partial_cmp(
&self,
other: &(A, B, C, D, E, F, G, H, I, J)
) -> Option<Ordering>`[src]
This method returns an ordering between self and other values if one exists. Read more
fn [lt](../std/cmp/trait.PartialOrd.html#method.lt)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F, G, H, I, J[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests less than (for self and other) and is used by the < operator. Read more
fn [le](../std/cmp/trait.PartialOrd.html#method.le)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F, G, H, I, J[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
fn [ge](../std/cmp/trait.PartialOrd.html#method.ge)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F, G, H, I, J[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more
fn [gt](../std/cmp/trait.PartialOrd.html#method.gt)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F, G, H, I, J[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests greater than (for self and other) and is used by the > operator. Read more
`impl<A, B, C, D, E, F, G, H, I, J, K> PartialOrd<(A, B, C, D, E, F, G, H, I, J, K)> for (A, B, C, D, E, F, G, H, I, J, K) where
A: PartialEq + PartialOrd,
B: PartialEq + PartialOrd,
C: PartialEq + PartialOrd,
D: PartialEq + PartialOrd,
E: PartialEq + PartialOrd,
F: PartialEq + PartialOrd,
G: PartialEq + PartialOrd,
H: PartialEq + PartialOrd,
I: PartialEq + PartialOrd,
J: PartialEq + PartialOrd,
K: PartialEq + PartialOrd + ?Sized, `[src]
`fn partial_cmp(
&self,
other: &(A, B, C, D, E, F, G, H, I, J, K)
) -> Option<Ordering>`[src]
This method returns an ordering between self and other values if one exists. Read more
fn [lt](../std/cmp/trait.PartialOrd.html#method.lt)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F, G, H, I, J, K[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests less than (for self and other) and is used by the < operator. Read more
fn [le](../std/cmp/trait.PartialOrd.html#method.le)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F, G, H, I, J, K[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
fn [ge](../std/cmp/trait.PartialOrd.html#method.ge)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F, G, H, I, J, K[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more
fn [gt](../std/cmp/trait.PartialOrd.html#method.gt)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F, G, H, I, J, K[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests greater than (for self and other) and is used by the > operator. Read more
`impl<A, B, C, D, E, F, G, H, I> PartialOrd<(A, B, C, D, E, F, G, H, I)> for (A, B, C, D, E, F, G, H, I) where
A: PartialEq + PartialOrd,
B: PartialEq + PartialOrd,
C: PartialEq + PartialOrd,
D: PartialEq + PartialOrd,
E: PartialEq + PartialOrd,
F: PartialEq + PartialOrd,
G: PartialEq + PartialOrd,
H: PartialEq + PartialOrd,
I: PartialEq + PartialOrd + ?Sized, `[src]
fn [partial_cmp](../std/cmp/trait.PartialOrd.html#tymethod.partial%5Fcmp)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F, G, H, I[)](primitive.tuple.html)) -> [Option](../std/option/enum.Option.html "enum std::option::Option")<[Ordering](../std/cmp/enum.Ordering.html "enum std::cmp::Ordering")>[src]
This method returns an ordering between self and other values if one exists. Read more
fn [lt](../std/cmp/trait.PartialOrd.html#method.lt)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F, G, H, I[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests less than (for self and other) and is used by the < operator. Read more
fn [le](../std/cmp/trait.PartialOrd.html#method.le)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F, G, H, I[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
fn [ge](../std/cmp/trait.PartialOrd.html#method.ge)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F, G, H, I[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more
fn [gt](../std/cmp/trait.PartialOrd.html#method.gt)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F, G, H, I[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests greater than (for self and other) and is used by the > operator. Read more
`impl<A, B, C, D> PartialOrd<(A, B, C, D)> for (A, B, C, D) where
A: PartialEq + PartialOrd,
B: PartialEq + PartialOrd,
C: PartialEq + PartialOrd,
D: PartialEq + PartialOrd + ?Sized, `[src]
fn [partial_cmp](../std/cmp/trait.PartialOrd.html#tymethod.partial%5Fcmp)(&self, other: &[(](primitive.tuple.html)A, B, C, D[)](primitive.tuple.html)) -> [Option](../std/option/enum.Option.html "enum std::option::Option")<[Ordering](../std/cmp/enum.Ordering.html "enum std::cmp::Ordering")>[src]
This method returns an ordering between self and other values if one exists. Read more
fn [lt](../std/cmp/trait.PartialOrd.html#method.lt)(&self, other: &[(](primitive.tuple.html)A, B, C, D[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests less than (for self and other) and is used by the < operator. Read more
fn [le](../std/cmp/trait.PartialOrd.html#method.le)(&self, other: &[(](primitive.tuple.html)A, B, C, D[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
fn [ge](../std/cmp/trait.PartialOrd.html#method.ge)(&self, other: &[(](primitive.tuple.html)A, B, C, D[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more
fn [gt](../std/cmp/trait.PartialOrd.html#method.gt)(&self, other: &[(](primitive.tuple.html)A, B, C, D[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests greater than (for self and other) and is used by the > operator. Read more
`impl<A, B, C, D, E, F, G, H, I, J, K, L> PartialOrd<(A, B, C, D, E, F, G, H, I, J, K, L)> for (A, B, C, D, E, F, G, H, I, J, K, L) where
A: PartialEq + PartialOrd,
B: PartialEq + PartialOrd,
C: PartialEq + PartialOrd,
D: PartialEq + PartialOrd,
E: PartialEq + PartialOrd,
F: PartialEq + PartialOrd,
G: PartialEq + PartialOrd,
H: PartialEq + PartialOrd,
I: PartialEq + PartialOrd,
J: PartialEq + PartialOrd,
K: PartialEq + PartialOrd,
L: PartialEq + PartialOrd + ?Sized, `[src]
`fn partial_cmp(
&self,
other: &(A, B, C, D, E, F, G, H, I, J, K, L)
) -> Option<Ordering>`[src]
This method returns an ordering between self and other values if one exists. Read more
fn [lt](../std/cmp/trait.PartialOrd.html#method.lt)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F, G, H, I, J, K, L[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests less than (for self and other) and is used by the < operator. Read more
fn [le](../std/cmp/trait.PartialOrd.html#method.le)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F, G, H, I, J, K, L[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
fn [ge](../std/cmp/trait.PartialOrd.html#method.ge)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F, G, H, I, J, K, L[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more
fn [gt](../std/cmp/trait.PartialOrd.html#method.gt)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F, G, H, I, J, K, L[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests greater than (for self and other) and is used by the > operator. Read more
`impl<A, B, C> PartialOrd<(A, B, C)> for (A, B, C) where
A: PartialEq + PartialOrd,
B: PartialEq + PartialOrd,
C: PartialEq + PartialOrd + ?Sized, `[src]
fn [partial_cmp](../std/cmp/trait.PartialOrd.html#tymethod.partial%5Fcmp)(&self, other: &[(](primitive.tuple.html)A, B, C[)](primitive.tuple.html)) -> [Option](../std/option/enum.Option.html "enum std::option::Option")<[Ordering](../std/cmp/enum.Ordering.html "enum std::cmp::Ordering")>[src]
This method returns an ordering between self and other values if one exists. Read more
fn [lt](../std/cmp/trait.PartialOrd.html#method.lt)(&self, other: &[(](primitive.tuple.html)A, B, C[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests less than (for self and other) and is used by the < operator. Read more
fn [le](../std/cmp/trait.PartialOrd.html#method.le)(&self, other: &[(](primitive.tuple.html)A, B, C[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
fn [ge](../std/cmp/trait.PartialOrd.html#method.ge)(&self, other: &[(](primitive.tuple.html)A, B, C[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more
fn [gt](../std/cmp/trait.PartialOrd.html#method.gt)(&self, other: &[(](primitive.tuple.html)A, B, C[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests greater than (for self and other) and is used by the > operator. Read more
`impl<A, B, C, D, E, F, G, H, I, J, K, L> Ord for (A, B, C, D, E, F, G, H, I, J, K, L) where
A: Ord,
B: Ord,
C: Ord,
D: Ord,
E: Ord,
F: Ord,
G: Ord,
H: Ord,
I: Ord,
J: Ord,
K: Ord,
L: Ord + ?Sized, `[src]
fn [cmp](../std/cmp/trait.Ord.html#tymethod.cmp)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F, G, H, I, J, K, L[)](primitive.tuple.html)) -> [Ordering](../std/cmp/enum.Ordering.html "enum std::cmp::Ordering")[src]
This method returns an Ordering between self and other. Read more
fn [max](../std/cmp/trait.Ord.html#method.max)(self, other: Self) -> Self
1.21.0
Compares and returns the maximum of two values. Read more
fn [min](../std/cmp/trait.Ord.html#method.min)(self, other: Self) -> Self
1.21.0
Compares and returns the minimum of two values. Read more
`impl<A, B, C, D> Ord for (A, B, C, D) where
A: Ord,
B: Ord,
C: Ord,
D: Ord + ?Sized, `[src]
fn [cmp](../std/cmp/trait.Ord.html#tymethod.cmp)(&self, other: &[(](primitive.tuple.html)A, B, C, D[)](primitive.tuple.html)) -> [Ordering](../std/cmp/enum.Ordering.html "enum std::cmp::Ordering")[src]
This method returns an Ordering between self and other. Read more
fn [max](../std/cmp/trait.Ord.html#method.max)(self, other: Self) -> Self
1.21.0
Compares and returns the maximum of two values. Read more
fn [min](../std/cmp/trait.Ord.html#method.min)(self, other: Self) -> Self
1.21.0
Compares and returns the minimum of two values. Read more
`impl<A, B, C> Ord for (A, B, C) where
A: Ord,
B: Ord,
C: Ord + ?Sized, `[src]
fn [cmp](../std/cmp/trait.Ord.html#tymethod.cmp)(&self, other: &[(](primitive.tuple.html)A, B, C[)](primitive.tuple.html)) -> [Ordering](../std/cmp/enum.Ordering.html "enum std::cmp::Ordering")[src]
This method returns an Ordering between self and other. Read more
fn [max](../std/cmp/trait.Ord.html#method.max)(self, other: Self) -> Self
1.21.0
Compares and returns the maximum of two values. Read more
fn [min](../std/cmp/trait.Ord.html#method.min)(self, other: Self) -> Self
1.21.0
Compares and returns the minimum of two values. Read more
`impl<A, B, C, D, E, F, G, H> Ord for (A, B, C, D, E, F, G, H) where
A: Ord,
B: Ord,
C: Ord,
D: Ord,
E: Ord,
F: Ord,
G: Ord,
H: Ord + ?Sized, `[src]
fn [cmp](../std/cmp/trait.Ord.html#tymethod.cmp)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F, G, H[)](primitive.tuple.html)) -> [Ordering](../std/cmp/enum.Ordering.html "enum std::cmp::Ordering")[src]
This method returns an Ordering between self and other. Read more
fn [max](../std/cmp/trait.Ord.html#method.max)(self, other: Self) -> Self
1.21.0
Compares and returns the maximum of two values. Read more
fn [min](../std/cmp/trait.Ord.html#method.min)(self, other: Self) -> Self
1.21.0
Compares and returns the minimum of two values. Read more
`impl<A, B, C, D, E, F> Ord for (A, B, C, D, E, F) where
A: Ord,
B: Ord,
C: Ord,
D: Ord,
E: Ord,
F: Ord + ?Sized, `[src]
fn [cmp](../std/cmp/trait.Ord.html#tymethod.cmp)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F[)](primitive.tuple.html)) -> [Ordering](../std/cmp/enum.Ordering.html "enum std::cmp::Ordering")[src]
This method returns an Ordering between self and other. Read more
fn [max](../std/cmp/trait.Ord.html#method.max)(self, other: Self) -> Self
1.21.0
Compares and returns the maximum of two values. Read more
fn [min](../std/cmp/trait.Ord.html#method.min)(self, other: Self) -> Self
1.21.0
Compares and returns the minimum of two values. Read more
`impl<A, B, C, D, E, F, G, H, I, J> Ord for (A, B, C, D, E, F, G, H, I, J) where
A: Ord,
B: Ord,
C: Ord,
D: Ord,
E: Ord,
F: Ord,
G: Ord,
H: Ord,
I: Ord,
J: Ord + ?Sized, `[src]
fn [cmp](../std/cmp/trait.Ord.html#tymethod.cmp)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F, G, H, I, J[)](primitive.tuple.html)) -> [Ordering](../std/cmp/enum.Ordering.html "enum std::cmp::Ordering")[src]
This method returns an Ordering between self and other. Read more
fn [max](../std/cmp/trait.Ord.html#method.max)(self, other: Self) -> Self
1.21.0
Compares and returns the maximum of two values. Read more
fn [min](../std/cmp/trait.Ord.html#method.min)(self, other: Self) -> Self
1.21.0
Compares and returns the minimum of two values. Read more
`impl<A, B, C, D, E, F, G> Ord for (A, B, C, D, E, F, G) where
A: Ord,
B: Ord,
C: Ord,
D: Ord,
E: Ord,
F: Ord,
G: Ord + ?Sized, `[src]
fn [cmp](../std/cmp/trait.Ord.html#tymethod.cmp)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F, G[)](primitive.tuple.html)) -> [Ordering](../std/cmp/enum.Ordering.html "enum std::cmp::Ordering")[src]
This method returns an Ordering between self and other. Read more
fn [max](../std/cmp/trait.Ord.html#method.max)(self, other: Self) -> Self
1.21.0
Compares and returns the maximum of two values. Read more
fn [min](../std/cmp/trait.Ord.html#method.min)(self, other: Self) -> Self
1.21.0
Compares and returns the minimum of two values. Read more
`impl<A, B> Ord for (A, B) where
A: Ord,
B: Ord + ?Sized, `[src]
fn [cmp](../std/cmp/trait.Ord.html#tymethod.cmp)(&self, other: &[(](primitive.tuple.html)A, B[)](primitive.tuple.html)) -> [Ordering](../std/cmp/enum.Ordering.html "enum std::cmp::Ordering")[src]
This method returns an Ordering between self and other. Read more
fn [max](../std/cmp/trait.Ord.html#method.max)(self, other: Self) -> Self
1.21.0
Compares and returns the maximum of two values. Read more
fn [min](../std/cmp/trait.Ord.html#method.min)(self, other: Self) -> Self
1.21.0
Compares and returns the minimum of two values. Read more
`impl<A, B, C, D, E, F, G, H, I, J, K> Ord for (A, B, C, D, E, F, G, H, I, J, K) where
A: Ord,
B: Ord,
C: Ord,
D: Ord,
E: Ord,
F: Ord,
G: Ord,
H: Ord,
I: Ord,
J: Ord,
K: Ord + ?Sized, `[src]
fn [cmp](../std/cmp/trait.Ord.html#tymethod.cmp)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F, G, H, I, J, K[)](primitive.tuple.html)) -> [Ordering](../std/cmp/enum.Ordering.html "enum std::cmp::Ordering")[src]
This method returns an Ordering between self and other. Read more
fn [max](../std/cmp/trait.Ord.html#method.max)(self, other: Self) -> Self
1.21.0
Compares and returns the maximum of two values. Read more
fn [min](../std/cmp/trait.Ord.html#method.min)(self, other: Self) -> Self
1.21.0
Compares and returns the minimum of two values. Read more
`impl<A, B, C, D, E> Ord for (A, B, C, D, E) where
A: Ord,
B: Ord,
C: Ord,
D: Ord,
E: Ord + ?Sized, `[src]
fn [cmp](../std/cmp/trait.Ord.html#tymethod.cmp)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E[)](primitive.tuple.html)) -> [Ordering](../std/cmp/enum.Ordering.html "enum std::cmp::Ordering")[src]
This method returns an Ordering between self and other. Read more
fn [max](../std/cmp/trait.Ord.html#method.max)(self, other: Self) -> Self
1.21.0
Compares and returns the maximum of two values. Read more
fn [min](../std/cmp/trait.Ord.html#method.min)(self, other: Self) -> Self
1.21.0
Compares and returns the minimum of two values. Read more
`impl Ord for (A,) where
fn [cmp](../std/cmp/trait.Ord.html#tymethod.cmp)(&self, other: &[(](primitive.tuple.html)A[,)](primitive.tuple.html)) -> [Ordering](../std/cmp/enum.Ordering.html "enum std::cmp::Ordering")[src]
This method returns an Ordering between self and other. Read more
fn [max](../std/cmp/trait.Ord.html#method.max)(self, other: Self) -> Self
1.21.0
Compares and returns the maximum of two values. Read more
fn [min](../std/cmp/trait.Ord.html#method.min)(self, other: Self) -> Self
1.21.0
Compares and returns the minimum of two values. Read more
`impl<A, B, C, D, E, F, G, H, I> Ord for (A, B, C, D, E, F, G, H, I) where
A: Ord,
B: Ord,
C: Ord,
D: Ord,
E: Ord,
F: Ord,
G: Ord,
H: Ord,
I: Ord + ?Sized, `[src]
fn [cmp](../std/cmp/trait.Ord.html#tymethod.cmp)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F, G, H, I[)](primitive.tuple.html)) -> [Ordering](../std/cmp/enum.Ordering.html "enum std::cmp::Ordering")[src]
This method returns an Ordering between self and other. Read more
fn [max](../std/cmp/trait.Ord.html#method.max)(self, other: Self) -> Self
1.21.0
Compares and returns the maximum of two values. Read more
fn [min](../std/cmp/trait.Ord.html#method.min)(self, other: Self) -> Self
1.21.0
Compares and returns the minimum of two values. Read more
`impl<A, B> Eq for (A, B) where
`impl<A, B, C, D, E, F, G, H, I, J, K> Eq for (A, B, C, D, E, F, G, H, I, J, K) where
A: Eq,
B: Eq,
C: Eq,
D: Eq,
E: Eq,
F: Eq,
G: Eq,
H: Eq,
I: Eq,
J: Eq,
K: Eq + ?Sized, `[src]
`impl<A, B, C, D> Eq for (A, B, C, D) where
A: Eq,
B: Eq,
C: Eq,
D: Eq + ?Sized, `[src]
`impl<A, B, C, D, E> Eq for (A, B, C, D, E) where
A: Eq,
B: Eq,
C: Eq,
D: Eq,
E: Eq + ?Sized, `[src]
`impl<A, B, C, D, E, F> Eq for (A, B, C, D, E, F) where
A: Eq,
B: Eq,
C: Eq,
D: Eq,
E: Eq,
F: Eq + ?Sized, `[src]
`impl<A, B, C, D, E, F, G> Eq for (A, B, C, D, E, F, G) where
A: Eq,
B: Eq,
C: Eq,
D: Eq,
E: Eq,
F: Eq,
G: Eq + ?Sized, `[src]
`impl<A, B, C, D, E, F, G, H, I> Eq for (A, B, C, D, E, F, G, H, I) where
A: Eq,
B: Eq,
C: Eq,
D: Eq,
E: Eq,
F: Eq,
G: Eq,
H: Eq,
I: Eq + ?Sized, `[src]
`impl<A, B, C, D, E, F, G, H, I, J, K, L> Eq for (A, B, C, D, E, F, G, H, I, J, K, L) where
A: Eq,
B: Eq,
C: Eq,
D: Eq,
E: Eq,
F: Eq,
G: Eq,
H: Eq,
I: Eq,
J: Eq,
K: Eq,
L: Eq + ?Sized, `[src]
`impl<A, B, C, D, E, F, G, H> Eq for (A, B, C, D, E, F, G, H) where
A: Eq,
B: Eq,
C: Eq,
D: Eq,
E: Eq,
F: Eq,
G: Eq,
H: Eq + ?Sized, `[src]
`impl<A, B, C> Eq for (A, B, C) where
A: Eq,
B: Eq,
C: Eq + ?Sized, `[src]
`impl Eq for (A,) where
`impl<A, B, C, D, E, F, G, H, I, J> Eq for (A, B, C, D, E, F, G, H, I, J) where
A: Eq,
B: Eq,
C: Eq,
D: Eq,
E: Eq,
F: Eq,
G: Eq,
H: Eq,
I: Eq,
J: Eq + ?Sized, `[src]
`impl<A, B, C, D, E> PartialEq<(A, B, C, D, E)> for (A, B, C, D, E) where
A: PartialEq,
B: PartialEq,
C: PartialEq,
D: PartialEq,
E: PartialEq + ?Sized, `[src]
fn [eq](../std/cmp/trait.PartialEq.html#tymethod.eq)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests for self and other values to be equal, and is used by ==. Read more
fn [ne](../std/cmp/trait.PartialEq.html#method.ne)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests for !=.
`impl<A, B, C, D, E, F, G> PartialEq<(A, B, C, D, E, F, G)> for (A, B, C, D, E, F, G) where
A: PartialEq,
B: PartialEq,
C: PartialEq,
D: PartialEq,
E: PartialEq,
F: PartialEq,
G: PartialEq + ?Sized, `[src]
fn [eq](../std/cmp/trait.PartialEq.html#tymethod.eq)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F, G[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests for self and other values to be equal, and is used by ==. Read more
fn [ne](../std/cmp/trait.PartialEq.html#method.ne)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F, G[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests for !=.
`impl<A, B, C, D, E, F, G, H, I, J, K> PartialEq<(A, B, C, D, E, F, G, H, I, J, K)> for (A, B, C, D, E, F, G, H, I, J, K) where
A: PartialEq,
B: PartialEq,
C: PartialEq,
D: PartialEq,
E: PartialEq,
F: PartialEq,
G: PartialEq,
H: PartialEq,
I: PartialEq,
J: PartialEq,
K: PartialEq + ?Sized, `[src]
fn [eq](../std/cmp/trait.PartialEq.html#tymethod.eq)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F, G, H, I, J, K[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests for self and other values to be equal, and is used by ==. Read more
fn [ne](../std/cmp/trait.PartialEq.html#method.ne)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F, G, H, I, J, K[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests for !=.
`impl<A, B, C, D, E, F, G, H, I, J, K, L> PartialEq<(A, B, C, D, E, F, G, H, I, J, K, L)> for (A, B, C, D, E, F, G, H, I, J, K, L) where
A: PartialEq,
B: PartialEq,
C: PartialEq,
D: PartialEq,
E: PartialEq,
F: PartialEq,
G: PartialEq,
H: PartialEq,
I: PartialEq,
J: PartialEq,
K: PartialEq,
L: PartialEq + ?Sized, `[src]
fn [eq](../std/cmp/trait.PartialEq.html#tymethod.eq)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F, G, H, I, J, K, L[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests for self and other values to be equal, and is used by ==. Read more
fn [ne](../std/cmp/trait.PartialEq.html#method.ne)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F, G, H, I, J, K, L[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests for !=.
`impl<A, B, C, D, E, F, G, H, I> PartialEq<(A, B, C, D, E, F, G, H, I)> for (A, B, C, D, E, F, G, H, I) where
A: PartialEq,
B: PartialEq,
C: PartialEq,
D: PartialEq,
E: PartialEq,
F: PartialEq,
G: PartialEq,
H: PartialEq,
I: PartialEq + ?Sized, `[src]
fn [eq](../std/cmp/trait.PartialEq.html#tymethod.eq)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F, G, H, I[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests for self and other values to be equal, and is used by ==. Read more
fn [ne](../std/cmp/trait.PartialEq.html#method.ne)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F, G, H, I[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests for !=.
`impl<A, B, C> PartialEq<(A, B, C)> for (A, B, C) where
A: PartialEq,
B: PartialEq,
C: PartialEq + ?Sized, `[src]
fn [eq](../std/cmp/trait.PartialEq.html#tymethod.eq)(&self, other: &[(](primitive.tuple.html)A, B, C[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests for self and other values to be equal, and is used by ==. Read more
fn [ne](../std/cmp/trait.PartialEq.html#method.ne)(&self, other: &[(](primitive.tuple.html)A, B, C[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests for !=.
`impl<A, B, C, D, E, F, G, H> PartialEq<(A, B, C, D, E, F, G, H)> for (A, B, C, D, E, F, G, H) where
A: PartialEq,
B: PartialEq,
C: PartialEq,
D: PartialEq,
E: PartialEq,
F: PartialEq,
G: PartialEq,
H: PartialEq + ?Sized, `[src]
fn [eq](../std/cmp/trait.PartialEq.html#tymethod.eq)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F, G, H[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests for self and other values to be equal, and is used by ==. Read more
fn [ne](../std/cmp/trait.PartialEq.html#method.ne)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F, G, H[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests for !=.
`impl<A, B, C, D, E, F, G, H, I, J> PartialEq<(A, B, C, D, E, F, G, H, I, J)> for (A, B, C, D, E, F, G, H, I, J) where
A: PartialEq,
B: PartialEq,
C: PartialEq,
D: PartialEq,
E: PartialEq,
F: PartialEq,
G: PartialEq,
H: PartialEq,
I: PartialEq,
J: PartialEq + ?Sized, `[src]
fn [eq](../std/cmp/trait.PartialEq.html#tymethod.eq)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F, G, H, I, J[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests for self and other values to be equal, and is used by ==. Read more
fn [ne](../std/cmp/trait.PartialEq.html#method.ne)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F, G, H, I, J[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests for !=.
`impl<A, B, C, D> PartialEq<(A, B, C, D)> for (A, B, C, D) where
A: PartialEq,
B: PartialEq,
C: PartialEq,
D: PartialEq + ?Sized, `[src]
fn [eq](../std/cmp/trait.PartialEq.html#tymethod.eq)(&self, other: &[(](primitive.tuple.html)A, B, C, D[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests for self and other values to be equal, and is used by ==. Read more
fn [ne](../std/cmp/trait.PartialEq.html#method.ne)(&self, other: &[(](primitive.tuple.html)A, B, C, D[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests for !=.
`impl<A, B> PartialEq<(A, B)> for (A, B) where
A: PartialEq,
B: PartialEq + ?Sized, `[src]
fn [eq](../std/cmp/trait.PartialEq.html#tymethod.eq)(&self, other: &[(](primitive.tuple.html)A, B[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests for self and other values to be equal, and is used by ==. Read more
fn [ne](../std/cmp/trait.PartialEq.html#method.ne)(&self, other: &[(](primitive.tuple.html)A, B[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests for !=.
`impl<A, B, C, D, E, F> PartialEq<(A, B, C, D, E, F)> for (A, B, C, D, E, F) where
A: PartialEq,
B: PartialEq,
C: PartialEq,
D: PartialEq,
E: PartialEq,
F: PartialEq + ?Sized, `[src]
fn [eq](../std/cmp/trait.PartialEq.html#tymethod.eq)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests for self and other values to be equal, and is used by ==. Read more
fn [ne](../std/cmp/trait.PartialEq.html#method.ne)(&self, other: &[(](primitive.tuple.html)A, B, C, D, E, F[)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests for !=.
`impl PartialEq<(A,)> for (A,) where
fn [eq](../std/cmp/trait.PartialEq.html#tymethod.eq)(&self, other: &[(](primitive.tuple.html)A[,)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests for self and other values to be equal, and is used by ==. Read more
fn [ne](../std/cmp/trait.PartialEq.html#method.ne)(&self, other: &[(](primitive.tuple.html)A[,)](primitive.tuple.html)) -> [bool](primitive.bool.html)[src]
This method tests for !=.
`impl<'a, T> RangeArgument for (Bound<&'a T>, Bound<&'a T>) where
fn [start](../std/collections/range/trait.RangeArgument.html#tymethod.start)(&self) -> [Bound](../std/collections/enum.Bound.html "enum std::collections::Bound")<[&](primitive.reference.html)T>[src]
🔬 This is a nightly-only experimental API. (collections_range #30877)
waiting for dust to settle on inclusive ranges
fn [end](../std/collections/range/trait.RangeArgument.html#tymethod.end)(&self) -> [Bound](../std/collections/enum.Bound.html "enum std::collections::Bound")<[&](primitive.reference.html)T>[src]
🔬 This is a nightly-only experimental API. (collections_range #30877)
waiting for dust to settle on inclusive ranges
impl<T> [RangeArgument](../std/collections/range/trait.RangeArgument.html "trait std::collections::range::RangeArgument")<T> for [(](primitive.tuple.html)[Bound](../std/collections/enum.Bound.html "enum std::collections::Bound")<T>, [Bound](../std/collections/enum.Bound.html "enum std::collections::Bound")<T>[)](primitive.tuple.html)[src]
fn [start](../std/collections/range/trait.RangeArgument.html#tymethod.start)(&self) -> [Bound](../std/collections/enum.Bound.html "enum std::collections::Bound")<[&](primitive.reference.html)T>[src]
🔬 This is a nightly-only experimental API. (collections_range #30877)
waiting for dust to settle on inclusive ranges
fn [end](../std/collections/range/trait.RangeArgument.html#tymethod.end)(&self) -> [Bound](../std/collections/enum.Bound.html "enum std::collections::Bound")<[&](primitive.reference.html)T>[src]
🔬 This is a nightly-only experimental API. (collections_range #30877)
waiting for dust to settle on inclusive ranges