# Trait std::cmp::PartialEq 1.0.0 [−] [src]

    #[lang = "eq"]
    pub trait PartialEq<Rhs = Self> where
        Rhs: ?Sized, {
        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 `!=`.

## Implementations on Foreign Types

### `impl PartialEq<_Unwind_Reason_Code> for _Unwind_Reason_Code`

#### `fn eq(&self, __arg_0: &_Unwind_Reason_Code) -> bool`

#### `fn ne(&self, other: &Rhs) -> bool`
1.0.0
[src]

### `impl PartialEq<_Unwind_Action> for _Unwind_Action`

#### `fn eq(&self, __arg_0: &_Unwind_Action) -> bool`

#### `fn ne(&self, other: &Rhs) -> bool`
1.0.0
[src]

### `impl<'a> PartialEq<Utf8LossyChunk<'a>> for Utf8LossyChunk<'a>`
[src]

#### `fn eq(&self, __arg_0: &Utf8LossyChunk<'a>) -> bool`
[src]

#### `fn ne(&self, __arg_0: &Utf8LossyChunk<'a>) -> bool`
[src]

### `impl PartialEq<InvalidSequence> for InvalidSequence`
[src]

#### `fn eq(&self, __arg_0: &InvalidSequence) -> bool`
[src]

#### `fn ne(&self, __arg_0: &InvalidSequence) -> bool`
[src]

### `impl<T> PartialEq<NonZero<T>> for NonZero<T> where
T: Zeroable + PartialEq<T>,`
[src]

#### `fn eq(&self, __arg_0: &NonZero<T>) -> bool`
[src]

#### `fn ne(&self, __arg_0: &NonZero<T>) -> bool`
[src]

## Implementors

- `impl PartialEq<DecodeUtf16Error> for DecodeUtf16Error`
- `impl PartialEq<i64> for i64`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10297) => core/5e4b76f::array[0]::{{impl}}[537]::{{initializer}}[0] }, Slice([])) }]> for &'b mut [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9889) => core/5e4b76f::array[0]::{{impl}}[472]::{{initializer}}[0] }, Slice([])) }]> for &'b [B] where
  B: PartialEq<A>,`
- `impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10065) => core/5e4b76f::array[0]::{{impl}}[500]::{{initializer}}[0] }, Slice([])) }]> for &'b [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10141) => core/5e4b76f::array[0]::{{impl}}[512]::{{initializer}}[0] }, Slice([])) }]> for [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9820) => core/5e4b76f::array[0]::{{impl}}[461]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10625) => core/5e4b76f::array[0]::{{impl}}[589]::{{initializer}}[0] }, Slice([])) }]> for [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9877) => core/5e4b76f::array[0]::{{impl}}[470]::{{initializer}}[0] }, Slice([])) }]> for [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9676) => core/5e4b76f::array[0]::{{impl}}[438]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10593) => core/5e4b76f::array[0]::{{impl}}[584]::{{initializer}}[0] }, Slice([])) }]> for &'b [B] where
  B: PartialEq<A>,`
- `impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret`
- `impl<Ret> PartialEq<unsafe extern "C" fn() -> Ret> for unsafe extern "C" fn() -> Ret`
- `impl<Ret, A, B, C> PartialEq<extern "C" fn(A, B, C) -> Ret> for extern "C" fn(A, B, C) -> Ret`
- `impl<'a, 'b, A, B> PartialEq<&'b B> for &'a mut A where
  A: PartialEq<B> + ?Sized,
  B: ?Sized,`
- `impl<Ret, A, B, C, D, E> PartialEq<fn(A, B, C, D, E) -> Ret> for fn(A, B, C, D, E) -> Ret`
- `impl PartialEq<TypeId> for TypeId`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10285) => core/5e4b76f::array[0]::{{impl}}[535]::{{initializer}}[0] }, Slice([])) }]> for &'b [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10097) => core/5e4b76f::array[0]::{{impl}}[505]::{{initializer}}[0] }, Slice([])) }]> for [B] where
  B: PartialEq<A>,`
- `impl<Ret, A, B, C, D, E, F, G, H> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9549) => core/5e4b76f::array[0]::{{impl}}[418]::{{initializer}}[0] }, Slice([])) }]> for &'b mut [B] where
  B: PartialEq<A>,`
- `impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10241) => core/5e4b76f::array[0]::{{impl}}[528]::{{initializer}}[0] }, Slice([])) }]> for &'b [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9236) => core/5e4b76f::array[0]::{{impl}}[368]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9737) => core/5e4b76f::array[0]::{{impl}}[448]::{{initializer}}[0] }, Slice([])) }]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9738) => core/5e4b76f::array[0]::{{impl}}[448]::{{initializer}}[1] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9241) => core/5e4b76f::array[0]::{{impl}}[369]::{{initializer}}[0] }, Slice([])) }]> for &'b mut [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10153) => core/5e4b76f::array[0]::{{impl}}[514]::{{initializer}}[0] }, Slice([])) }]> for &'b [B] where
  B: PartialEq<A>,`
- `impl<Ret, A, B, C, D, E, F> PartialEq<extern "C" fn(A, B, C, D, E, F, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, ...) -> Ret`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10656) => core/5e4b76f::array[0]::{{impl}}[594]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10500) => core/5e4b76f::array[0]::{{impl}}[569]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10473) => core/5e4b76f::array[0]::{{impl}}[565]::{{initializer}}[0] }, Slice([])) }]> for &'b mut [B] where
  B: PartialEq<A>,`
- `impl<Ret, A, B, C, D> PartialEq<fn(A, B, C, D) -> Ret> for fn(A, B, C, D) -> Ret`
- `impl PartialEq<i8> for i8`
- `impl<Ret, A, B, C, D, E> PartialEq<extern "C" fn(A, B, C, D, E, ...) -> Ret> for extern "C" fn(A, B, C, D, E, ...) -> Ret`
- `impl<'a, 'b, A, B> PartialEq<[B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10368) => core/5e4b76f::array[0]::{{impl}}[548]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10617) => core/5e4b76f::array[0]::{{impl}}[588]::{{initializer}}[0] }, Slice([])) }]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10618) => core/5e4b76f::array[0]::{{impl}}[588]::{{initializer}}[1] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10529) => core/5e4b76f::array[0]::{{impl}}[574]::{{initializer}}[0] }, Slice([])) }]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10530) => core/5e4b76f::array[0]::{{impl}}[574]::{{initializer}}[1] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<T> PartialEq<ManuallyDrop<T>> for ManuallyDrop<T> where
  T: PartialEq<T>,`
