Trait core::cmp::PartialEq1.0.0 [−] [src]

```#[lang = "eq"]
pub trait PartialEq<Rhs: ?Sized = Self> {
fn eq(&self, other: &Rhs) -> bool;

fn ne(&self, other: &Rhs) -> bool { ... }
}```

Trait for equality comparisons which are partial equivalence relations.

This trait allows for partial equality, for types that do not have a full equivalence relation. For example, in floating point numbers `NaN != NaN`, so floating point types implement `PartialEq` but not `Eq`.

Formally, the equality must be (for all `a`, `b` and `c`):

• symmetric: `a == b` implies `b == a`; and
• transitive: `a == b` and `b == c` implies `a == c`.

Note that these requirements mean that the trait itself must be implemented symmetrically and transitively: if `T: PartialEq<U>` and `U: PartialEq<V>` then `U: PartialEq<T>` and `T: PartialEq<V>`.

Derivable

This trait can be used with `#[derive]`. When `derive`d on structs, two instances are equal if all fields are equal, and not equal if any fields are not equal. When `derive`d on enums, each variant is equal to itself and not equal to the other variants.

How can I implement `PartialEq`?

PartialEq only requires the `eq` method to be implemented; `ne` is defined in terms of it by default. Any manual implementation of `ne` must respect the rule that `eq` is a strict inverse of `ne`; that is, `!(a == b)` if and only if `a != b`.

Implementations of `PartialEq`, `PartialOrd`, and `Ord` must agree with each other. It's easy to accidentally make them disagree by deriving some of the traits and manually implementing others.

An example implementation for a domain in which two books are considered the same book if their ISBN matches, even if the formats differ:

```enum BookFormat { Paperback, Hardback, Ebook }
struct Book {
isbn: i32,
format: BookFormat,
}

impl PartialEq for Book {
fn eq(&self, other: &Book) -> bool {
self.isbn == other.isbn
}
}

let b1 = Book { isbn: 3, format: BookFormat::Paperback };
let b2 = Book { isbn: 3, format: BookFormat::Ebook };
let b3 = Book { isbn: 10, format: BookFormat::Paperback };

assert!(b1 == b2);
assert!(b1 != b3);Run```

Examples

```let x: u32 = 0;
let y: u32 = 1;

assert_eq!(x == y, false);
assert_eq!(x.eq(&y), false);Run```

Required Methods

`fn eq(&self, other: &Rhs) -> bool`

This method tests for `self` and `other` values to be equal, and is used by `==`.

Provided Methods

`fn ne(&self, other: &Rhs) -> bool`

This method tests for `!=`.

Implementors

