# Trait bitflags::__core::prelude::v1::PartialEq [−] [src]

    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>`.

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`.

This trait can be used with `#[derive]`.

# Examples

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

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

## Required Methods

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

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

## Provided Methods

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

This method tests for `!=`.

## Implementors

- `impl PartialEq for LocalKeyState`
- `impl<K, V, S> PartialEq for HashMap<K, V, S> where S: BuildHasher, K: Eq + Hash, V: PartialEq<V>`
- `impl<T, S> PartialEq for HashSet<T, S> where S: BuildHasher, T: Eq + Hash`
- `impl<A> PartialEq for LinkedList<A> where A: PartialEq<A>`
- `impl<A> PartialEq for VecDeque<A> where A: PartialEq<A>`
- `impl PartialEq for VarError`
- `impl PartialEq for CString`
- `impl PartialEq for NulError`
- `impl PartialEq for IntoStringError`
- `impl PartialEq for CStr`
- `impl PartialEq for OsString`
- `impl PartialEq for OsString`
- `impl PartialEq for str`
- `impl PartialEq for OsStr`
- `impl PartialEq for OsStr`
- `impl PartialEq for str`
- `impl<'a, 'b> PartialEq for OsString`
- `impl<'a, 'b> PartialEq for OsStr`
- `impl<'a, 'b> PartialEq for OsString`
- `impl<'a, 'b> PartialEq for &'a OsStr`
- `impl<'a, 'b> PartialEq for Cow<'a, OsStr>`
- `impl<'a, 'b> PartialEq for OsStr`
- `impl<'a, 'b> PartialEq for Cow<'a, OsStr>`
- `impl<'a, 'b> PartialEq for &'b OsStr`
- `impl<'a, 'b> PartialEq for Cow<'a, OsStr>`
- `impl<'a, 'b> PartialEq 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 for Ipv6Addr`
- `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 for PathBuf`
- `impl<'a, 'b> PartialEq for Path`
- `impl<'a, 'b> PartialEq for PathBuf`
- `impl<'a, 'b> PartialEq for &'a Path`
- `impl<'a, 'b> PartialEq for Cow<'a, Path>`
- `impl<'a, 'b> PartialEq for Path`
- `impl<'a, 'b> PartialEq for Cow<'a, Path>`
- `impl<'a, 'b> PartialEq for &'b Path`
- `impl<'a, 'b> PartialEq for Cow<'a, Path>`
- `impl<'a, 'b> PartialEq for PathBuf`
- `impl<'a, 'b> PartialEq for PathBuf`
- `impl<'a, 'b> PartialEq for OsStr`
- `impl<'a, 'b> PartialEq for PathBuf`
- `impl<'a, 'b> PartialEq for &'a OsStr`
- `impl<'a, 'b> PartialEq for PathBuf`
- `impl<'a, 'b> PartialEq for Cow<'a, OsStr>`
- `impl<'a, 'b> PartialEq for PathBuf`
- `impl<'a, 'b> PartialEq for OsString`
- `impl<'a, 'b> PartialEq for Path`
- `impl<'a, 'b> PartialEq for OsStr`
- `impl<'a, 'b> PartialEq for Path`
- `impl<'a, 'b> PartialEq for &'a OsStr`
- `impl<'a, 'b> PartialEq for Path`
- `impl<'a, 'b> PartialEq for Cow<'a, OsStr>`
- `impl<'a, 'b> PartialEq for Path`
- `impl<'a, 'b> PartialEq for OsString`
- `impl<'a, 'b> PartialEq for &'a Path`
- `impl<'a, 'b> PartialEq for OsStr`
- `impl<'a, 'b> PartialEq for &'a Path`
- `impl<'a, 'b> PartialEq for Cow<'b, OsStr>`
- `impl<'a, 'b> PartialEq for &'a Path`
- `impl<'a, 'b> PartialEq for OsString`
- `impl<'a, 'b> PartialEq for Cow<'a, Path>`
- `impl<'a, 'b> PartialEq for OsStr`
- `impl<'a, 'b> PartialEq for Cow<'a, Path>`
- `impl<'a, 'b> PartialEq for &'b OsStr`
- `impl<'a, 'b> PartialEq for Cow<'a, Path>`
- `impl<'a, 'b> PartialEq for OsString`
- `impl PartialEq for Output`
- `impl PartialEq for ExitStatus`
- `impl<T> PartialEq for SendError<T> where T: PartialEq<T>`
- `impl PartialEq for RecvError`
- `impl PartialEq for TryRecvError`
- `impl<T> PartialEq for TrySendError<T> where T: PartialEq<T>`
- `impl PartialEq for WaitTimeoutResult`
- `impl PartialEq for Duration`
- `impl PartialEq for Instant`
- `impl PartialEq for SystemTime`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Cow<'a, [A]> where A: Clone + PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Cow<'a, [A]> where A: Clone + PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Cow<'a, [A]> where A: Clone + PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for Vec<A> where A: PartialEq<B>`
- `impl PartialEq for Ordering`
- `impl PartialEq for ()`
- `impl PartialEq for bool`
- `impl PartialEq for char`
- `impl PartialEq for usize`
- `impl PartialEq for u8`
- `impl PartialEq for u16`
- `impl PartialEq for u32`
- `impl PartialEq for u64`
- `impl PartialEq for isize`
- `impl PartialEq for i8`
- `impl PartialEq for i16`
- `impl PartialEq for i32`
- `impl PartialEq for i64`
- `impl PartialEq for f32`
- `impl PartialEq for f64`
- `impl<'a, 'b, A, B> PartialEq for &'a A where B: ?Sized, A: PartialEq<B> + ?Sized`
- `impl<'a, 'b, A, B> PartialEq for &'a mut A where A: PartialEq<B> + ?Sized, B: ?Sized`
- `impl<'a, 'b, A, B> PartialEq for &'a A where A: PartialEq<B> + ?Sized, B: ?Sized`
- `impl<'a, 'b, A, B> PartialEq for &'a mut A where A: PartialEq<B> + ?Sized, B: ?Sized`
- `impl<T> PartialEq for Box<T> where T: PartialEq<T> + ?Sized`
- `impl PartialEq for TypeId`
- `impl PartialEq for RangeFull`
- `impl<Idx> PartialEq for Range<Idx> where Idx: PartialEq<Idx>`
- `impl<Idx> PartialEq for RangeFrom<Idx> where Idx: PartialEq<Idx>`
- `impl<Idx> PartialEq for RangeTo<Idx> where Idx: PartialEq<Idx>`
- `impl<Idx> PartialEq for RangeInclusive<Idx> where Idx: PartialEq<Idx>`
- `impl<Idx> PartialEq for RangeToInclusive<Idx> where Idx: PartialEq<Idx>`
- `impl PartialEq for DecodeUtf16Error`
- `impl<T> PartialEq for PhantomData<T> where T: ?Sized`
- `impl PartialEq for SearchStep`
- `impl<T> PartialEq for Cell<T> where T: Copy + PartialEq<T>`
- `impl PartialEq for BorrowState`
- `impl<T> PartialEq for RefCell<T> where T: PartialEq<T> + ?Sized`
- `impl<T> PartialEq for Rc<T> where T: PartialEq<T> + ?Sized`
- `impl PartialEq for String`
- `impl<'a, 'b> PartialEq for String`
- `impl<'a, 'b> PartialEq for str`
- `impl<'a, 'b> PartialEq for String`
- `impl<'a, 'b> PartialEq for &'a str`
- `impl<'a, 'b> PartialEq for Cow<'a, str>`
- `impl<'a, 'b> PartialEq for str`
- `impl<'a, 'b> PartialEq for Cow<'a, str>`
- `impl<'a, 'b> PartialEq for &'b str`
- `impl<'a, 'b> PartialEq for Cow<'a, str>`
- `impl<'a, 'b> PartialEq for String`
- `impl PartialEq for ParseError`
- `impl<T, E> PartialEq for Result<T, E> where T: PartialEq<T>, E: PartialEq<E>`
- `impl<T> PartialEq for *const T where T: ?Sized`
- `impl<T> PartialEq for *mut T where T: ?Sized`
- `impl<Ret> PartialEq for fn() -> Ret`
- `impl<Ret> PartialEq for extern fn() -> Ret`
- `impl<Ret> PartialEq for unsafe fn() -> Ret`
- `impl<Ret> PartialEq for unsafe extern fn() -> Ret`
- `impl<Ret, A> PartialEq for fn(A) -> Ret`
- `impl<Ret, A> PartialEq for extern fn(A) -> Ret`
- `impl<Ret, A> PartialEq for unsafe fn(A) -> Ret`
- `impl<Ret, A> PartialEq for unsafe extern fn(A) -> Ret`
- `impl<Ret, A, B> PartialEq for fn(A, B) -> Ret`
- `impl<Ret, A, B> PartialEq for extern fn(A, B) -> Ret`
- `impl<Ret, A, B> PartialEq for unsafe fn(A, B) -> Ret`
- `impl<Ret, A, B> PartialEq for unsafe extern fn(A, B) -> Ret`
- `impl<Ret, A, B, C> PartialEq for fn(A, B, C) -> Ret`
- `impl<Ret, A, B, C> PartialEq for extern fn(A, B, C) -> Ret`
- `impl<Ret, A, B, C> PartialEq for unsafe fn(A, B, C) -> Ret`
- `impl<Ret, A, B, C> PartialEq for unsafe extern fn(A, B, C) -> Ret`
- `impl<Ret, A, B, C, D> PartialEq for fn(A, B, C, D) -> Ret`
- `impl<Ret, A, B, C, D> PartialEq for extern fn(A, B, C, D) -> Ret`
- `impl<Ret, A, B, C, D> PartialEq for unsafe fn(A, B, C, D) -> Ret`
- `impl<Ret, A, B, C, D> PartialEq for unsafe extern fn(A, B, C, D) -> Ret`
- `impl<Ret, A, B, C, D, E> PartialEq for fn(A, B, C, D, E) -> Ret`
- `impl<Ret, A, B, C, D, E> PartialEq for extern fn(A, B, C, D, E) -> Ret`
- `impl<Ret, A, B, C, D, E> PartialEq for unsafe fn(A, B, C, D, E) -> Ret`
- `impl<Ret, A, B, C, D, E> PartialEq for unsafe extern fn(A, B, C, D, E) -> Ret`
- `impl<Ret, A, B, C, D, E, F> PartialEq for fn(A, B, C, D, E, F) -> Ret`
- `impl<Ret, A, B, C, D, E, F> PartialEq for extern fn(A, B, C, D, E, F) -> Ret`
- `impl<Ret, A, B, C, D, E, F> PartialEq for unsafe fn(A, B, C, D, E, F) -> Ret`
- `impl<Ret, A, B, C, D, E, F> PartialEq for unsafe extern fn(A, B, C, D, E, F) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G> PartialEq for fn(A, B, C, D, E, F, G) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G> PartialEq for extern fn(A, B, C, D, E, F, G) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G> PartialEq for unsafe fn(A, B, C, D, E, F, G) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G> PartialEq for unsafe extern fn(A, B, C, D, E, F, G) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H> PartialEq for fn(A, B, C, D, E, F, G, H) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H> PartialEq for extern fn(A, B, C, D, E, F, G, H) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H> PartialEq for unsafe fn(A, B, C, D, E, F, G, H) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H> PartialEq for unsafe extern fn(A, B, C, D, E, F, G, H) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H, I> PartialEq for fn(A, B, C, D, E, F, G, H, I) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H, I> PartialEq for extern fn(A, B, C, D, E, F, G, H, I) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H, I> PartialEq for unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H, I> PartialEq for unsafe extern fn(A, B, C, D, E, F, G, H, I) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialEq for fn(A, B, C, D, E, F, G, H, I, J) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialEq for extern fn(A, B, C, D, E, F, G, H, I, J) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialEq for unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialEq for unsafe extern fn(A, B, C, D, E, F, G, H, I, J) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialEq for fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialEq for extern fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialEq for unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialEq for unsafe extern fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialEq for fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialEq for extern fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialEq for unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialEq for unsafe extern fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret`
- `impl<'a, 'b, B, C> PartialEq for Cow<'a, B> where B: PartialEq<C> + ToOwned + ?Sized, C: ToOwned + ?Sized`
- `impl<T> PartialEq for Option<T> where T: PartialEq<T>`
- `impl<T> PartialEq for Wrapping<T> where T: PartialEq<T>`
- `impl PartialEq for ParseFloatError`
- `impl PartialEq for FpCategory`
- `impl PartialEq for ParseIntError`
- `impl<T> PartialEq for NonZero<T> where T: Zeroable + PartialEq<T>`
- `impl<'a, 'b, A, B> PartialEq for [A; 0] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [A; 0] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 0] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 0] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b mut [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 1] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [A; 1] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 1] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 1] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b mut [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 2] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [A; 2] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 2] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 2] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b mut [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 3] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [A; 3] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 3] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 3] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b mut [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 4] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [A; 4] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 4] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 4] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b mut [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 5] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [A; 5] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 5] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 5] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b mut [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 6] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [A; 6] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 6] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 6] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b mut [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 7] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [A; 7] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 7] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 7] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b mut [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 8] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [A; 8] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 8] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 8] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b mut [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 9] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [A; 9] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 9] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 9] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b mut [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 10] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [A; 10] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 10] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 10] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b mut [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 11] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [A; 11] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 11] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 11] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b mut [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 12] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [A; 12] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 12] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 12] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b mut [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 13] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [A; 13] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 13] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 13] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b mut [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 14] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [A; 14] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 14] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 14] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b mut [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 15] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [A; 15] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 15] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 15] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b mut [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 16] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [A; 16] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 16] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 16] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b mut [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 17] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [A; 17] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 17] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 17] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b mut [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 18] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [A; 18] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 18] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 18] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b mut [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 19] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [A; 19] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 19] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 19] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b mut [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 20] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [A; 20] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 20] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 20] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b mut [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 21] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [A; 21] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 21] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 21] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b mut [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 22] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [A; 22] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 22] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 22] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b mut [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 23] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [A; 23] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 23] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 23] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b mut [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 24] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [A; 24] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 24] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 24] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b mut [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 25] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [A; 25] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 25] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 25] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b mut [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 26] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [A; 26] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 26] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 26] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b mut [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 27] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [A; 27] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 27] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 27] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b mut [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 28] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [A; 28] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 28] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 28] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b mut [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 29] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [A; 29] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 29] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 29] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b mut [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 30] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [A; 30] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 30] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 30] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b mut [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 31] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [A; 31] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 31] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 31] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b mut [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 32] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [A; 32] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 32] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b [B] where B: PartialEq<A>`
- `impl<'a, 'b, A, B> PartialEq for [A; 32] where A: PartialEq<B>`
- `impl<'a, 'b, A, B> PartialEq for &'b mut [B] where B: PartialEq<A>`
- `impl<A, B> PartialEq for [A] where A: PartialEq<B>`
- `impl PartialEq for ParseBoolError`
- `impl PartialEq for Utf8Error`
- `impl PartialEq for str`
- `impl PartialEq for Error`
- `impl<A> PartialEq for (A,) where A: PartialEq<A>`
- `impl<A, B> PartialEq for (A, B) where B: PartialEq<B>, A: PartialEq<A>`
- `impl<A, B, C> PartialEq for (A, B, C) where B: PartialEq<B>, C: PartialEq<C>, A: PartialEq<A>`
- `impl<A, B, C, D> PartialEq for (A, B, C, D) where D: PartialEq<D>, C: PartialEq<C>, A: PartialEq<A>, B: PartialEq<B>`
- `impl<A, B, C, D, E> PartialEq for (A, B, C, D, E) where E: PartialEq<E>, A: PartialEq<A>, C: PartialEq<C>, D: PartialEq<D>, B: PartialEq<B>`
- `impl<A, B, C, D, E, F> PartialEq for (A, B, C, D, E, F) where B: PartialEq<B>, C: PartialEq<C>, F: PartialEq<F>, A: PartialEq<A>, E: PartialEq<E>, D: PartialEq<D>`
- `impl<A, B, C, D, E, F, G> PartialEq for (A, B, C, D, E, F, G) where B: PartialEq<B>, F: PartialEq<F>, C: PartialEq<C>, G: PartialEq<G>, A: PartialEq<A>, D: PartialEq<D>, E: PartialEq<E>`
- `impl<A, B, C, D, E, F, G, H> PartialEq for (A, B, C, D, E, F, G, H) where B: PartialEq<B>, C: PartialEq<C>, H: PartialEq<H>, D: PartialEq<D>, A: PartialEq<A>, G: PartialEq<G>, F: PartialEq<F>, E: PartialEq<E>`
- `impl<A, B, C, D, E, F, G, H, I> PartialEq for (A, B, C, D, E, F, G, H, I) where F: PartialEq<F>, D: PartialEq<D>, A: PartialEq<A>, I: PartialEq<I>, G: PartialEq<G>, E: PartialEq<E>, C: PartialEq<C>, B: PartialEq<B>, H: PartialEq<H>`
- `impl<A, B, C, D, E, F, G, H, I, J> PartialEq for (A, B, C, D, E, F, G, H, I, J) where E: PartialEq<E>, G: PartialEq<G>, B: PartialEq<B>, D: PartialEq<D>, I: PartialEq<I>, C: PartialEq<C>, J: PartialEq<J>, H: PartialEq<H>, A: PartialEq<A>, F: PartialEq<F>`
- `impl<A, B, C, D, E, F, G, H, I, J, K> PartialEq for (A, B, C, D, E, F, G, H, I, J, K) where G: PartialEq<G>, A: PartialEq<A>, C: PartialEq<C>, B: PartialEq<B>, J: PartialEq<J>, H: PartialEq<H>, K: PartialEq<K>, F: PartialEq<F>, E: PartialEq<E>, D: PartialEq<D>, I: PartialEq<I>`
- `impl<A, B, C, D, E, F, G, H, I, J, K, L> PartialEq for (A, B, C, D, E, F, G, H, I, J, K, L) where C: PartialEq<C>, E: PartialEq<E>, J: PartialEq<J>, I: PartialEq<I>, F: PartialEq<F>, H: PartialEq<H>, D: PartialEq<D>, K: PartialEq<K>, G: PartialEq<G>, B: PartialEq<B>, L: PartialEq<L>, A: PartialEq<A>`
- `impl<K, V> PartialEq for BTreeMap<K, V> where K: PartialEq<K>, V: PartialEq<V>`
- `impl<T> PartialEq for BTreeSet<T> where T: PartialEq<T>`
- `impl<E> PartialEq for EnumSet<E> where E: PartialEq<E>`
- `impl<T> PartialEq for Bound<T> where T: PartialEq<T>`
- `impl<T> PartialEq for Arc<T> where T: PartialEq<T> + ?Sized`

# 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

## 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`)