- `impl<Ret, A, B, C, D, E, F> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F) -> Ret`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10033) => core/5e4b76f::array[0]::{{impl}}[495]::{{initializer}}[0] }, Slice([])) }]> for &'b mut [B] where
  B: PartialEq<A>,`
- `impl PartialEq<ParseFloatError> for ParseFloatError`
- `impl<Ret, A, B> PartialEq<extern "C" fn(A, B, ...) -> Ret> for extern "C" fn(A, B, ...) -> Ret`
- `impl<A, B, C, D, E, F> PartialEq<(A, B, C, D, E, F)> for (A, B, C, D, E, F) where
  A: PartialEq<A>,
  B: PartialEq<B>,
  C: PartialEq<C>,
  D: PartialEq<D>,
  E: PartialEq<E>,
  F: PartialEq<F> + ?Sized,`
- `impl<Ret, A, B, C, D> PartialEq<extern "C" fn(A, B, C, D, ...) -> Ret> for extern "C" fn(A, B, C, D, ...) -> Ret`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10561) => core/5e4b76f::array[0]::{{impl}}[579]::{{initializer}}[0] }, Slice([])) }]> for &'b mut [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9913) => core/5e4b76f::array[0]::{{impl}}[476]::{{initializer}}[0] }, Slice([])) }]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9914) => core/5e4b76f::array[0]::{{impl}}[476]::{{initializer}}[1] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9957) => core/5e4b76f::array[0]::{{impl}}[483]::{{initializer}}[0] }, Slice([])) }]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9958) => core/5e4b76f::array[0]::{{impl}}[483]::{{initializer}}[1] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret`
- `impl<Ret, A, B> PartialEq<unsafe fn(A, B) -> Ret> for unsafe fn(A, B) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H> PartialEq<fn(A, B, C, D, E, F, G, H) -> Ret> for fn(A, B, C, D, E, F, G, H) -> Ret`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9361) => core/5e4b76f::array[0]::{{impl}}[388]::{{initializer}}[0] }, Slice([])) }]> for &'b [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9500) => core/5e4b76f::array[0]::{{impl}}[410]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<Ret, A, B, C, D> PartialEq<unsafe fn(A, B, C, D) -> Ret> for unsafe fn(A, B, C, D) -> Ret`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9305) => core/5e4b76f::array[0]::{{impl}}[379]::{{initializer}}[0] }, Slice([])) }]> for [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9852) => core/5e4b76f::array[0]::{{impl}}[466]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10405) => core/5e4b76f::array[0]::{{impl}}[554]::{{initializer}}[0] }, Slice([])) }]> for [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9833) => core/5e4b76f::array[0]::{{impl}}[463]::{{initializer}}[0] }, Slice([])) }]> for [B] where
  B: PartialEq<A>,`
- `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<A>,
  B: PartialEq<B>,
  C: PartialEq<C>,
  D: PartialEq<D>,
  E: PartialEq<E>,
  F: PartialEq<F>,
  G: PartialEq<G>,
  H: PartialEq<H>,
  I: PartialEq<I> + ?Sized,`
- `impl<A, B, C> PartialEq<(A, B, C)> for (A, B, C) where
  A: PartialEq<A>,
  B: PartialEq<B>,
  C: PartialEq<C> + ?Sized,`
- `impl<Ret, A, B, C, D, E> PartialEq<unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10260) => core/5e4b76f::array[0]::{{impl}}[531]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9569) => core/5e4b76f::array[0]::{{impl}}[421]::{{initializer}}[0] }, Slice([])) }]> for [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<[B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9224) => core/5e4b76f::array[0]::{{impl}}[366]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<T> PartialEq<Reverse<T>> for Reverse<T> where
  T: PartialEq<T>,`
- `impl<Ret, A, B, C, D, E, F> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10568) => core/5e4b76f::array[0]::{{impl}}[580]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9456) => core/5e4b76f::array[0]::{{impl}}[403]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<Ret, A, B, C, D, E, F, G, H> PartialEq<unsafe fn(A, B, C, D, E, F, G, H) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H) -> Ret`
- `impl<'a, 'b, A, B> PartialEq<[B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10236) => core/5e4b76f::array[0]::{{impl}}[527]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9669) => core/5e4b76f::array[0]::{{impl}}[437]::{{initializer}}[0] }, Slice([])) }]> for &'b [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10397) => core/5e4b76f::array[0]::{{impl}}[553]::{{initializer}}[0] }, Slice([])) }]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10398) => core/5e4b76f::array[0]::{{impl}}[553]::{{initializer}}[1] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<Ret, A, B, C, D, E, F, G, H, I> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret`
- `impl<'a, 'b, A, B> PartialEq<[B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9312) => core/5e4b76f::array[0]::{{impl}}[380]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10549) => core/5e4b76f::array[0]::{{impl}}[577]::{{initializer}}[0] }, Slice([])) }]> for &'b [B] where
  B: PartialEq<A>,`
- `impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialEq<fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret`
- `impl<Ret, A, B> PartialEq<extern "C" fn(A, B) -> Ret> for extern "C" fn(A, B) -> Ret`
- `impl PartialEq<!> for !`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9380) => core/5e4b76f::array[0]::{{impl}}[391]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl PartialEq<f64> for f64`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10128) => core/5e4b76f::array[0]::{{impl}}[510]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<Ret, A, B, C, D, E, F, G> PartialEq<unsafe fn(A, B, C, D, E, F, G) -> Ret> for unsafe fn(A, B, C, D, E, F, G) -> Ret`
- `impl PartialEq<u32> for u32`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9713) => core/5e4b76f::array[0]::{{impl}}[444]::{{initializer}}[0] }, Slice([])) }]> for &'b [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9908) => core/5e4b76f::array[0]::{{impl}}[475]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9933) => core/5e4b76f::array[0]::{{impl}}[479]::{{initializer}}[0] }, Slice([])) }]> for &'b [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10524) => core/5e4b76f::array[0]::{{impl}}[573]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<Idx> PartialEq<RangeFrom<Idx>> for RangeFrom<Idx> where
  Idx: PartialEq<Idx>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9757) => core/5e4b76f::array[0]::{{impl}}[451]::{{initializer}}[0] }, Slice([])) }]> for &'b [B] where
  B: PartialEq<A>,`
- `impl<Ret, A, B, C, D, E, F, G> PartialEq<fn(A, B, C, D, E, F, G) -> Ret> for fn(A, B, C, D, E, F, G) -> Ret`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9248) => core/5e4b76f::array[0]::{{impl}}[370]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `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<A>,
  B: PartialEq<B>,
  C: PartialEq<C>,
  D: PartialEq<D>,
  E: PartialEq<E>,
  F: PartialEq<F>,
  G: PartialEq<G> + ?Sized,`
- `impl<'a, 'b, A, B> PartialEq<[B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10588) => core/5e4b76f::array[0]::{{impl}}[583]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9688) => core/5e4b76f::array[0]::{{impl}}[440]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<Ret, A> PartialEq<extern "C" fn(A) -> Ret> for extern "C" fn(A) -> Ret`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10637) => core/5e4b76f::array[0]::{{impl}}[591]::{{initializer}}[0] }, Slice([])) }]> for &'b [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9285) => core/5e4b76f::array[0]::{{impl}}[376]::{{initializer}}[0] }, Slice([])) }]> for &'b mut [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10485) => core/5e4b76f::array[0]::{{impl}}[567]::{{initializer}}[0] }, Slice([])) }]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10486) => core/5e4b76f::array[0]::{{impl}}[567]::{{initializer}}[1] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<T> PartialEq<Wrapping<T>> for Wrapping<T> where
  T: PartialEq<T>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9393) => core/5e4b76f::array[0]::{{impl}}[393]::{{initializer}}[0] }, Slice([])) }]> for [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9588) => core/5e4b76f::array[0]::{{impl}}[424]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `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<A>,
  B: PartialEq<B>,
  C: PartialEq<C>,
  D: PartialEq<D>,
  E: PartialEq<E>,
  F: PartialEq<F>,
  G: PartialEq<G>,
  H: PartialEq<H>,
  I: PartialEq<I>,
  J: PartialEq<J> + ?Sized,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9989) => core/5e4b76f::array[0]::{{impl}}[488]::{{initializer}}[0] }, Slice([])) }]> for &'b mut [B] where
  B: PartialEq<A>,`
- `impl PartialEq<()> for ()`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9449) => core/5e4b76f::array[0]::{{impl}}[402]::{{initializer}}[0] }, Slice([])) }]> for &'b [B] where
  B: PartialEq<A>,`
- `impl<A, B> PartialEq<[B]> for [A] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10045) => core/5e4b76f::array[0]::{{impl}}[497]::{{initializer}}[0] }, Slice([])) }]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10046) => core/5e4b76f::array[0]::{{impl}}[497]::{{initializer}}[1] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10581) => core/5e4b76f::array[0]::{{impl}}[582]::{{initializer}}[0] }, Slice([])) }]> for [B] where
  B: PartialEq<A>,`
- `impl<Ret, A, B, C, D, E, F, G, H, I> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret`
- `impl<T> PartialEq<*mut T> for *mut T where
  T: ?Sized,`
- `impl<'a, 'b, A, B> PartialEq<[B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10632) => core/5e4b76f::array[0]::{{impl}}[590]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10649) => core/5e4b76f::array[0]::{{impl}}[593]::{{initializer}}[0] }, Slice([])) }]> for &'b mut [B] where
  B: PartialEq<A>,`
- `impl PartialEq<u8> for u8`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9952) => core/5e4b76f::array[0]::{{impl}}[482]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10417) => core/5e4b76f::array[0]::{{impl}}[556]::{{initializer}}[0] }, Slice([])) }]> for &'b [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10072) => core/5e4b76f::array[0]::{{impl}}[501]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9921) => core/5e4b76f::array[0]::{{impl}}[477]::{{initializer}}[0] }, Slice([])) }]> for [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9701) => core/5e4b76f::array[0]::{{impl}}[442]::{{initializer}}[0] }, Slice([])) }]> for [B] where
  B: PartialEq<A>,`
- `impl<Ret, A, B, C, D, E, F> PartialEq<extern "C" fn(A, B, C, D, E, F) -> Ret> for extern "C" fn(A, B, C, D, E, F) -> Ret`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10353) => core/5e4b76f::array[0]::{{impl}}[546]::{{initializer}}[0] }, Slice([])) }]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10354) => core/5e4b76f::array[0]::{{impl}}[546]::{{initializer}}[1] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9324) => core/5e4b76f::array[0]::{{impl}}[382]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10385) => core/5e4b76f::array[0]::{{impl}}[551]::{{initializer}}[0] }, Slice([])) }]> for &'b mut [B] where
  B: PartialEq<A>,`