• `impl PartialEq for ParseFloatError`
• `impl<T: PartialEq> PartialEq for Wrapping<T>`
• `impl PartialEq for FpCategory`
• `impl PartialEq for ParseIntError`
• `impl<T> PartialEq for Discriminant<T>`
• `impl<T: PartialEq> PartialEq for ManuallyDrop<T>`
• `impl<T: PartialEq + Zeroable> PartialEq for NonZero<T>`
• `impl<T: ?Sized> PartialEq for *const T`
• `impl<T: ?Sized> PartialEq for *mut T`
• `impl<Ret> PartialEq for fn() -> Ret`
• `impl<Ret> PartialEq for extern "C" fn() -> Ret`
• `impl<Ret> PartialEq for unsafe fn() -> Ret`
• `impl<Ret> PartialEq for unsafe extern "C" fn() -> Ret`
• `impl<Ret, A> PartialEq for fn(_: A) -> Ret`
• `impl<Ret, A> PartialEq for extern "C" fn(_: A) -> Ret`
• `impl<Ret, A> PartialEq for extern "C" fn(_: A, ...) -> Ret`
• `impl<Ret, A> PartialEq for unsafe fn(_: A) -> Ret`
• `impl<Ret, A> PartialEq for unsafe extern "C" fn(_: A) -> Ret`
• `impl<Ret, A> PartialEq for unsafe extern "C" fn(_: A, ...) -> Ret`
• `impl<Ret, A, B> PartialEq for fn(_: A, _: B) -> Ret`
• `impl<Ret, A, B> PartialEq for extern "C" fn(_: A, _: B) -> Ret`
• `impl<Ret, A, B> PartialEq for extern "C" fn(_: A, _: B, ...) -> Ret`
• `impl<Ret, A, B> PartialEq for unsafe fn(_: A, _: B) -> Ret`
• `impl<Ret, A, B> PartialEq for unsafe extern "C" fn(_: A, _: B) -> Ret`
• `impl<Ret, A, B> PartialEq for unsafe extern "C" fn(_: A, _: B, ...) -> Ret`
• `impl<Ret, A, B, C> PartialEq for fn(_: A, _: B, _: C) -> Ret`
• `impl<Ret, A, B, C> PartialEq for extern "C" fn(_: A, _: B, _: C) -> Ret`
• `impl<Ret, A, B, C> PartialEq for extern "C" fn(_: A, _: B, _: C, ...) -> Ret`
• `impl<Ret, A, B, C> PartialEq for unsafe fn(_: A, _: B, _: C) -> Ret`
• `impl<Ret, A, B, C> PartialEq for unsafe extern "C" fn(_: A, _: B, _: C) -> Ret`
• `impl<Ret, A, B, C> PartialEq for unsafe extern "C" fn(_: A, _: B, _: C, ...) -> Ret`
• `impl<Ret, A, B, C, D> PartialEq for fn(_: A, _: B, _: C, _: D) -> Ret`
• `impl<Ret, A, B, C, D> PartialEq for extern "C" fn(_: A, _: B, _: C, _: D) -> Ret`
• `impl<Ret, A, B, C, D> PartialEq for extern "C" fn(_: A, _: B, _: C, _: D, ...) -> Ret`
• `impl<Ret, A, B, C, D> PartialEq for unsafe fn(_: A, _: B, _: C, _: D) -> Ret`
• `impl<Ret, A, B, C, D> PartialEq for unsafe extern "C" fn(_: A, _: B, _: C, _: D) -> Ret`
• `impl<Ret, A, B, C, D> PartialEq for unsafe extern "C" fn(_: A, _: B, _: C, _: D, ...) -> Ret`
• `impl<Ret, A, B, C, D, E> PartialEq for fn(_: A, _: B, _: C, _: D, _: E) -> Ret`
• `impl<Ret, A, B, C, D, E> PartialEq for extern "C" fn(_: A, _: B, _: C, _: D, _: E) -> Ret`
• `impl<Ret, A, B, C, D, E> PartialEq for extern "C" fn(_: A, _: B, _: C, _: D, _: E, ...) -> Ret`
• `impl<Ret, A, B, C, D, E> PartialEq for unsafe fn(_: A, _: B, _: C, _: D, _: E) -> Ret`
• `impl<Ret, A, B, C, D, E> PartialEq for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E) -> Ret`
• `impl<Ret, A, B, C, D, E> PartialEq for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, ...) -> Ret`
• `impl<Ret, A, B, C, D, E, F> PartialEq for fn(_: A, _: B, _: C, _: D, _: E, _: F) -> Ret`
• `impl<Ret, A, B, C, D, E, F> PartialEq for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F) -> Ret`
• `impl<Ret, A, B, C, D, E, F> PartialEq for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, ...) -> Ret`
• `impl<Ret, A, B, C, D, E, F> PartialEq for unsafe fn(_: A, _: B, _: C, _: D, _: E, _: F) -> Ret`
• `impl<Ret, A, B, C, D, E, F> PartialEq for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F) -> Ret`
• `impl<Ret, A, B, C, D, E, F> PartialEq for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, ...) -> Ret`
• `impl<Ret, A, B, C, D, E, F, G> PartialEq for fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G) -> Ret`
• `impl<Ret, A, B, C, D, E, F, G> PartialEq for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G) -> Ret`
• `impl<Ret, A, B, C, D, E, F, G> PartialEq for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, ...) -> Ret`
• `impl<Ret, A, B, C, D, E, F, G> PartialEq for unsafe fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G) -> Ret`
• `impl<Ret, A, B, C, D, E, F, G> PartialEq for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G) -> Ret`
• `impl<Ret, A, B, C, D, E, F, G> PartialEq for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, ...) -> Ret`
• `impl<Ret, A, B, C, D, E, F, G, H> PartialEq for fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H) -> Ret`
• `impl<Ret, A, B, C, D, E, F, G, H> PartialEq for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H) -> Ret`
• `impl<Ret, A, B, C, D, E, F, G, H> PartialEq for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, ...) -> Ret`
• `impl<Ret, A, B, C, D, E, F, G, H> PartialEq for unsafe fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H) -> Ret`
• `impl<Ret, A, B, C, D, E, F, G, H> PartialEq for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H) -> Ret`
• `impl<Ret, A, B, C, D, E, F, G, H> PartialEq for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, ...) -> Ret`
• `impl<Ret, A, B, C, D, E, F, G, H, I> PartialEq for fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I) -> Ret`
• `impl<Ret, A, B, C, D, E, F, G, H, I> PartialEq for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I) -> Ret`
• `impl<Ret, A, B, C, D, E, F, G, H, I> PartialEq for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, ...) -> Ret`
• `impl<Ret, A, B, C, D, E, F, G, H, I> PartialEq for unsafe fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I) -> Ret`
• `impl<Ret, A, B, C, D, E, F, G, H, I> PartialEq for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I) -> Ret`
• `impl<Ret, A, B, C, D, E, F, G, H, I> PartialEq for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, ...) -> Ret`
• `impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialEq for fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J) -> Ret`
• `impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialEq for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J) -> Ret`
• `impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialEq for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, ...) -> Ret`
• `impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialEq for unsafe fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J) -> Ret`
• `impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialEq for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J) -> Ret`
• `impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialEq for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, ...) -> Ret`
• `impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialEq for fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K) -> Ret`
• `impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialEq for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K) -> Ret`
• `impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialEq for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, ...) -> Ret`
• `impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialEq for unsafe fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K) -> Ret`
• `impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialEq for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K) -> Ret`
• `impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialEq for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, ...) -> Ret`
• `impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialEq for fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L) -> Ret`
• `impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialEq for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L) -> Ret`
• `impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialEq for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L, ...) -> Ret`
• `impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialEq for unsafe fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L) -> Ret`
• `impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialEq for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L) -> Ret`
• `impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialEq for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L, ...) -> Ret`
• `impl<T: ?Sized> PartialEq for NonNull<T>`
• `impl<T: ?Sized> PartialEq for PhantomData<T>`
• `impl<Y: PartialEq, R: PartialEq> PartialEq for GeneratorState<Y, R>`
• `impl PartialEq for RangeFull`
• `impl<Idx: PartialEq> PartialEq for Range<Idx>`
• `impl<Idx: PartialEq> PartialEq for RangeFrom<Idx>`
• `impl<Idx: PartialEq> PartialEq for RangeTo<Idx>`
• `impl<Idx: PartialEq> PartialEq for RangeInclusive<Idx>`
• `impl<Idx: PartialEq> PartialEq for RangeToInclusive<Idx>`
• `impl PartialEq for ()`
• `impl PartialEq for bool`
• `impl PartialEq for char`
• `impl PartialEq for usize`
• `impl PartialEq for u8`
• `impl PartialEq for u16`
• `impl PartialEq for u32`
• `impl PartialEq for u64`
• `impl PartialEq for u128`
• `impl PartialEq for isize`
• `impl PartialEq for i8`
• `impl PartialEq for i16`
• `impl PartialEq for i32`
• `impl PartialEq for i64`
• `impl PartialEq for i128`
• `impl PartialEq for f32`
• `impl PartialEq for f64`
• `impl PartialEq for !`
• `impl<'a, 'b, A: ?Sized, B: ?Sized> PartialEq<&'b B> for &'a A where    A: PartialEq<B>, `
• `impl<'a, 'b, A: ?Sized, B: ?Sized> PartialEq<&'b mut B> for &'a mut A where    A: PartialEq<B>, `
• `impl<'a, 'b, A: ?Sized, B: ?Sized> PartialEq<&'b mut B> for &'a A where    A: PartialEq<B>, `
• `impl<'a, 'b, A: ?Sized, B: ?Sized> PartialEq<&'b B> for &'a mut A where    A: PartialEq<B>, `
• `impl PartialEq for Ordering`
• `impl<T: PartialEq> PartialEq for Reverse<T>`
• `impl PartialEq for Infallible`
• `impl PartialEq for TypeId`
• `impl<'a, 'b, A: Sized, B> PartialEq<[B; 0]> for [A; 0] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B]> for [A; 0] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 0]> for [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b [B]> for [A; 0] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 0]> for &'b [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b mut [B]> for [A; 0] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 0]> for &'b mut [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B; 1]> for [A; 1] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B]> for [A; 1] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 1]> for [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b [B]> for [A; 1] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 1]> for &'b [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b mut [B]> for [A; 1] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 1]> for &'b mut [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B; 2]> for [A; 2] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B]> for [A; 2] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 2]> for [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b [B]> for [A; 2] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 2]> for &'b [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b mut [B]> for [A; 2] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 2]> for &'b mut [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B; 3]> for [A; 3] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B]> for [A; 3] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 3]> for [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b [B]> for [A; 3] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 3]> for &'b [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b mut [B]> for [A; 3] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 3]> for &'b mut [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B; 4]> for [A; 4] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B]> for [A; 4] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 4]> for [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b [B]> for [A; 4] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 4]> for &'b [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b mut [B]> for [A; 4] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 4]> for &'b mut [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B; 5]> for [A; 5] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B]> for [A; 5] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 5]> for [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b [B]> for [A; 5] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 5]> for &'b [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b mut [B]> for [A; 5] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 5]> for &'b mut [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B; 6]> for [A; 6] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B]> for [A; 6] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 6]> for [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b [B]> for [A; 6] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 6]> for &'b [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b mut [B]> for [A; 6] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 6]> for &'b mut [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B; 7]> for [A; 7] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B]> for [A; 7] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 7]> for [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b [B]> for [A; 7] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 7]> for &'b [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b mut [B]> for [A; 7] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 7]> for &'b mut [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B; 8]> for [A; 8] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B]> for [A; 8] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 8]> for [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b [B]> for [A; 8] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 8]> for &'b [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b mut [B]> for [A; 8] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 8]> for &'b mut [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B; 9]> for [A; 9] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B]> for [A; 9] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 9]> for [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b [B]> for [A; 9] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 9]> for &'b [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b mut [B]> for [A; 9] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 9]> for &'b mut [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B; 10]> for [A; 10] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B]> for [A; 10] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 10]> for [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b [B]> for [A; 10] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 10]> for &'b [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b mut [B]> for [A; 10] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 10]> for &'b mut [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B; 11]> for [A; 11] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B]> for [A; 11] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 11]> for [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b [B]> for [A; 11] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 11]> for &'b [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b mut [B]> for [A; 11] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 11]> for &'b mut [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B; 12]> for [A; 12] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B]> for [A; 12] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 12]> for [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b [B]> for [A; 12] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 12]> for &'b [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b mut [B]> for [A; 12] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 12]> for &'b mut [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B; 13]> for [A; 13] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B]> for [A; 13] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 13]> for [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b [B]> for [A; 13] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 13]> for &'b [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b mut [B]> for [A; 13] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 13]> for &'b mut [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B; 14]> for [A; 14] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B]> for [A; 14] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 14]> for [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b [B]> for [A; 14] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 14]> for &'b [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b mut [B]> for [A; 14] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 14]> for &'b mut [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B; 15]> for [A; 15] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B]> for [A; 15] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 15]> for [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b [B]> for [A; 15] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 15]> for &'b [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b mut [B]> for [A; 15] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 15]> for &'b mut [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B; 16]> for [A; 16] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B]> for [A; 16] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 16]> for [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b [B]> for [A; 16] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 16]> for &'b [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b mut [B]> for [A; 16] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 16]> for &'b mut [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B; 17]> for [A; 17] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B]> for [A; 17] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 17]> for [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b [B]> for [A; 17] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 17]> for &'b [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b mut [B]> for [A; 17] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 17]> for &'b mut [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B; 18]> for [A; 18] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B]> for [A; 18] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 18]> for [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b [B]> for [A; 18] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 18]> for &'b [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b mut [B]> for [A; 18] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 18]> for &'b mut [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B; 19]> for [A; 19] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B]> for [A; 19] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 19]> for [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b [B]> for [A; 19] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 19]> for &'b [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b mut [B]> for [A; 19] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 19]> for &'b mut [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B; 20]> for [A; 20] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B]> for [A; 20] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 20]> for [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b [B]> for [A; 20] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 20]> for &'b [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b mut [B]> for [A; 20] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 20]> for &'b mut [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B; 21]> for [A; 21] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B]> for [A; 21] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 21]> for [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b [B]> for [A; 21] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 21]> for &'b [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b mut [B]> for [A; 21] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 21]> for &'b mut [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B; 22]> for [A; 22] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B]> for [A; 22] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 22]> for [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b [B]> for [A; 22] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 22]> for &'b [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b mut [B]> for [A; 22] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 22]> for &'b mut [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B; 23]> for [A; 23] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B]> for [A; 23] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 23]> for [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b [B]> for [A; 23] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 23]> for &'b [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b mut [B]> for [A; 23] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 23]> for &'b mut [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B; 24]> for [A; 24] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B]> for [A; 24] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 24]> for [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b [B]> for [A; 24] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 24]> for &'b [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b mut [B]> for [A; 24] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 24]> for &'b mut [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B; 25]> for [A; 25] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B]> for [A; 25] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 25]> for [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b [B]> for [A; 25] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 25]> for &'b [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b mut [B]> for [A; 25] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 25]> for &'b mut [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B; 26]> for [A; 26] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B]> for [A; 26] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 26]> for [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b [B]> for [A; 26] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 26]> for &'b [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b mut [B]> for [A; 26] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 26]> for &'b mut [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B; 27]> for [A; 27] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B]> for [A; 27] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 27]> for [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b [B]> for [A; 27] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 27]> for &'b [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b mut [B]> for [A; 27] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 27]> for &'b mut [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B; 28]> for [A; 28] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B]> for [A; 28] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 28]> for [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b [B]> for [A; 28] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 28]> for &'b [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b mut [B]> for [A; 28] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 28]> for &'b mut [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B; 29]> for [A; 29] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B]> for [A; 29] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 29]> for [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b [B]> for [A; 29] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 29]> for &'b [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b mut [B]> for [A; 29] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 29]> for &'b mut [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B; 30]> for [A; 30] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B]> for [A; 30] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 30]> for [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b [B]> for [A; 30] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 30]> for &'b [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b mut [B]> for [A; 30] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 30]> for &'b mut [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B; 31]> for [A; 31] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B]> for [A; 31] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 31]> for [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b [B]> for [A; 31] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 31]> for &'b [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b mut [B]> for [A; 31] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 31]> for &'b mut [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B; 32]> for [A; 32] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[B]> for [A; 32] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 32]> for [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b [B]> for [A; 32] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 32]> for &'b [B] where    B: PartialEq<A>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<&'b mut [B]> for [A; 32] where    A: PartialEq<B>, `
• `impl<'a, 'b, A: Sized, B> PartialEq<[A; 32]> for &'b mut [B] where    B: PartialEq<A>, `
• `impl<T: PartialEq + Copy> PartialEq for Cell<T>`
• `impl<T: ?Sized + PartialEq> PartialEq for RefCell<T>`
• `impl PartialEq for ParseCharError`
• `impl PartialEq for CharTryFromError`
• `impl PartialEq for InvalidSequence`
• `impl<T: PartialEq> PartialEq for Option<T>`
• `impl PartialEq for NoneError`
• `impl<T: PartialEq, E: PartialEq> PartialEq for Result<T, E>`
• `impl<A, B> PartialEq<[B]> for [A] where    A: PartialEq<B>, `
• `impl PartialEq for SearchStep`
• `impl PartialEq for str`
• `impl PartialEq for ParseBoolError`
• `impl PartialEq for Utf8Error`
• `impl PartialEq for Error`
• `impl PartialEq for Duration`
• `impl<A> PartialEq for (A,) where    A: PartialEq + ?Sized, `
• `impl<A: PartialEq, B> PartialEq for (A, B) where    B: PartialEq + ?Sized, `
• `impl<A: PartialEq, B: PartialEq, C> PartialEq for (A, B, C) where    C: PartialEq + ?Sized, `
• `impl<A: PartialEq, B: PartialEq, C: PartialEq, D> PartialEq for (A, B, C, D) where    D: PartialEq + ?Sized, `
• `impl<A: PartialEq, B: PartialEq, C: PartialEq, D: PartialEq, E> PartialEq for (A, B, C, D, E) where    E: PartialEq + ?Sized, `
• `impl<A: PartialEq, B: PartialEq, C: PartialEq, D: PartialEq, E: PartialEq, F> PartialEq for (A, B, C, D, E, F) where    F: PartialEq + ?Sized, `
• `impl<A: PartialEq, B: PartialEq, C: PartialEq, D: PartialEq, E: PartialEq, F: PartialEq, G> PartialEq for (A, B, C, D, E, F, G) where    G: PartialEq + ?Sized, `
• `impl<A: PartialEq, B: PartialEq, C: PartialEq, D: PartialEq, E: PartialEq, F: PartialEq, G: PartialEq, H> PartialEq for (A, B, C, D, E, F, G, H) where    H: PartialEq + ?Sized, `
• `impl<A: PartialEq, B: PartialEq, C: PartialEq, D: PartialEq, E: PartialEq, F: PartialEq, G: PartialEq, H: PartialEq, I> PartialEq for (A, B, C, D, E, F, G, H, I) where    I: PartialEq + ?Sized, `
• `impl<A: PartialEq, B: PartialEq, C: PartialEq, D: PartialEq, E: PartialEq, F: PartialEq, G: PartialEq, H: PartialEq, I: PartialEq, J> PartialEq for (A, B, C, D, E, F, G, H, I, J) where    J: PartialEq + ?Sized, `
• `impl<A: PartialEq, B: PartialEq, C: PartialEq, D: PartialEq, E: PartialEq, F: PartialEq, G: PartialEq, H: PartialEq, I: PartialEq, J: PartialEq, K> PartialEq for (A, B, C, D, E, F, G, H, I, J, K) where    K: PartialEq + ?Sized, `
• `impl<A: PartialEq, B: PartialEq, C: PartialEq, D: PartialEq, E: PartialEq, F: PartialEq, G: PartialEq, H: PartialEq, I: PartialEq, J: PartialEq, K: PartialEq, L> PartialEq for (A, B, C, D, E, F, G, H, I, J, K, L) where    L: PartialEq + ?Sized, `