- `impl<Ret, A, B, C> PartialEq<fn(A, B, C) -> Ret> for fn(A, B, C) -> Ret`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10449) => core/5e4b76f::array[0]::{{impl}}[561]::{{initializer}}[0] }, Slice([])) }]> for [B] where
  B: PartialEq<A>,`
- `impl PartialEq<bool> for bool`
- `impl<Ret, A, B, C, D, E, F, G, H, I> PartialEq<unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret`
- `impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10512) => core/5e4b76f::array[0]::{{impl}}[571]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<Ret, A> PartialEq<unsafe fn(A) -> Ret> for unsafe fn(A) -> Ret`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10197) => core/5e4b76f::array[0]::{{impl}}[521]::{{initializer}}[0] }, Slice([])) }]> for &'b [B] where
  B: PartialEq<A>,`
- `impl PartialEq<str> for str`
- `impl<Y, R> PartialEq<GeneratorState<Y, R>> for GeneratorState<Y, R> where
  R: PartialEq<R>,
  Y: PartialEq<Y>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10177) => core/5e4b76f::array[0]::{{impl}}[518]::{{initializer}}[0] }, Slice([])) }]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10178) => core/5e4b76f::array[0]::{{impl}}[518]::{{initializer}}[1] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9901) => core/5e4b76f::array[0]::{{impl}}[474]::{{initializer}}[0] }, Slice([])) }]> for &'b mut [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10253) => core/5e4b76f::array[0]::{{impl}}[530]::{{initializer}}[0] }, Slice([])) }]> for &'b mut [B] where
  B: PartialEq<A>,`
- `impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10221) => core/5e4b76f::array[0]::{{impl}}[525]::{{initializer}}[0] }, Slice([])) }]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10222) => core/5e4b76f::array[0]::{{impl}}[525]::{{initializer}}[1] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10265) => core/5e4b76f::array[0]::{{impl}}[532]::{{initializer}}[0] }, Slice([])) }]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10266) => core/5e4b76f::array[0]::{{impl}}[532]::{{initializer}}[1] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9556) => core/5e4b76f::array[0]::{{impl}}[419]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<Ret, A, B, C, D, E, F, G> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9505) => core/5e4b76f::array[0]::{{impl}}[411]::{{initializer}}[0] }, Slice([])) }]> for &'b mut [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10441) => core/5e4b76f::array[0]::{{impl}}[560]::{{initializer}}[0] }, Slice([])) }]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10442) => core/5e4b76f::array[0]::{{impl}}[560]::{{initializer}}[1] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10348) => core/5e4b76f::array[0]::{{impl}}[545]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10517) => core/5e4b76f::array[0]::{{impl}}[572]::{{initializer}}[0] }, Slice([])) }]> for &'b mut [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10380) => core/5e4b76f::array[0]::{{impl}}[550]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10040) => core/5e4b76f::array[0]::{{impl}}[496]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9884) => core/5e4b76f::array[0]::{{impl}}[471]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl PartialEq<Error> for Error`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9417) => core/5e4b76f::array[0]::{{impl}}[397]::{{initializer}}[0] }, Slice([])) }]> for &'b mut [B] where
  B: PartialEq<A>,`
- `impl<Ret> PartialEq<fn() -> Ret> for fn() -> Ret`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10053) => core/5e4b76f::array[0]::{{impl}}[498]::{{initializer}}[0] }, Slice([])) }]> for [B] where
  B: PartialEq<A>,`
- `impl<Ret, A> PartialEq<extern "C" fn(A, ...) -> Ret> for extern "C" fn(A, ...) -> Ret`
- `impl<Idx> PartialEq<RangeTo<Idx>> for RangeTo<Idx> where
  Idx: PartialEq<Idx>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10317) => core/5e4b76f::array[0]::{{impl}}[540]::{{initializer}}[0] }, Slice([])) }]> for [B] where
  B: PartialEq<A>,`
- `impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9229) => core/5e4b76f::array[0]::{{impl}}[367]::{{initializer}}[0] }, Slice([])) }]> for &'b [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10461) => core/5e4b76f::array[0]::{{impl}}[563]::{{initializer}}[0] }, Slice([])) }]> for &'b [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<[B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10192) => core/5e4b76f::array[0]::{{impl}}[520]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9605) => core/5e4b76f::array[0]::{{impl}}[427]::{{initializer}}[0] }, Slice([])) }]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9606) => core/5e4b76f::array[0]::{{impl}}[427]::{{initializer}}[1] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<A, B, C, D, E> PartialEq<(A, B, C, D, E)> for (A, B, C, D, E) where
  A: PartialEq<A>,
  B: PartialEq<B>,
  C: PartialEq<C>,
  D: PartialEq<D>,
  E: PartialEq<E> + ?Sized,`
- `impl PartialEq<ParseIntError> for ParseIntError`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9405) => core/5e4b76f::array[0]::{{impl}}[395]::{{initializer}}[0] }, Slice([])) }]> for &'b [B] where
  B: PartialEq<A>,`
- `impl<Ret, A, B, C> PartialEq<unsafe fn(A, B, C) -> Ret> for unsafe fn(A, B, C) -> Ret`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9481) => core/5e4b76f::array[0]::{{impl}}[407]::{{initializer}}[0] }, Slice([])) }]> for [B] where
  B: PartialEq<A>,`
- `impl PartialEq<RangeFull> for RangeFull`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9776) => core/5e4b76f::array[0]::{{impl}}[454]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<T> PartialEq<RefCell<T>> for RefCell<T> where
  T: PartialEq<T> + ?Sized,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10084) => core/5e4b76f::array[0]::{{impl}}[503]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9329) => core/5e4b76f::array[0]::{{impl}}[383]::{{initializer}}[0] }, Slice([])) }]> for &'b mut [B] where
  B: PartialEq<A>,`
- `impl PartialEq<i32> for i32`
- `impl<'a, 'b, A, B> PartialEq<[B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10324) => core/5e4b76f::array[0]::{{impl}}[541]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10133) => core/5e4b76f::array[0]::{{impl}}[511]::{{initializer}}[0] }, Slice([])) }]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10134) => core/5e4b76f::array[0]::{{impl}}[511]::{{initializer}}[1] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<Ret, A, B, C> PartialEq<unsafe extern "C" fn(A, B, C) -> Ret> for unsafe extern "C" fn(A, B, C) -> Ret`
- `impl<'a, 'b, A, B> PartialEq<[B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9708) => core/5e4b76f::array[0]::{{impl}}[443]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9745) => core/5e4b76f::array[0]::{{impl}}[449]::{{initializer}}[0] }, Slice([])) }]> for [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9412) => core/5e4b76f::array[0]::{{impl}}[396]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl PartialEq<u128> for u128`
- `impl<'a, 'b, A, B> PartialEq<[B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9840) => core/5e4b76f::array[0]::{{impl}}[464]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut B> for &'a A where
  A: PartialEq<B> + ?Sized,
  B: ?Sized,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10001) => core/5e4b76f::array[0]::{{impl}}[490]::{{initializer}}[0] }, Slice([])) }]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10002) => core/5e4b76f::array[0]::{{impl}}[490]::{{initializer}}[1] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<Ret, A, B, C, D, E, F> PartialEq<unsafe fn(A, B, C, D, E, F) -> Ret> for unsafe fn(A, B, C, D, E, F) -> Ret`
- `impl PartialEq<i128> for i128`
- `impl PartialEq<usize> for usize`
- `impl<Ret, A, B, C, D, E, F> PartialEq<fn(A, B, C, D, E, F) -> Ret> for fn(A, B, C, D, E, F) -> Ret`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10612) => core/5e4b76f::array[0]::{{impl}}[587]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9280) => core/5e4b76f::array[0]::{{impl}}[375]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9424) => core/5e4b76f::array[0]::{{impl}}[398]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<Ret> PartialEq<unsafe fn() -> Ret> for unsafe fn() -> Ret`
- `impl PartialEq<f32> for f32`
- `impl<Ret, A, B, C, D, E, F, G, H> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret`
- `impl<Ret, A, B, C> PartialEq<extern "C" fn(A, B, C, ...) -> Ret> for extern "C" fn(A, B, C, ...) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialEq<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret> for fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9317) => core/5e4b76f::array[0]::{{impl}}[381]::{{initializer}}[0] }, Slice([])) }]> for &'b [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9984) => core/5e4b76f::array[0]::{{impl}}[487]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10148) => core/5e4b76f::array[0]::{{impl}}[513]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<Ret, A, B> PartialEq<unsafe extern "C" fn(A, B, ...) -> Ret> for unsafe extern "C" fn(A, B, ...) -> Ret`
- `impl PartialEq<SearchStep> for SearchStep`
- `impl PartialEq<i16> for i16`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10480) => core/5e4b76f::array[0]::{{impl}}[566]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<Ret, A> PartialEq<unsafe extern "C" fn(A) -> Ret> for unsafe extern "C" fn(A) -> Ret`
- `impl<Ret, A, B, C, D, E> PartialEq<unsafe fn(A, B, C, D, E) -> Ret> for unsafe fn(A, B, C, D, E) -> Ret`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10021) => core/5e4b76f::array[0]::{{impl}}[493]::{{initializer}}[0] }, Slice([])) }]> for &'b [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<[B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9444) => core/5e4b76f::array[0]::{{impl}}[401]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<Ret, A, B, C, D, E, F, G> PartialEq<extern "C" fn(A, B, C, D, E, F, G) -> Ret> for extern "C" fn(A, B, C, D, E, F, G) -> Ret`
- `impl<Idx> PartialEq<RangeInclusive<Idx>> for RangeInclusive<Idx> where
  Idx: PartialEq<Idx>,`
- `impl<A, B, C, D> PartialEq<(A, B, C, D)> for (A, B, C, D) where
  A: PartialEq<A>,
  B: PartialEq<B>,
  C: PartialEq<C>,
  D: PartialEq<D> + ?Sized,`
- `impl PartialEq<char> for char`
- `impl<'a, 'b, A, B> PartialEq<&'b mut B> for &'a mut A where
  A: PartialEq<B> + ?Sized,
  B: ?Sized,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9544) => core/5e4b76f::array[0]::{{impl}}[417]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10273) => core/5e4b76f::array[0]::{{impl}}[533]::{{initializer}}[0] }, Slice([])) }]> for [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9644) => core/5e4b76f::array[0]::{{impl}}[433]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9869) => core/5e4b76f::array[0]::{{impl}}[469]::{{initializer}}[0] }, Slice([])) }]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9870) => core/5e4b76f::array[0]::{{impl}}[469]::{{initializer}}[1] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9209) => core/5e4b76f::array[0]::{{impl}}[364]::{{initializer}}[0] }, Slice([])) }]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9210) => core/5e4b76f::array[0]::{{impl}}[364]::{{initializer}}[1] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9977) => core/5e4b76f::array[0]::{{impl}}[486]::{{initializer}}[0] }, Slice([])) }]> for &'b [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<[B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9796) => core/5e4b76f::array[0]::{{impl}}[457]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9512) => core/5e4b76f::array[0]::{{impl}}[412]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b B> for &'a A where
  A: PartialEq<B> + ?Sized,
  B: ?Sized,`
- `impl<T> PartialEq<Discriminant<T>> for Discriminant<T>`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9493) => core/5e4b76f::array[0]::{{impl}}[409]::{{initializer}}[0] }, Slice([])) }]> for &'b [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9657) => core/5e4b76f::array[0]::{{impl}}[435]::{{initializer}}[0] }, Slice([])) }]> for [B] where
  B: PartialEq<A>,`
- `impl<T> PartialEq<Option<T>> for Option<T> where
  T: PartialEq<T>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9857) => core/5e4b76f::array[0]::{{impl}}[467]::{{initializer}}[0] }, Slice([])) }]> for &'b mut [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9473) => core/5e4b76f::array[0]::{{impl}}[406]::{{initializer}}[0] }, Slice([])) }]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9474) => core/5e4b76f::array[0]::{{impl}}[406]::{{initializer}}[1] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<Ret, A, B> PartialEq<unsafe extern "C" fn(A, B) -> Ret> for unsafe extern "C" fn(A, B) -> Ret`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9825) => core/5e4b76f::array[0]::{{impl}}[462]::{{initializer}}[0] }, Slice([])) }]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9826) => core/5e4b76f::array[0]::{{impl}}[462]::{{initializer}}[1] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10341) => core/5e4b76f::array[0]::{{impl}}[544]::{{initializer}}[0] }, Slice([])) }]> for &'b mut [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<[B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9928) => core/5e4b76f::array[0]::{{impl}}[478]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<Idx> PartialEq<Range<Idx>> for Range<Idx> where
  Idx: PartialEq<Idx>,`
- `impl<Ret, A, B, C, D, E, F, G, H, I> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9593) => core/5e4b76f::array[0]::{{impl}}[425]::{{initializer}}[0] }, Slice([])) }]> for &'b mut [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9253) => core/5e4b76f::array[0]::{{impl}}[371]::{{initializer}}[0] }, Slice([])) }]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9254) => core/5e4b76f::array[0]::{{impl}}[371]::{{initializer}}[1] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10493) => core/5e4b76f::array[0]::{{impl}}[568]::{{initializer}}[0] }, Slice([])) }]> for [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10089) => core/5e4b76f::array[0]::{{impl}}[504]::{{initializer}}[0] }, Slice([])) }]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10090) => core/5e4b76f::array[0]::{{impl}}[504]::{{initializer}}[1] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret`
- `impl<'a, 'b, A, B> PartialEq<[B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9532) => core/5e4b76f::array[0]::{{impl}}[415]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9488) => core/5e4b76f::array[0]::{{impl}}[408]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret`
- `impl<'a, 'b, A, B> PartialEq<[B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10412) => core/5e4b76f::array[0]::{{impl}}[555]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10060) => core/5e4b76f::array[0]::{{impl}}[499]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<Ret, A> PartialEq<fn(A) -> Ret> for fn(A) -> Ret`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10505) => core/5e4b76f::array[0]::{{impl}}[570]::{{initializer}}[0] }, Slice([])) }]> for &'b [B] where
  B: PartialEq<A>,`
- `impl<Ret, A, B, C, D, E, F, G, H, I> PartialEq<fn(A, B, C, D, E, F, G, H, I) -> Ret> for fn(A, B, C, D, E, F, G, H, I) -> Ret`
- `impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10644) => core/5e4b76f::array[0]::{{impl}}[592]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10229) => core/5e4b76f::array[0]::{{impl}}[526]::{{initializer}}[0] }, Slice([])) }]> for [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9341) => core/5e4b76f::array[0]::{{impl}}[385]::{{initializer}}[0] }, Slice([])) }]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9342) => core/5e4b76f::array[0]::{{impl}}[385]::{{initializer}}[1] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<Idx> PartialEq<RangeToInclusive<Idx>> for RangeToInclusive<Idx> where
  Idx: PartialEq<Idx>,`
- `impl<A, B> PartialEq<(A, B)> for (A, B) where
  A: PartialEq<A>,
  B: PartialEq<B> + ?Sized,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10309) => core/5e4b76f::array[0]::{{impl}}[539]::{{initializer}}[0] }, Slice([])) }]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10310) => core/5e4b76f::array[0]::{{impl}}[539]::{{initializer}}[1] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl PartialEq<Ordering> for Ordering`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9349) => core/5e4b76f::array[0]::{{impl}}[386]::{{initializer}}[0] }, Slice([])) }]> for [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10121) => core/5e4b76f::array[0]::{{impl}}[509]::{{initializer}}[0] }, Slice([])) }]> for &'b mut [B] where
  B: PartialEq<A>,`
- `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<A>,
  B: PartialEq<B>,
  C: PartialEq<C>,
  D: PartialEq<D>,
  E: PartialEq<E>,
  F: PartialEq<F>,
  G: PartialEq<G>,
  H: PartialEq<H>,
  I: PartialEq<I>,
  J: PartialEq<J>,
  K: PartialEq<K> + ?Sized,`
- `impl<Ret, A, B, C, D> PartialEq<unsafe extern "C" fn(A, B, C, D) -> Ret> for unsafe extern "C" fn(A, B, C, D) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialEq<unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret`
- `impl PartialEq<u64> for u64`
- `impl<T, E> PartialEq<Result<T, E>> for Result<T, E> where
  E: PartialEq<E>,
  T: PartialEq<T>,`
- `impl<Ret, A, B> PartialEq<fn(A, B) -> Ret> for fn(A, B) -> Ret`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10165) => core/5e4b76f::array[0]::{{impl}}[516]::{{initializer}}[0] }, Slice([])) }]> for &'b mut [B] where
  B: PartialEq<A>,`
- `impl<Ret, A, B, C, D, E, F, G> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret`
- `impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10424) => core/5e4b76f::array[0]::{{impl}}[557]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9896) => core/5e4b76f::array[0]::{{impl}}[473]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<Ret, A, B, C, D, E> PartialEq<extern "C" fn(A, B, C, D, E) -> Ret> for extern "C" fn(A, B, C, D, E) -> Ret`
- `impl PartialEq<ParseBoolError> for ParseBoolError`
- `impl<Ret, A, B, C> PartialEq<unsafe extern "C" fn(A, B, C, ...) -> Ret> for unsafe extern "C" fn(A, B, C, ...) -> Ret`
- `impl<'a, 'b, A, B> PartialEq<[B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10280) => core/5e4b76f::array[0]::{{impl}}[534]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl PartialEq<FpCategory> for FpCategory`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9637) => core/5e4b76f::array[0]::{{impl}}[432]::{{initializer}}[0] }, Slice([])) }]> for &'b mut [B] where
  B: PartialEq<A>,`
- `impl<Ret, A, B, C, D, E, F, G, H> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret`
- `impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10336) => core/5e4b76f::array[0]::{{impl}}[543]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10436) => core/5e4b76f::array[0]::{{impl}}[559]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9813) => core/5e4b76f::array[0]::{{impl}}[460]::{{initializer}}[0] }, Slice([])) }]> for &'b mut [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10028) => core/5e4b76f::array[0]::{{impl}}[494]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10573) => core/5e4b76f::array[0]::{{impl}}[581]::{{initializer}}[0] }, Slice([])) }]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10574) => core/5e4b76f::array[0]::{{impl}}[581]::{{initializer}}[1] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<T> PartialEq<*const T> for *const T where
  T: ?Sized,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9581) => core/5e4b76f::array[0]::{{impl}}[423]::{{initializer}}[0] }, Slice([])) }]> for &'b [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10209) => core/5e4b76f::array[0]::{{impl}}[523]::{{initializer}}[0] }, Slice([])) }]> for &'b mut [B] where
  B: PartialEq<A>,`
- `impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret`
- `impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10160) => core/5e4b76f::array[0]::{{impl}}[515]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9537) => core/5e4b76f::array[0]::{{impl}}[416]::{{initializer}}[0] }, Slice([])) }]> for &'b [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9808) => core/5e4b76f::array[0]::{{impl}}[459]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10104) => core/5e4b76f::array[0]::{{impl}}[506]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9693) => core/5e4b76f::array[0]::{{impl}}[441]::{{initializer}}[0] }, Slice([])) }]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9694) => core/5e4b76f::array[0]::{{impl}}[441]::{{initializer}}[1] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl PartialEq<u16> for u16`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9261) => core/5e4b76f::array[0]::{{impl}}[372]::{{initializer}}[0] }, Slice([])) }]> for [B] where
  B: PartialEq<A>,`
- `impl<T> PartialEq<Cell<T>> for Cell<T> where
  T: Copy + PartialEq<T>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9769) => core/5e4b76f::array[0]::{{impl}}[453]::{{initializer}}[0] }, Slice([])) }]> for &'b mut [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10204) => core/5e4b76f::array[0]::{{impl}}[522]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10392) => core/5e4b76f::array[0]::{{impl}}[552]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialEq<unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret`
- `impl<'a, 'b, A, B> PartialEq<[B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9400) => core/5e4b76f::array[0]::{{impl}}[394]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9864) => core/5e4b76f::array[0]::{{impl}}[468]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10605) => core/5e4b76f::array[0]::{{impl}}[586]::{{initializer}}[0] }, Slice([])) }]> for &'b mut [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<[B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9752) => core/5e4b76f::array[0]::{{impl}}[450]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9965) => core/5e4b76f::array[0]::{{impl}}[484]::{{initializer}}[0] }, Slice([])) }]> for [B] where
  B: PartialEq<A>,`
- `impl<Ret> PartialEq<extern "C" fn() -> Ret> for extern "C" fn() -> Ret`
- `impl<'a, 'b, A, B> PartialEq<[B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9576) => core/5e4b76f::array[0]::{{impl}}[422]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9613) => core/5e4b76f::array[0]::{{impl}}[428]::{{initializer}}[0] }, Slice([])) }]> for [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9725) => core/5e4b76f::array[0]::{{impl}}[446]::{{initializer}}[0] }, Slice([])) }]> for &'b mut [B] where
  B: PartialEq<A>,`
- `impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialEq<fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for fn(A, B, C, D, E, F, G, H, I, J) -> Ret`
- `impl<'a, 'b, A, B> PartialEq<[B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9972) => core/5e4b76f::array[0]::{{impl}}[485]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<Ret, A, B, C, D> PartialEq<extern "C" fn(A, B, C, D) -> Ret> for extern "C" fn(A, B, C, D) -> Ret`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9649) => core/5e4b76f::array[0]::{{impl}}[434]::{{initializer}}[0] }, Slice([])) }]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9650) => core/5e4b76f::array[0]::{{impl}}[434]::{{initializer}}[1] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10556) => core/5e4b76f::array[0]::{{impl}}[578]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10456) => core/5e4b76f::array[0]::{{impl}}[562]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9764) => core/5e4b76f::array[0]::{{impl}}[452]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9292) => core/5e4b76f::array[0]::{{impl}}[377]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `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<A>,
  B: PartialEq<B>,
  C: PartialEq<C>,
  D: PartialEq<D>,
  E: PartialEq<E>,
  F: PartialEq<F>,
  G: PartialEq<G>,
  H: PartialEq<H> + ?Sized,`
- `impl<T> PartialEq<PhantomData<T>> for PhantomData<T> where
  T: ?Sized,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10429) => core/5e4b76f::array[0]::{{impl}}[558]::{{initializer}}[0] }, Slice([])) }]> for &'b mut [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10216) => core/5e4b76f::array[0]::{{impl}}[524]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9273) => core/5e4b76f::array[0]::{{impl}}[374]::{{initializer}}[0] }, Slice([])) }]> for &'b [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9561) => core/5e4b76f::array[0]::{{impl}}[420]::{{initializer}}[0] }, Slice([])) }]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9562) => core/5e4b76f::array[0]::{{impl}}[420]::{{initializer}}[1] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9732) => core/5e4b76f::array[0]::{{impl}}[447]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10248) => core/5e4b76f::array[0]::{{impl}}[529]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9620) => core/5e4b76f::array[0]::{{impl}}[429]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9437) => core/5e4b76f::array[0]::{{impl}}[400]::{{initializer}}[0] }, Slice([])) }]> for [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9468) => core/5e4b76f::array[0]::{{impl}}[405]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9801) => core/5e4b76f::array[0]::{{impl}}[458]::{{initializer}}[0] }, Slice([])) }]> for &'b [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9373) => core/5e4b76f::array[0]::{{impl}}[390]::{{initializer}}[0] }, Slice([])) }]> for &'b mut [B] where
  B: PartialEq<A>,`
- `impl<Ret, A, B, C, D, E> PartialEq<unsafe extern "C" fn(A, B, C, D, E) -> Ret> for unsafe extern "C" fn(A, B, C, D, E) -> Ret`
- `impl<Ret, A, B, C, D> PartialEq<unsafe extern "C" fn(A, B, C, D, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, ...) -> Ret`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10009) => core/5e4b76f::array[0]::{{impl}}[491]::{{initializer}}[0] }, Slice([])) }]> for [B] where
  B: PartialEq<A>,`
- `impl<Ret, A, B, C, D, E, F, G, H> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H) -> Ret`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10537) => core/5e4b76f::array[0]::{{impl}}[575]::{{initializer}}[0] }, Slice([])) }]> for [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<[B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10544) => core/5e4b76f::array[0]::{{impl}}[576]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9385) => core/5e4b76f::array[0]::{{impl}}[392]::{{initializer}}[0] }, Slice([])) }]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9386) => core/5e4b76f::array[0]::{{impl}}[392]::{{initializer}}[1] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9940) => core/5e4b76f::array[0]::{{impl}}[480]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9461) => core/5e4b76f::array[0]::{{impl}}[404]::{{initializer}}[0] }, Slice([])) }]> for &'b mut [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9297) => core/5e4b76f::array[0]::{{impl}}[378]::{{initializer}}[0] }, Slice([])) }]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9298) => core/5e4b76f::array[0]::{{impl}}[378]::{{initializer}}[1] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10116) => core/5e4b76f::array[0]::{{impl}}[508]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9517) => core/5e4b76f::array[0]::{{impl}}[413]::{{initializer}}[0] }, Slice([])) }]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9518) => core/5e4b76f::array[0]::{{impl}}[413]::{{initializer}}[1] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10109) => core/5e4b76f::array[0]::{{impl}}[507]::{{initializer}}[0] }, Slice([])) }]> for &'b [B] where
  B: PartialEq<A>,`
- `impl PartialEq<CharTryFromError> for CharTryFromError`
- `impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10468) => core/5e4b76f::array[0]::{{impl}}[564]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9217) => core/5e4b76f::array[0]::{{impl}}[365]::{{initializer}}[0] }, Slice([])) }]> for [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9945) => core/5e4b76f::array[0]::{{impl}}[481]::{{initializer}}[0] }, Slice([])) }]> for &'b mut [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10292) => core/5e4b76f::array[0]::{{impl}}[536]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10077) => core/5e4b76f::array[0]::{{impl}}[502]::{{initializer}}[0] }, Slice([])) }]> for &'b mut [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9681) => core/5e4b76f::array[0]::{{impl}}[439]::{{initializer}}[0] }, Slice([])) }]> for &'b mut [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9600) => core/5e4b76f::array[0]::{{impl}}[426]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G> PartialEq<extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9336) => core/5e4b76f::array[0]::{{impl}}[384]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10016) => core/5e4b76f::array[0]::{{impl}}[492]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10600) => core/5e4b76f::array[0]::{{impl}}[585]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9525) => core/5e4b76f::array[0]::{{impl}}[414]::{{initializer}}[0] }, Slice([])) }]> for [B] where
  B: PartialEq<A>,`
- `impl<A> PartialEq<(A,)> for (A,) where
  A: PartialEq<A> + ?Sized,`
- `impl<'a, 'b, A, B> PartialEq<[B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9664) => core/5e4b76f::array[0]::{{impl}}[436]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<Ret, A, B, C, D, E, F, G, H, I> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret`
- `impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9720) => core/5e4b76f::array[0]::{{impl}}[445]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl PartialEq<Utf8Error> for Utf8Error`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9781) => core/5e4b76f::array[0]::{{impl}}[455]::{{initializer}}[0] }, Slice([])) }]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9782) => core/5e4b76f::array[0]::{{impl}}[455]::{{initializer}}[1] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9845) => core/5e4b76f::array[0]::{{impl}}[465]::{{initializer}}[0] }, Slice([])) }]> for &'b [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9996) => core/5e4b76f::array[0]::{{impl}}[489]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10172) => core/5e4b76f::array[0]::{{impl}}[517]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9625) => core/5e4b76f::array[0]::{{impl}}[430]::{{initializer}}[0] }, Slice([])) }]> for &'b [B] where
  B: PartialEq<A>,`
- `impl PartialEq<isize> for isize`
- `impl<Ret, A> PartialEq<unsafe extern "C" fn(A, ...) -> Ret> for unsafe extern "C" fn(A, ...) -> Ret`
- `impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9368) => core/5e4b76f::array[0]::{{impl}}[389]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10185) => core/5e4b76f::array[0]::{{impl}}[519]::{{initializer}}[0] }, Slice([])) }]> for [B] where
  B: PartialEq<A>,`
- `impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialEq<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret`
- `impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9632) => core/5e4b76f::array[0]::{{impl}}[431]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10329) => core/5e4b76f::array[0]::{{impl}}[542]::{{initializer}}[0] }, Slice([])) }]> for &'b [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10373) => core/5e4b76f::array[0]::{{impl}}[549]::{{initializer}}[0] }, Slice([])) }]> for &'b [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9429) => core/5e4b76f::array[0]::{{impl}}[399]::{{initializer}}[0] }, Slice([])) }]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9430) => core/5e4b76f::array[0]::{{impl}}[399]::{{initializer}}[1] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9268) => core/5e4b76f::array[0]::{{impl}}[373]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10361) => core/5e4b76f::array[0]::{{impl}}[547]::{{initializer}}[0] }, Slice([])) }]> for [B] where
  B: PartialEq<A>,`
- `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<A>,
  B: PartialEq<B>,
  C: PartialEq<C>,
  D: PartialEq<D>,
  E: PartialEq<E>,
  F: PartialEq<F>,
  G: PartialEq<G>,
  H: PartialEq<H>,
  I: PartialEq<I>,
  J: PartialEq<J>,
  K: PartialEq<K>,
  L: PartialEq<L> + ?Sized,`
- `impl<'a, 'b, A, B> PartialEq<[A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9789) => core/5e4b76f::array[0]::{{impl}}[456]::{{initializer}}[0] }, Slice([])) }]> for [B] where
  B: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:10304) => core/5e4b76f::array[0]::{{impl}}[538]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret`
- `impl<'a, 'b, A, B> PartialEq<[B]> for [A; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(1), node: DefIndex(1:9356) => core/5e4b76f::array[0]::{{impl}}[387]::{{initializer}}[0] }, Slice([])) }] where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2133) => alloc/9cd1d79::vec[0]::{{impl}}[163]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2147) => alloc/9cd1d79::vec[0]::{{impl}}[165]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<Vec<B>> for Cow<'a, [A]> where
  A: Clone + PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2775) => alloc/9cd1d79::vec_deque[0]::{{impl}}[146]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2685) => alloc/9cd1d79::vec_deque[0]::{{impl}}[131]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2469) => alloc/9cd1d79::vec_deque[0]::{{impl}}[95]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2196) => alloc/9cd1d79::vec[0]::{{impl}}[172]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2049) => alloc/9cd1d79::vec[0]::{{impl}}[151]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2457) => alloc/9cd1d79::vec_deque[0]::{{impl}}[93]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:1853) => alloc/9cd1d79::vec[0]::{{impl}}[123]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2313) => alloc/9cd1d79::vec_deque[0]::{{impl}}[69]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2028) => alloc/9cd1d79::vec[0]::{{impl}}[148]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2397) => alloc/9cd1d79::vec_deque[0]::{{impl}}[83]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2140) => alloc/9cd1d79::vec[0]::{{impl}}[164]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2168) => alloc/9cd1d79::vec[0]::{{impl}}[168]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2070) => alloc/9cd1d79::vec[0]::{{impl}}[154]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b> PartialEq<str> for String`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2541) => alloc/9cd1d79::vec_deque[0]::{{impl}}[107]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2361) => alloc/9cd1d79::vec_deque[0]::{{impl}}[77]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:1881) => alloc/9cd1d79::vec[0]::{{impl}}[127]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:1832) => alloc/9cd1d79::vec[0]::{{impl}}[120]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b> PartialEq<Cow<'a, str>> for &'b str`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2451) => alloc/9cd1d79::vec_deque[0]::{{impl}}[92]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2295) => alloc/9cd1d79::vec_deque[0]::{{impl}}[66]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2000) => alloc/9cd1d79::vec[0]::{{impl}}[144]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2349) => alloc/9cd1d79::vec_deque[0]::{{impl}}[75]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2307) => alloc/9cd1d79::vec_deque[0]::{{impl}}[68]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:1937) => alloc/9cd1d79::vec[0]::{{impl}}[135]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:1755) => alloc/9cd1d79::vec[0]::{{impl}}[109]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:1888) => alloc/9cd1d79::vec[0]::{{impl}}[128]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:1930) => alloc/9cd1d79::vec[0]::{{impl}}[134]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2439) => alloc/9cd1d79::vec_deque[0]::{{impl}}[90]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for Cow<'a, [A]> where
  A: Clone + PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2203) => alloc/9cd1d79::vec[0]::{{impl}}[173]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2601) => alloc/9cd1d79::vec_deque[0]::{{impl}}[117]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2619) => alloc/9cd1d79::vec_deque[0]::{{impl}}[120]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2035) => alloc/9cd1d79::vec[0]::{{impl}}[149]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<T> PartialEq<BTreeSet<T>> for BTreeSet<T> where
  T: PartialEq<T>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2337) => alloc/9cd1d79::vec_deque[0]::{{impl}}[73]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2325) => alloc/9cd1d79::vec_deque[0]::{{impl}}[71]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2763) => alloc/9cd1d79::vec_deque[0]::{{impl}}[144]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2793) => alloc/9cd1d79::vec_deque[0]::{{impl}}[149]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:1916) => alloc/9cd1d79::vec[0]::{{impl}}[132]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2084) => alloc/9cd1d79::vec[0]::{{impl}}[156]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2577) => alloc/9cd1d79::vec_deque[0]::{{impl}}[113]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<Vec<B>> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:1804) => alloc/9cd1d79::vec[0]::{{impl}}[116]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:1902) => alloc/9cd1d79::vec[0]::{{impl}}[130]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b> PartialEq<Cow<'a, str>> for str`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2119) => alloc/9cd1d79::vec[0]::{{impl}}[161]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2289) => alloc/9cd1d79::vec_deque[0]::{{impl}}[65]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<K, V> PartialEq<BTreeMap<K, V>> for BTreeMap<K, V> where
  K: PartialEq<K>,
  V: PartialEq<V>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2697) => alloc/9cd1d79::vec_deque[0]::{{impl}}[133]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2259) => alloc/9cd1d79::vec_deque[0]::{{impl}}[60]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2409) => alloc/9cd1d79::vec_deque[0]::{{impl}}[85]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2189) => alloc/9cd1d79::vec[0]::{{impl}}[171]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2817) => alloc/9cd1d79::vec_deque[0]::{{impl}}[153]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:1979) => alloc/9cd1d79::vec[0]::{{impl}}[141]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2433) => alloc/9cd1d79::vec_deque[0]::{{impl}}[89]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b> PartialEq<String> for &'a str`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2385) => alloc/9cd1d79::vec_deque[0]::{{impl}}[81]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2643) => alloc/9cd1d79::vec_deque[0]::{{impl}}[124]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2112) => alloc/9cd1d79::vec[0]::{{impl}}[160]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:1748) => alloc/9cd1d79::vec[0]::{{impl}}[108]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2559) => alloc/9cd1d79::vec_deque[0]::{{impl}}[110]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:1769) => alloc/9cd1d79::vec[0]::{{impl}}[111]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2799) => alloc/9cd1d79::vec_deque[0]::{{impl}}[150]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<T> PartialEq<Rc<T>> for Rc<T> where
  T: PartialEq<T> + ?Sized,`
- `impl<'a, 'b> PartialEq<String> for Cow<'a, str>`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2182) => alloc/9cd1d79::vec[0]::{{impl}}[170]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, B, C> PartialEq<Cow<'b, C>> for Cow<'a, B> where
  B: PartialEq<C> + ToOwned + ?Sized,
  C: ToOwned + ?Sized,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:1818) => alloc/9cd1d79::vec[0]::{{impl}}[118]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:1986) => alloc/9cd1d79::vec[0]::{{impl}}[142]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<A> PartialEq<VecDeque<A>> for VecDeque<A> where
  A: PartialEq<A>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2691) => alloc/9cd1d79::vec_deque[0]::{{impl}}[132]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2667) => alloc/9cd1d79::vec_deque[0]::{{impl}}[128]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:1993) => alloc/9cd1d79::vec[0]::{{impl}}[143]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2673) => alloc/9cd1d79::vec_deque[0]::{{impl}}[129]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<T> PartialEq<LinkedList<T>> for LinkedList<T> where
  T: PartialEq<T>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:1951) => alloc/9cd1d79::vec[0]::{{impl}}[137]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2757) => alloc/9cd1d79::vec_deque[0]::{{impl}}[143]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2589) => alloc/9cd1d79::vec_deque[0]::{{impl}}[115]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl PartialEq<String> for String`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:1860) => alloc/9cd1d79::vec[0]::{{impl}}[124]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl PartialEq<CannotReallocInPlace> for CannotReallocInPlace`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:1958) => alloc/9cd1d79::vec[0]::{{impl}}[138]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2277) => alloc/9cd1d79::vec_deque[0]::{{impl}}[63]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:1797) => alloc/9cd1d79::vec[0]::{{impl}}[115]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2379) => alloc/9cd1d79::vec_deque[0]::{{impl}}[80]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2126) => alloc/9cd1d79::vec[0]::{{impl}}[162]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:1811) => alloc/9cd1d79::vec[0]::{{impl}}[117]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<T> PartialEq<Box<T>> for Box<T> where
  T: PartialEq<T> + ?Sized,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2715) => alloc/9cd1d79::vec_deque[0]::{{impl}}[136]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2175) => alloc/9cd1d79::vec[0]::{{impl}}[169]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2571) => alloc/9cd1d79::vec_deque[0]::{{impl}}[112]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2487) => alloc/9cd1d79::vec_deque[0]::{{impl}}[98]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2583) => alloc/9cd1d79::vec_deque[0]::{{impl}}[114]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2511) => alloc/9cd1d79::vec_deque[0]::{{impl}}[102]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2265) => alloc/9cd1d79::vec_deque[0]::{{impl}}[61]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:1783) => alloc/9cd1d79::vec[0]::{{impl}}[113]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:1825) => alloc/9cd1d79::vec[0]::{{impl}}[119]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2547) => alloc/9cd1d79::vec_deque[0]::{{impl}}[108]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2637) => alloc/9cd1d79::vec_deque[0]::{{impl}}[123]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2253) => alloc/9cd1d79::vec_deque[0]::{{impl}}[59]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2595) => alloc/9cd1d79::vec_deque[0]::{{impl}}[116]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2271) => alloc/9cd1d79::vec_deque[0]::{{impl}}[62]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2154) => alloc/9cd1d79::vec[0]::{{impl}}[166]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2499) => alloc/9cd1d79::vec_deque[0]::{{impl}}[100]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2091) => alloc/9cd1d79::vec[0]::{{impl}}[157]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2613) => alloc/9cd1d79::vec_deque[0]::{{impl}}[119]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2427) => alloc/9cd1d79::vec_deque[0]::{{impl}}[88]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:1867) => alloc/9cd1d79::vec[0]::{{impl}}[125]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl PartialEq<ParseError> for ParseError`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2505) => alloc/9cd1d79::vec_deque[0]::{{impl}}[101]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2829) => alloc/9cd1d79::vec_deque[0]::{{impl}}[155]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2343) => alloc/9cd1d79::vec_deque[0]::{{impl}}[74]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2529) => alloc/9cd1d79::vec_deque[0]::{{impl}}[105]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2367) => alloc/9cd1d79::vec_deque[0]::{{impl}}[78]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2247) => alloc/9cd1d79::vec_deque[0]::{{impl}}[58]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2811) => alloc/9cd1d79::vec_deque[0]::{{impl}}[152]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2445) => alloc/9cd1d79::vec_deque[0]::{{impl}}[91]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2769) => alloc/9cd1d79::vec_deque[0]::{{impl}}[145]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2077) => alloc/9cd1d79::vec[0]::{{impl}}[155]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2703) => alloc/9cd1d79::vec_deque[0]::{{impl}}[134]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2161) => alloc/9cd1d79::vec[0]::{{impl}}[167]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<T> PartialEq<Bound<T>> for Bound<T> where
  T: PartialEq<T>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2301) => alloc/9cd1d79::vec_deque[0]::{{impl}}[67]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b> PartialEq<str> for Cow<'a, str>`
- `impl<'a, 'b, A, B> PartialEq<&'b [B]> for Cow<'a, [A]> where
  A: Clone + PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2679) => alloc/9cd1d79::vec_deque[0]::{{impl}}[130]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:1776) => alloc/9cd1d79::vec[0]::{{impl}}[112]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2745) => alloc/9cd1d79::vec_deque[0]::{{impl}}[141]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b> PartialEq<String> for str`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2709) => alloc/9cd1d79::vec_deque[0]::{{impl}}[135]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2105) => alloc/9cd1d79::vec[0]::{{impl}}[159]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2607) => alloc/9cd1d79::vec_deque[0]::{{impl}}[118]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2042) => alloc/9cd1d79::vec[0]::{{impl}}[150]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:1846) => alloc/9cd1d79::vec[0]::{{impl}}[122]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:1839) => alloc/9cd1d79::vec[0]::{{impl}}[121]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl PartialEq<AllocErr> for AllocErr`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2823) => alloc/9cd1d79::vec_deque[0]::{{impl}}[154]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2721) => alloc/9cd1d79::vec_deque[0]::{{impl}}[137]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2625) => alloc/9cd1d79::vec_deque[0]::{{impl}}[121]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2649) => alloc/9cd1d79::vec_deque[0]::{{impl}}[125]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<Vec<B>> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2331) => alloc/9cd1d79::vec_deque[0]::{{impl}}[72]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2631) => alloc/9cd1d79::vec_deque[0]::{{impl}}[122]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2007) => alloc/9cd1d79::vec[0]::{{impl}}[145]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2063) => alloc/9cd1d79::vec[0]::{{impl}}[153]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2739) => alloc/9cd1d79::vec_deque[0]::{{impl}}[140]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2553) => alloc/9cd1d79::vec_deque[0]::{{impl}}[109]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2523) => alloc/9cd1d79::vec_deque[0]::{{impl}}[104]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:1874) => alloc/9cd1d79::vec[0]::{{impl}}[126]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2014) => alloc/9cd1d79::vec[0]::{{impl}}[146]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2727) => alloc/9cd1d79::vec_deque[0]::{{impl}}[138]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:1944) => alloc/9cd1d79::vec[0]::{{impl}}[136]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:1909) => alloc/9cd1d79::vec[0]::{{impl}}[131]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2056) => alloc/9cd1d79::vec[0]::{{impl}}[152]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2535) => alloc/9cd1d79::vec_deque[0]::{{impl}}[106]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2655) => alloc/9cd1d79::vec_deque[0]::{{impl}}[126]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2751) => alloc/9cd1d79::vec_deque[0]::{{impl}}[142]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:1790) => alloc/9cd1d79::vec[0]::{{impl}}[114]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2283) => alloc/9cd1d79::vec_deque[0]::{{impl}}[64]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2781) => alloc/9cd1d79::vec_deque[0]::{{impl}}[147]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2517) => alloc/9cd1d79::vec_deque[0]::{{impl}}[103]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:1965) => alloc/9cd1d79::vec[0]::{{impl}}[139]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b> PartialEq<&'a str> for String`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:1895) => alloc/9cd1d79::vec[0]::{{impl}}[129]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2415) => alloc/9cd1d79::vec_deque[0]::{{impl}}[86]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2733) => alloc/9cd1d79::vec_deque[0]::{{impl}}[139]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2098) => alloc/9cd1d79::vec[0]::{{impl}}[158]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2421) => alloc/9cd1d79::vec_deque[0]::{{impl}}[87]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2463) => alloc/9cd1d79::vec_deque[0]::{{impl}}[94]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:1762) => alloc/9cd1d79::vec[0]::{{impl}}[110]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2481) => alloc/9cd1d79::vec_deque[0]::{{impl}}[97]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2787) => alloc/9cd1d79::vec_deque[0]::{{impl}}[148]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b> PartialEq<&'b str> for Cow<'a, str>`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2373) => alloc/9cd1d79::vec_deque[0]::{{impl}}[79]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2493) => alloc/9cd1d79::vec_deque[0]::{{impl}}[99]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2661) => alloc/9cd1d79::vec_deque[0]::{{impl}}[127]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:1972) => alloc/9cd1d79::vec[0]::{{impl}}[140]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<T> PartialEq<Arc<T>> for Arc<T> where
  T: PartialEq<T> + ?Sized,`
- `impl<'a, 'b> PartialEq<Cow<'a, str>> for String`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2805) => alloc/9cd1d79::vec_deque[0]::{{impl}}[151]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2355) => alloc/9cd1d79::vec_deque[0]::{{impl}}[76]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:1923) => alloc/9cd1d79::vec[0]::{{impl}}[133]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2403) => alloc/9cd1d79::vec_deque[0]::{{impl}}[84]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2319) => alloc/9cd1d79::vec_deque[0]::{{impl}}[70]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<[B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2391) => alloc/9cd1d79::vec_deque[0]::{{impl}}[82]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl PartialEq<Layout> for Layout`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2475) => alloc/9cd1d79::vec_deque[0]::{{impl}}[96]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2021) => alloc/9cd1d79::vec[0]::{{impl}}[147]::{{initializer}}[0] }, Slice([])) }]> for Vec<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2565) => alloc/9cd1d79::vec_deque[0]::{{impl}}[111]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl<'a, 'b, A, B> PartialEq<&'b mut [B; Const { ty: usize, val: Unevaluated(DefId { krate: CrateNum(3), node: DefIndex(1:2835) => alloc/9cd1d79::vec_deque[0]::{{impl}}[156]::{{initializer}}[0] }, Slice([])) }]> for VecDeque<A> where
  A: PartialEq<B>,`
- `impl PartialEq for LocalKeyState`
- `impl PartialEq for ThreadId`
- `impl<K, V, S> PartialEq for HashMap<K, V, S> where
  K: Eq + Hash,
  V: PartialEq,
  S: BuildHasher,`
- `impl<T, S> PartialEq for HashSet<T, S> where
  T: Eq + Hash,
  S: BuildHasher,`
- `impl PartialEq for VarError`
- `impl PartialEq for CString`
- `impl PartialEq for NulError`
- `impl PartialEq for FromBytesWithNulError`
- `impl PartialEq for IntoStringError`
- `impl PartialEq for CStr`
- `impl PartialEq for OsString`
- `impl PartialEq<str> for OsString`
- `impl PartialEq<OsString> for str`
- `impl PartialEq for OsStr`
- `impl PartialEq<str> for OsStr`
- `impl PartialEq<OsStr> for str`
- `impl<'a, 'b> PartialEq<OsStr> for OsString`
- `impl<'a, 'b> PartialEq<OsString> for OsStr`
- `impl<'a, 'b> PartialEq<&'a OsStr> for OsString`
- `impl<'a, 'b> PartialEq<OsString> for &'a OsStr`
- `impl<'a, 'b> PartialEq<OsStr> for Cow<'a, OsStr>`
- `impl<'a, 'b> PartialEq<Cow<'a, OsStr>> for OsStr`
- `impl<'a, 'b> PartialEq<&'b OsStr> for Cow<'a, OsStr>`
- `impl<'a, 'b> PartialEq<Cow<'a, OsStr>> for &'b OsStr`
- `impl<'a, 'b> PartialEq<OsString> for Cow<'a, OsStr>`
- `impl<'a, 'b> PartialEq<Cow<'a, OsStr>> for OsString`
- `impl PartialEq for Permissions`
- `impl PartialEq for FileType`
- `impl PartialEq for ErrorKind`
- `impl PartialEq for SeekFrom`
- `impl PartialEq for IpAddr`
- `impl PartialEq for Ipv6MulticastScope`
- `impl PartialEq for Ipv4Addr`
- `impl PartialEq<Ipv4Addr> for IpAddr`
- `impl PartialEq<IpAddr> for Ipv4Addr`
- `impl PartialEq for Ipv6Addr`
- `impl PartialEq<IpAddr> for Ipv6Addr`
- `impl PartialEq<Ipv6Addr> for IpAddr`
- `impl PartialEq for SocketAddr`
- `impl PartialEq for SocketAddrV4`
- `impl PartialEq for SocketAddrV6`
- `impl PartialEq for AddrParseError`
- `impl PartialEq for Shutdown`
- `impl<'a> PartialEq for Prefix<'a>`
- `impl<'a> PartialEq for PrefixComponent<'a>`
- `impl<'a> PartialEq for Component<'a>`
- `impl<'a> PartialEq for Components<'a>`
- `impl PartialEq for PathBuf`
- `impl PartialEq for StripPrefixError`
- `impl PartialEq for Path`
- `impl<'a, 'b> PartialEq<Path> for PathBuf`
- `impl<'a, 'b> PartialEq<PathBuf> for Path`
- `impl<'a, 'b> PartialEq<&'a Path> for PathBuf`
- `impl<'a, 'b> PartialEq<PathBuf> for &'a Path`
- `impl<'a, 'b> PartialEq<Path> for Cow<'a, Path>`
- `impl<'a, 'b> PartialEq<Cow<'a, Path>> for Path`
- `impl<'a, 'b> PartialEq<&'b Path> for Cow<'a, Path>`
- `impl<'a, 'b> PartialEq<Cow<'a, Path>> for &'b Path`
- `impl<'a, 'b> PartialEq<PathBuf> for Cow<'a, Path>`
- `impl<'a, 'b> PartialEq<Cow<'a, Path>> for PathBuf`
- `impl<'a, 'b> PartialEq<OsStr> for PathBuf`
- `impl<'a, 'b> PartialEq<PathBuf> for OsStr`
- `impl<'a, 'b> PartialEq<&'a OsStr> for PathBuf`
- `impl<'a, 'b> PartialEq<PathBuf> for &'a OsStr`
- `impl<'a, 'b> PartialEq<Cow<'a, OsStr>> for PathBuf`
- `impl<'a, 'b> PartialEq<PathBuf> for Cow<'a, OsStr>`
- `impl<'a, 'b> PartialEq<OsString> for PathBuf`
- `impl<'a, 'b> PartialEq<PathBuf> for OsString`
- `impl<'a, 'b> PartialEq<OsStr> for Path`
- `impl<'a, 'b> PartialEq<Path> for OsStr`
- `impl<'a, 'b> PartialEq<&'a OsStr> for Path`
- `impl<'a, 'b> PartialEq<Path> for &'a OsStr`
- `impl<'a, 'b> PartialEq<Cow<'a, OsStr>> for Path`
- `impl<'a, 'b> PartialEq<Path> for Cow<'a, OsStr>`
- `impl<'a, 'b> PartialEq<OsString> for Path`
- `impl<'a, 'b> PartialEq<Path> for OsString`
- `impl<'a, 'b> PartialEq<OsStr> for &'a Path`
- `impl<'a, 'b> PartialEq<&'a Path> for OsStr`
- `impl<'a, 'b> PartialEq<Cow<'b, OsStr>> for &'a Path`
- `impl<'a, 'b> PartialEq<&'a Path> for Cow<'b, OsStr>`
- `impl<'a, 'b> PartialEq<OsString> for &'a Path`
- `impl<'a, 'b> PartialEq<&'a Path> for OsString`
- `impl<'a, 'b> PartialEq<OsStr> for Cow<'a, Path>`
- `impl<'a, 'b> PartialEq<Cow<'a, Path>> for OsStr`
- `impl<'a, 'b> PartialEq<&'b OsStr> for Cow<'a, Path>`
- `impl<'a, 'b> PartialEq<Cow<'a, Path>> for &'b OsStr`
- `impl<'a, 'b> PartialEq<OsString> for Cow<'a, Path>`
- `impl<'a, 'b> PartialEq<Cow<'a, Path>> for OsString`
- `impl PartialEq for Output`
- `impl PartialEq for ExitStatus`
- `impl<T: PartialEq> PartialEq for SendError<T>`
- `impl PartialEq for RecvError`
- `impl PartialEq for TryRecvError`
- `impl PartialEq for RecvTimeoutError`
- `impl<T: PartialEq> PartialEq for TrySendError<T>`
- `impl PartialEq for WaitTimeoutResult`
- `impl PartialEq for Duration`
- `impl PartialEq for Instant`
- `impl PartialEq for SystemTime`

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result
+
  Collapse/expand all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)