std::cmp::PartialEq - Rust
Description: API documentation for the Rust `PartialEq` trait in crate `std`.
Keywords: rust, rustlang, rust-lang, PartialEq

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

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

    #[must_use]
        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: &Self) -> 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

## How can I compare two different types?

The type you can compare with is controlled by `PartialEq`'s type parameter. For example, let's tweak our previous code a bit:

    // The derive implements <BookFormat> == <BookFormat> comparisons
    #[derive(PartialEq)]
    enum BookFormat {
        Paperback,
        Hardback,
        Ebook,
    }

    struct Book {
        isbn: i32,
        format: BookFormat,
    }

    // Implement <Book> == <BookFormat> comparisons
    impl PartialEq<BookFormat> for Book {
        fn eq(&self, other: &BookFormat) -> bool {
            self.format == *other
        }
    }

    // Implement <BookFormat> == <Book> comparisons
    impl PartialEq<Book> for BookFormat {
        fn eq(&self, other: &Book) -> bool {
            *self == other.format
        }
    }

    let b1 = Book { isbn: 3, format: BookFormat::Paperback };

    assert!(b1 == BookFormat::Paperback);
    assert!(BookFormat::Ebook != b1);Run

By changing `impl PartialEq for Book` to `impl PartialEq<BookFormat> for Book`, we allow `BookFormat`s to be compared with `Book`s.

A comparison like the one above, which ignores some fields of the struct, can be dangerous. It can easily lead to an unintended violation of the requirements for a partial equivalence relation. For example, if we kept the above implementation of `PartialEq<Book>` for `BookFormat` and added an implementation of `PartialEq<Book>` for `Book` (either via a `#[derive]` or via the manual implementation from the first example) then the result would violate transitivity:

    #[derive(PartialEq)]
    enum BookFormat {
        Paperback,
        Hardback,
        Ebook,
    }

    #[derive(PartialEq)]
    struct Book {
        isbn: i32,
        format: BookFormat,
    }

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

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

    fn main() {
        let b1 = Book { isbn: 1, format: BookFormat::Paperback };
        let b2 = Book { isbn: 2, format: BookFormat::Paperback };

        assert!(b1 == BookFormat::Paperback);
        assert!(BookFormat::Paperback == b2);

        // The following should hold by transitivity but doesn't.
        assert!(b1 == b2); // <-- PANICS
    }Run

# Examples

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

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

## Required methods

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

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

Loading content...

## Provided methods

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

This method tests for `!=`.

Loading content...

## Implementations on Foreign Types

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

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

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

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

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

### `impl<T, S> PartialEq<HashSet<T, S>> for HashSet<T, S> where
S: BuildHasher,
T: Eq + Hash,`

#### `fn eq(&self, other: &HashSet<T, S>) -> bool`

### `impl PartialEq<CollectionAllocErr> for CollectionAllocErr`

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

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

### `impl<K, V, S> PartialEq<HashMap<K, V, S>> for HashMap<K, V, S> where
K: Eq + Hash,
S: BuildHasher,
V: PartialEq<V>,`

#### `fn eq(&self, other: &HashMap<K, V, S>) -> bool`

Loading content...

## Implementors

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

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

### `impl PartialEq<Ordering> for std::cmp::Ordering`[src]

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

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

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

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

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

#### `fn eq(&self, &Infallible) -> bool`[src]

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

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

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

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

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

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

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

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

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

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

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

### `impl PartialEq<IpAddr> for Ipv4Addr`[src]

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

### `impl PartialEq<IpAddr> for Ipv6Addr`[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

### `impl PartialEq<Ordering> for std::sync::atomic::Ordering`[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#### `fn eq(&self, &!) -> bool`[src]

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

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

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

### `impl PartialEq<str> for OsStr`[src]

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

### `impl PartialEq<str> for OsString`[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

### `impl PartialEq<()> for ()`[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

### `impl PartialEq<OsStr> for str`[src]

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

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

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

### `impl PartialEq<OsString> for str`[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

### `impl PartialEq<Ipv4Addr> for IpAddr`[src]

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

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

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

### `impl PartialEq<Ipv6Addr> for IpAddr`[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

### `impl<'_> PartialEq<&'_ str> for OsString`[src]

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

### `impl<'_, '_, A, B> PartialEq<&'_ B> for &'_ A where
A: PartialEq<B> + ?Sized,
B: ?Sized,` [src]

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

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

### `impl<'_, '_, A, B> PartialEq<&'_ B> for &'_ mut A where
A: PartialEq<B> + ?Sized,
B: ?Sized,` [src]

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

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

### `impl<'_, '_, A, B> PartialEq<&'_ mut B> for &'_ A where
A: PartialEq<B> + ?Sized,
B: ?Sized,` [src]

#### `fn eq(&self, other: &&mut B) -> bool`[src]

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

### `impl<'_, '_, A, B> PartialEq<&'_ mut B> for &'_ mut A where
A: PartialEq<B> + ?Sized,
B: ?Sized,` [src]

#### `fn eq(&self, other: &&mut B) -> bool`[src]

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

### `impl<'_, '_, A, B> PartialEq<&'_ [B]> for Cow<'_, [A]> where
A: PartialEq<B> + Clone,` [src]

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

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

### `impl<'_, '_, A, B> PartialEq<&'_ mut [B]> for Cow<'_, [A]> where
A: PartialEq<B> + Clone,` [src]

#### `fn eq(&self, other: &&mut [B]) -> bool`[src]

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

### `impl<'_, A, B> PartialEq<&'_ [B]> for VecDeque<A> where
A: PartialEq<B>,` [src]

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

### `impl<'_, A, B> PartialEq<&'_ [B]> for Vec<A> where
A: PartialEq<B>,` [src]

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

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

### `impl<'_, A, B> PartialEq<&'_ mut [B]> for VecDeque<A> where
A: PartialEq<B>,` [src]

#### `fn eq(&self, other: &&mut [B]) -> bool`[src]

### `impl<'_, A, B> PartialEq<&'_ mut [B]> for Vec<A> where
A: PartialEq<B>,` [src]

#### `fn eq(&self, other: &&mut [B]) -> bool`[src]

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

### `impl<'_, A, B> PartialEq<Vec<B>> for Cow<'_, [A]> where
A: PartialEq<B> + Clone,` [src]

#### `fn eq(&self, other: &Vec<B>) -> bool`[src]

#### `fn ne(&self, other: &Vec<B>) -> bool`[src]

### `impl<'_, const N: usize, A, B> PartialEq<&'_ [B; N]> for VecDeque<A> where
A: PartialEq<B>,
[B; N]: LengthAtMost32,` [src]

#### `fn eq(&self, other: &&[B; N]) -> bool`[src]

### `impl<'_, const N: usize, A, B> PartialEq<&'_ [B; N]> for Vec<A> where
A: PartialEq<B>,
[B; N]: LengthAtMost32,` [src]

#### `fn eq(&self, other: &&[B; N]) -> bool`[src]

#### `fn ne(&self, other: &&[B; N]) -> bool`[src]

### `impl<'_, const N: usize, A, B> PartialEq<&'_ mut [B; N]> for VecDeque<A> where
A: PartialEq<B>,
[B; N]: LengthAtMost32,` [src]

#### `fn eq(&self, other: &&mut [B; N]) -> bool`[src]

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

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

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

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

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

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

### `impl<'a> PartialEq<OsString> for &'a str`[src]

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

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

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

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

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

### `impl<'a, 'b> PartialEq<&'a str> for String`[src]

#### `fn eq(&self, other: &&'a str) -> bool`[src]

#### `fn ne(&self, other: &&'a str) -> bool`[src]

### `impl<'a, 'b> PartialEq<&'a OsStr> for OsString`[src]

#### `fn eq(&self, other: &&'a OsStr) -> bool`[src]

### `impl<'a, 'b> PartialEq<&'a OsStr> for Path`[src]

#### `fn eq(&self, other: &&'a OsStr) -> bool`[src]

### `impl<'a, 'b> PartialEq<&'a OsStr> for PathBuf`[src]

#### `fn eq(&self, other: &&'a OsStr) -> bool`[src]

### `impl<'a, 'b> PartialEq<&'a Path> for Cow<'b, OsStr>`[src]

#### `fn eq(&self, other: &&'a Path) -> bool`[src]

### `impl<'a, 'b> PartialEq<&'a Path> for OsStr`[src]

#### `fn eq(&self, other: &&'a Path) -> bool`[src]

### `impl<'a, 'b> PartialEq<&'a Path> for OsString`[src]

#### `fn eq(&self, other: &&'a Path) -> bool`[src]

### `impl<'a, 'b> PartialEq<&'a Path> for PathBuf`[src]

#### `fn eq(&self, other: &&'a Path) -> bool`[src]

### `impl<'a, 'b> PartialEq<&'b str> for Cow<'a, str>`[src]

#### `fn eq(&self, other: &&'b str) -> bool`[src]

#### `fn ne(&self, other: &&'b str) -> bool`[src]

### `impl<'a, 'b> PartialEq<&'b OsStr> for Cow<'a, OsStr>`[src]

#### `fn eq(&self, other: &&'b OsStr) -> bool`[src]

### `impl<'a, 'b> PartialEq<&'b OsStr> for Cow<'a, Path>`[src]

#### `fn eq(&self, other: &&'b OsStr) -> bool`[src]

### `impl<'a, 'b> PartialEq<&'b Path> for Cow<'a, Path>`[src]

#### `fn eq(&self, other: &&'b Path) -> bool`[src]

### `impl<'a, 'b> PartialEq<Cow<'a, str>> for &'b str`[src]

#### `fn eq(&self, other: &Cow<'a, str>) -> bool`[src]

#### `fn ne(&self, other: &Cow<'a, str>) -> bool`[src]

### `impl<'a, 'b> PartialEq<Cow<'a, str>> for str`[src]

#### `fn eq(&self, other: &Cow<'a, str>) -> bool`[src]

#### `fn ne(&self, other: &Cow<'a, str>) -> bool`[src]

### `impl<'a, 'b> PartialEq<Cow<'a, str>> for String`[src]

#### `fn eq(&self, other: &Cow<'a, str>) -> bool`[src]

#### `fn ne(&self, other: &Cow<'a, str>) -> bool`[src]

### `impl<'a, 'b> PartialEq<Cow<'a, OsStr>> for &'b OsStr`[src]

#### `fn eq(&self, other: &Cow<'a, OsStr>) -> bool`[src]

### `impl<'a, 'b> PartialEq<Cow<'a, OsStr>> for OsStr`[src]

#### `fn eq(&self, other: &Cow<'a, OsStr>) -> bool`[src]

### `impl<'a, 'b> PartialEq<Cow<'a, OsStr>> for OsString`[src]

#### `fn eq(&self, other: &Cow<'a, OsStr>) -> bool`[src]

### `impl<'a, 'b> PartialEq<Cow<'a, OsStr>> for Path`[src]

#### `fn eq(&self, other: &Cow<'a, OsStr>) -> bool`[src]

### `impl<'a, 'b> PartialEq<Cow<'a, OsStr>> for PathBuf`[src]

#### `fn eq(&self, other: &Cow<'a, OsStr>) -> bool`[src]

### `impl<'a, 'b> PartialEq<Cow<'a, Path>> for &'b OsStr`[src]

#### `fn eq(&self, other: &Cow<'a, Path>) -> bool`[src]

### `impl<'a, 'b> PartialEq<Cow<'a, Path>> for &'b Path`[src]

#### `fn eq(&self, other: &Cow<'a, Path>) -> bool`[src]

### `impl<'a, 'b> PartialEq<Cow<'a, Path>> for OsStr`[src]

#### `fn eq(&self, other: &Cow<'a, Path>) -> bool`[src]

### `impl<'a, 'b> PartialEq<Cow<'a, Path>> for OsString`[src]

#### `fn eq(&self, other: &Cow<'a, Path>) -> bool`[src]

### `impl<'a, 'b> PartialEq<Cow<'a, Path>> for Path`[src]

#### `fn eq(&self, other: &Cow<'a, Path>) -> bool`[src]

### `impl<'a, 'b> PartialEq<Cow<'a, Path>> for PathBuf`[src]

#### `fn eq(&self, other: &Cow<'a, Path>) -> bool`[src]

### `impl<'a, 'b> PartialEq<Cow<'b, OsStr>> for &'a Path`[src]

#### `fn eq(&self, other: &Cow<'b, OsStr>) -> bool`[src]

### `impl<'a, 'b> PartialEq<str> for Cow<'a, str>`[src]

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

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

### `impl<'a, 'b> PartialEq<str> for String`[src]

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

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

### `impl<'a, 'b> PartialEq<OsStr> for &'a Path`[src]

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

### `impl<'a, 'b> PartialEq<OsStr> for Cow<'a, OsStr>`[src]

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

### `impl<'a, 'b> PartialEq<OsStr> for Cow<'a, Path>`[src]

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

### `impl<'a, 'b> PartialEq<OsStr> for OsString`[src]

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

### `impl<'a, 'b> PartialEq<OsStr> for Path`[src]

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

### `impl<'a, 'b> PartialEq<OsStr> for PathBuf`[src]

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

### `impl<'a, 'b> PartialEq<OsString> for &'a OsStr`[src]

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

### `impl<'a, 'b> PartialEq<OsString> for &'a Path`[src]

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

### `impl<'a, 'b> PartialEq<OsString> for Cow<'a, OsStr>`[src]

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

### `impl<'a, 'b> PartialEq<OsString> for Cow<'a, Path>`[src]

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

### `impl<'a, 'b> PartialEq<OsString> for OsStr`[src]

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

### `impl<'a, 'b> PartialEq<OsString> for Path`[src]

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

### `impl<'a, 'b> PartialEq<OsString> for PathBuf`[src]

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

### `impl<'a, 'b> PartialEq<Path> for &'a OsStr`[src]

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

### `impl<'a, 'b> PartialEq<Path> for Cow<'a, OsStr>`[src]

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

### `impl<'a, 'b> PartialEq<Path> for Cow<'a, Path>`[src]

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

### `impl<'a, 'b> PartialEq<Path> for OsStr`[src]

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

### `impl<'a, 'b> PartialEq<Path> for OsString`[src]

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

### `impl<'a, 'b> PartialEq<Path> for PathBuf`[src]

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

### `impl<'a, 'b> PartialEq<PathBuf> for &'a OsStr`[src]

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

### `impl<'a, 'b> PartialEq<PathBuf> for &'a Path`[src]

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

### `impl<'a, 'b> PartialEq<PathBuf> for Cow<'a, OsStr>`[src]

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

### `impl<'a, 'b> PartialEq<PathBuf> for Cow<'a, Path>`[src]

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

### `impl<'a, 'b> PartialEq<PathBuf> for OsStr`[src]

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

### `impl<'a, 'b> PartialEq<PathBuf> for OsString`[src]

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

### `impl<'a, 'b> PartialEq<PathBuf> for Path`[src]

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

### `impl<'a, 'b> PartialEq<String> for &'a str`[src]

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

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

### `impl<'a, 'b> PartialEq<String> for Cow<'a, str>`[src]

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

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

### `impl<'a, 'b> PartialEq<String> for str`[src]

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

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

### `impl<'a, 'b, B, C> PartialEq<Cow<'b, C>> for Cow<'a, B> where
B: PartialEq<C> + ToOwned + ?Sized,
C: ToOwned + ?Sized,` [src]

#### `fn eq(&self, other: &Cow<'b, C>) -> bool`[src]

### `impl<'b, const N: usize, A, B> PartialEq<[A; N]> for &'b [B] where
B: PartialEq<A>,
[A; N]: LengthAtMost32,` [src]

#### `fn eq(&self, other: &[A; N]) -> bool`[src]

#### `fn ne(&self, other: &[A; N]) -> bool`[src]

### `impl<'b, const N: usize, A, B> PartialEq<[A; N]> for &'b mut [B] where
B: PartialEq<A>,
[A; N]: LengthAtMost32,` [src]

#### `fn eq(&self, other: &[A; N]) -> bool`[src]

#### `fn ne(&self, other: &[A; N]) -> bool`[src]

### `impl<'b, const N: usize, A, B> PartialEq<&'b [B]> for [A; N] where
A: PartialEq<B>,
[A; N]: LengthAtMost32,` [src]

#### `fn eq(&self, other: &&'b [B]) -> bool`[src]

#### `fn ne(&self, other: &&'b [B]) -> bool`[src]

### `impl<'b, const N: usize, A, B> PartialEq<&'b mut [B]> for [A; N] where
A: PartialEq<B>,
[A; N]: LengthAtMost32,` [src]

#### `fn eq(&self, other: &&'b mut [B]) -> bool`[src]

#### `fn ne(&self, other: &&'b mut [B]) -> bool`[src]

### `impl<A> PartialEq<(A,)> for (A,) where
A: PartialEq<A> + ?Sized,` [src]

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

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

### `impl<A> PartialEq<VecDeque<A>> for VecDeque<A> where
A: PartialEq<A>,` [src]

#### `fn eq(&self, other: &VecDeque<A>) -> bool`[src]

### `impl<A, B> PartialEq<[B]> for [A] where
A: PartialEq<B>,` [src]

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

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

### `impl<A, B> PartialEq<(A, B)> for (A, B) where
A: PartialEq<A>,
B: PartialEq<B> + ?Sized,` [src]

#### `fn eq(&self, other: &(A, B)) -> bool`[src]

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

### `impl<A, B> PartialEq<Vec<B>> for VecDeque<A> where
A: PartialEq<B>,` [src]

#### `fn eq(&self, other: &Vec<B>) -> bool`[src]

### `impl<A, B> PartialEq<Vec<B>> for Vec<A> where
A: PartialEq<B>,` [src]

#### `fn eq(&self, other: &Vec<B>) -> bool`[src]

#### `fn ne(&self, other: &Vec<B>) -> bool`[src]

### `impl<A, B, C> PartialEq<(A, B, C)> for (A, B, C) where
A: PartialEq<A>,
B: PartialEq<B>,
C: PartialEq<C> + ?Sized,` [src]

#### `fn eq(&self, other: &(A, B, C)) -> bool`[src]

#### `fn ne(&self, other: &(A, B, C)) -> bool`[src]

### `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,` [src]

#### `fn eq(&self, other: &(A, B, C, D)) -> bool`[src]

#### `fn ne(&self, other: &(A, B, C, D)) -> bool`[src]

### `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,` [src]

#### `fn eq(&self, other: &(A, B, C, D, E)) -> bool`[src]

#### `fn ne(&self, other: &(A, B, C, D, E)) -> bool`[src]

### `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,` [src]

#### `fn eq(&self, other: &(A, B, C, D, E, F)) -> bool`[src]

#### `fn ne(&self, other: &(A, B, C, D, E, F)) -> bool`[src]

### `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,` [src]

#### `fn eq(&self, other: &(A, B, C, D, E, F, G)) -> bool`[src]

#### `fn ne(&self, other: &(A, B, C, D, E, F, G)) -> bool`[src]

### `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,` [src]

#### `fn eq(&self, other: &(A, B, C, D, E, F, G, H)) -> bool`[src]

#### `fn ne(&self, other: &(A, B, C, D, E, F, G, H)) -> bool`[src]

### `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,` [src]

#### `fn eq(&self, other: &(A, B, C, D, E, F, G, H, I)) -> bool`[src]

#### `fn ne(&self, other: &(A, B, C, D, E, F, G, H, I)) -> bool`[src]

### `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,` [src]

#### `fn eq(&self, other: &(A, B, C, D, E, F, G, H, I, J)) -> bool`[src]

#### `fn ne(&self, other: &(A, B, C, D, E, F, G, H, I, J)) -> bool`[src]

### `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,` [src]

#### `fn eq(&self, other: &(A, B, C, D, E, F, G, H, I, J, K)) -> bool`[src]

#### `fn ne(&self, other: &(A, B, C, D, E, F, G, H, I, J, K)) -> bool`[src]

### `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,` [src]

#### `fn eq(&self, other: &(A, B, C, D, E, F, G, H, I, J, K, L)) -> bool`[src]

#### `fn ne(&self, other: &(A, B, C, D, E, F, G, H, I, J, K, L)) -> bool`[src]

### `impl<H> PartialEq<BuildHasherDefault<H>> for BuildHasherDefault<H>`[src]

#### `fn eq(&self, _other: &BuildHasherDefault<H>) -> bool`[src]

### `impl<Idx> PartialEq<Range<Idx>> for Range<Idx> where
Idx: PartialEq<Idx>,` [src]

#### `fn eq(&self, other: &Range<Idx>) -> bool`[src]

#### `fn ne(&self, other: &Range<Idx>) -> bool`[src]

### `impl<Idx> PartialEq<RangeFrom<Idx>> for RangeFrom<Idx> where
Idx: PartialEq<Idx>,` [src]

#### `fn eq(&self, other: &RangeFrom<Idx>) -> bool`[src]

#### `fn ne(&self, other: &RangeFrom<Idx>) -> bool`[src]

### `impl<Idx> PartialEq<RangeInclusive<Idx>> for RangeInclusive<Idx> where
Idx: PartialEq<Idx>,` [src]

#### `fn eq(&self, other: &RangeInclusive<Idx>) -> bool`[src]

### `impl<Idx> PartialEq<RangeTo<Idx>> for RangeTo<Idx> where
Idx: PartialEq<Idx>,` [src]

#### `fn eq(&self, other: &RangeTo<Idx>) -> bool`[src]

#### `fn ne(&self, other: &RangeTo<Idx>) -> bool`[src]

### `impl<Idx> PartialEq<RangeToInclusive<Idx>> for RangeToInclusive<Idx> where
Idx: PartialEq<Idx>,` [src]

#### `fn eq(&self, other: &RangeToInclusive<Idx>) -> bool`[src]

#### `fn ne(&self, other: &RangeToInclusive<Idx>) -> bool`[src]

### `impl<K, V> PartialEq<BTreeMap<K, V>> for BTreeMap<K, V> where
K: PartialEq<K>,
V: PartialEq<V>,` [src]

#### `fn eq(&self, other: &BTreeMap<K, V>) -> bool`[src]

### `impl<K, V, S> PartialEq<HashMap<K, V, S>> for std::collections::HashMap<K, V, S> where
K: Eq + Hash,
V: PartialEq,
S: BuildHasher,` [src]

#### `fn eq(&self, other: &HashMap<K, V, S>) -> bool`[src]

### `impl<P, Q> PartialEq<Pin<Q>> for Pin<P> where
P: Deref,
Q: Deref,
<P as Deref>::Target: PartialEq<<Q as Deref>::Target>,` [src]

#### `fn eq(&self, other: &Pin<Q>) -> bool`[src]

#### `fn ne(&self, other: &Pin<Q>) -> bool`[src]

### `impl<Ret> PartialEq<fn() -> Ret> for fn() -> Ret`[src]

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

### `impl<Ret> PartialEq<extern "C" fn() -> Ret> for extern "C" fn() -> Ret`[src]

#### `fn eq(&self, other: &extern "C" fn() -> Ret) -> bool`[src]

### `impl<Ret> PartialEq<unsafe fn() -> Ret> for unsafe fn() -> Ret`[src]

#### `fn eq(&self, other: &unsafe fn() -> Ret) -> bool`[src]

### `impl<Ret> PartialEq<unsafe extern "C" fn() -> Ret> for unsafe extern "C" fn() -> Ret`[src]

#### `fn eq(&self, other: &unsafe extern "C" fn() -> Ret) -> bool`[src]

### `impl<Ret, A> PartialEq<fn(A) -> Ret> for fn(A) -> Ret`[src]

#### `fn eq(&self, other: &fn(A) -> Ret) -> bool`[src]

### `impl<Ret, A> PartialEq<extern "C" fn(A) -> Ret> for extern "C" fn(A) -> Ret`[src]

#### `fn eq(&self, other: &extern "C" fn(A) -> Ret) -> bool`[src]

### `impl<Ret, A> PartialEq<extern "C" fn(A, ...) -> Ret> for extern "C" fn(A, ...) -> Ret`[src]

#### `fn eq(&self, other: &extern "C" fn(A, ...) -> Ret) -> bool`[src]

### `impl<Ret, A> PartialEq<unsafe fn(A) -> Ret> for unsafe fn(A) -> Ret`[src]

#### `fn eq(&self, other: &unsafe fn(A) -> Ret) -> bool`[src]

### `impl<Ret, A> PartialEq<unsafe extern "C" fn(A) -> Ret> for unsafe extern "C" fn(A) -> Ret`[src]

#### `fn eq(&self, other: &unsafe extern "C" fn(A) -> Ret) -> bool`[src]

### `impl<Ret, A> PartialEq<unsafe extern "C" fn(A, ...) -> Ret> for unsafe extern "C" fn(A, ...) -> Ret`[src]

#### `fn eq(&self, other: &unsafe extern "C" fn(A, ...) -> Ret) -> bool`[src]

### `impl<Ret, A, B> PartialEq<fn(A, B) -> Ret> for fn(A, B) -> Ret`[src]

#### `fn eq(&self, other: &fn(A, B) -> Ret) -> bool`[src]

### `impl<Ret, A, B> PartialEq<extern "C" fn(A, B) -> Ret> for extern "C" fn(A, B) -> Ret`[src]

#### `fn eq(&self, other: &extern "C" fn(A, B) -> Ret) -> bool`[src]

### `impl<Ret, A, B> PartialEq<extern "C" fn(A, B, ...) -> Ret> for extern "C" fn(A, B, ...) -> Ret`[src]

#### `fn eq(&self, other: &extern "C" fn(A, B, ...) -> Ret) -> bool`[src]

### `impl<Ret, A, B> PartialEq<unsafe fn(A, B) -> Ret> for unsafe fn(A, B) -> Ret`[src]

#### `fn eq(&self, other: &unsafe fn(A, B) -> Ret) -> bool`[src]

### `impl<Ret, A, B> PartialEq<unsafe extern "C" fn(A, B) -> Ret> for unsafe extern "C" fn(A, B) -> Ret`[src]

#### `fn eq(&self, other: &unsafe extern "C" fn(A, B) -> Ret) -> bool`[src]

### `impl<Ret, A, B> PartialEq<unsafe extern "C" fn(A, B, ...) -> Ret> for unsafe extern "C" fn(A, B, ...) -> Ret`[src]

#### `fn eq(&self, other: &unsafe extern "C" fn(A, B, ...) -> Ret) -> bool`[src]

### `impl<Ret, A, B, C> PartialEq<fn(A, B, C) -> Ret> for fn(A, B, C) -> Ret`[src]

#### `fn eq(&self, other: &fn(A, B, C) -> Ret) -> bool`[src]

### `impl<Ret, A, B, C> PartialEq<extern "C" fn(A, B, C) -> Ret> for extern "C" fn(A, B, C) -> Ret`[src]

#### `fn eq(&self, other: &extern "C" fn(A, B, C) -> Ret) -> bool`[src]

### `impl<Ret, A, B, C> PartialEq<extern "C" fn(A, B, C, ...) -> Ret> for extern "C" fn(A, B, C, ...) -> Ret`[src]

#### `fn eq(&self, other: &extern "C" fn(A, B, C, ...) -> Ret) -> bool`[src]

### `impl<Ret, A, B, C> PartialEq<unsafe fn(A, B, C) -> Ret> for unsafe fn(A, B, C) -> Ret`[src]

#### `fn eq(&self, other: &unsafe fn(A, B, C) -> Ret) -> bool`[src]

### `impl<Ret, A, B, C> PartialEq<unsafe extern "C" fn(A, B, C) -> Ret> for unsafe extern "C" fn(A, B, C) -> Ret`[src]

#### `fn eq(&self, other: &unsafe extern "C" fn(A, B, C) -> Ret) -> bool`[src]

### `impl<Ret, A, B, C> PartialEq<unsafe extern "C" fn(A, B, C, ...) -> Ret> for unsafe extern "C" fn(A, B, C, ...) -> Ret`[src]

#### `fn eq(&self, other: &unsafe extern "C" fn(A, B, C, ...) -> Ret) -> bool`[src]

### `impl<Ret, A, B, C, D> PartialEq<fn(A, B, C, D) -> Ret> for fn(A, B, C, D) -> Ret`[src]

#### `fn eq(&self, other: &fn(A, B, C, D) -> Ret) -> bool`[src]

### `impl<Ret, A, B, C, D> PartialEq<extern "C" fn(A, B, C, D) -> Ret> for extern "C" fn(A, B, C, D) -> Ret`[src]

#### `fn eq(&self, other: &extern "C" fn(A, B, C, D) -> Ret) -> bool`[src]

### `impl<Ret, A, B, C, D> PartialEq<extern "C" fn(A, B, C, D, ...) -> Ret> for extern "C" fn(A, B, C, D, ...) -> Ret`[src]

#### `fn eq(&self, other: &extern "C" fn(A, B, C, D, ...) -> Ret) -> bool`[src]

### `impl<Ret, A, B, C, D> PartialEq<unsafe fn(A, B, C, D) -> Ret> for unsafe fn(A, B, C, D) -> Ret`[src]

#### `fn eq(&self, other: &unsafe fn(A, B, C, D) -> Ret) -> bool`[src]

### `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`[src]

#### `fn eq(&self, other: &unsafe extern "C" fn(A, B, C, D) -> Ret) -> bool`[src]

### `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`[src]

#### `fn eq(&self, other: &unsafe extern "C" fn(A, B, C, D, ...) -> Ret) -> bool`[src]

### `impl<Ret, A, B, C, D, E> PartialEq<fn(A, B, C, D, E) -> Ret> for fn(A, B, C, D, E) -> Ret`[src]

#### `fn eq(&self, other: &fn(A, B, C, D, E) -> Ret) -> bool`[src]

### `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`[src]

#### `fn eq(&self, other: &extern "C" fn(A, B, C, D, E) -> Ret) -> bool`[src]

### `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`[src]

#### `fn eq(&self, other: &extern "C" fn(A, B, C, D, E, ...) -> Ret) -> bool`[src]

### `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`[src]

#### `fn eq(&self, other: &unsafe fn(A, B, C, D, E) -> Ret) -> bool`[src]

### `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`[src]

#### `fn eq(&self, other: &unsafe extern "C" fn(A, B, C, D, E) -> Ret) -> bool`[src]

### `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`[src]

#### `fn eq(&self, other: &unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret) -> bool`[src]

### `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`[src]

#### `fn eq(&self, other: &fn(A, B, C, D, E, F) -> Ret) -> bool`[src]

### `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`[src]

#### `fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F) -> Ret) -> bool`[src]

### `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`[src]

#### `fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F, ...) -> Ret) -> bool`[src]

### `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`[src]

#### `fn eq(&self, other: &unsafe fn(A, B, C, D, E, F) -> Ret) -> bool`[src]

### `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`[src]

#### `fn eq(&self, other: &unsafe extern "C" fn(A, B, C, D, E, F) -> Ret) -> bool`[src]

### `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`[src]

#### `fn eq(&self, other: &unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret) -> bool`[src]

### `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`[src]

#### `fn eq(&self, other: &fn(A, B, C, D, E, F, G) -> Ret) -> bool`[src]

### `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`[src]

#### `fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F, G) -> Ret) -> bool`[src]

### `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`[src]

#### `fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret) -> bool`[src]

### `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`[src]

#### `fn eq(&self, other: &unsafe fn(A, B, C, D, E, F, G) -> Ret) -> bool`[src]

### `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`[src]

#### `fn eq(&self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret) -> bool`[src]

### `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`[src]

#### `fn eq(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret
) -> bool`[src]

### `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`[src]

#### `fn eq(&self, other: &fn(A, B, C, D, E, F, G, H) -> Ret) -> bool`[src]

### `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`[src]

#### `fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F, G, H) -> Ret) -> bool`[src]

### `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`[src]

#### `fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret) -> bool`[src]

### `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`[src]

#### `fn eq(&self, other: &unsafe fn(A, B, C, D, E, F, G, H) -> Ret) -> bool`[src]

### `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`[src]

#### `fn eq(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret
) -> bool`[src]

### `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`[src]

#### `fn eq(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret
) -> bool`[src]

### `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`[src]

#### `fn eq(&self, other: &fn(A, B, C, D, E, F, G, H, I) -> Ret) -> bool`[src]

### `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`[src]

#### `fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret) -> bool`[src]

### `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`[src]

#### `fn eq(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret
) -> bool`[src]

### `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`[src]

#### `fn eq(&self, other: &unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret) -> bool`[src]

### `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`[src]

#### `fn eq(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret
) -> bool`[src]

### `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`[src]

#### `fn eq(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret
) -> bool`[src]

### `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`[src]

#### `fn eq(&self, other: &fn(A, B, C, D, E, F, G, H, I, J) -> Ret) -> bool`[src]

### `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`[src]

#### `fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret) -> bool`[src]

### `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`[src]

#### `fn eq(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret
) -> bool`[src]

### `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`[src]

#### `fn eq(&self, other: &unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret) -> bool`[src]

### `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`[src]

#### `fn eq(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret
) -> bool`[src]

### `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`[src]

#### `fn eq(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret
) -> bool`[src]

### `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`[src]

#### `fn eq(&self, other: &fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret) -> bool`[src]

### `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`[src]

#### `fn eq(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
) -> bool`[src]

### `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`[src]

#### `fn eq(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret
) -> bool`[src]

### `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`[src]

#### `fn eq(&self, other: &unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret) -> bool`[src]

### `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`[src]

#### `fn eq(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
) -> bool`[src]

### `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`[src]

#### `fn eq(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret
) -> bool`[src]

### `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`[src]

#### `fn eq(&self, other: &fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret) -> bool`[src]

### `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`[src]

#### `fn eq(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
) -> bool`[src]

### `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`[src]

#### `fn eq(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret
) -> bool`[src]

### `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`[src]

#### `fn eq(
&self,
other: &unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
) -> bool`[src]

### `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`[src]

#### `fn eq(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
) -> bool`[src]

### `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`[src]

#### `fn eq(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret
) -> bool`[src]

### `impl<T> PartialEq<Bound<T>> for Bound<T> where
T: PartialEq<T>,` [src]

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

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

### `impl<T> PartialEq<Option<T>> for Option<T> where
T: PartialEq<T>,` [src]

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

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

### `impl<T> PartialEq<Poll<T>> for Poll<T> where
T: PartialEq<T>,` [src]

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

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

### `impl<T> PartialEq<*const T> for *const T where
T: ?Sized,` [src]

#### `fn eq(&self, other: &*const T) -> bool`[src]

### `impl<T> PartialEq<*mut T> for *mut T where
T: ?Sized,` [src]

#### `fn eq(&self, other: &*mut T) -> bool`[src]

### `impl<T> PartialEq<Box<T>> for Box<T> where
T: PartialEq<T> + ?Sized,` [src]

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

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

### `impl<T> PartialEq<Cell<T>> for Cell<T> where
T: Copy + PartialEq<T>,` [src]

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

### `impl<T> PartialEq<RefCell<T>> for RefCell<T> where
T: PartialEq<T> + ?Sized,` [src]

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

# Panics

Panics if the value in either `RefCell` is currently borrowed.

### `impl<T> PartialEq<Reverse<T>> for Reverse<T> where
T: PartialEq<T>,` [src]

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

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

### `impl<T> PartialEq<BTreeSet<T>> for BTreeSet<T> where
T: PartialEq<T>,` [src]

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

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

### `impl<T> PartialEq<LinkedList<T>> for LinkedList<T> where
T: PartialEq<T>,` [src]

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

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

### `impl<T> PartialEq<PhantomData<T>> for PhantomData<T> where
T: ?Sized,` [src]

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

### `impl<T> PartialEq<Discriminant<T>> for Discriminant<T>`[src]

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

### `impl<T> PartialEq<ManuallyDrop<T>> for ManuallyDrop<T> where
T: PartialEq<T> + ?Sized,` [src]

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

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

### `impl<T> PartialEq<Wrapping<T>> for Wrapping<T> where
T: PartialEq<T>,` [src]

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

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

### `impl<T> PartialEq<NonNull<T>> for NonNull<T> where
T: ?Sized,` [src]

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

### `impl<T> PartialEq<Rc<T>> for Rc<T> where
T: PartialEq<T> + ?Sized,` [src]

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

Equality for two `Rc`s.

Two `Rc`s are equal if their inner values are equal, even if they are stored in different allocation.

If `T` also implements `Eq` (implying reflexivity of equality), two `Rc`s that point to the same allocation are always equal.

# Examples

    use std::rc::Rc;

    let five = Rc::new(5);

    assert!(five == Rc::new(5));Run

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

Inequality for two `Rc`s.

Two `Rc`s are unequal if their inner values are unequal.

If `T` also implements `Eq` (implying reflexivity of equality), two `Rc`s that point to the same allocation are never unequal.

# Examples

    use std::rc::Rc;

    let five = Rc::new(5);

    assert!(five != Rc::new(6));Run

### `impl<T> PartialEq<Arc<T>> for Arc<T> where
T: PartialEq<T> + ?Sized,` [src]

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

Equality for two `Arc`s.

Two `Arc`s are equal if their inner values are equal, even if they are stored in different allocation.

If `T` also implements `Eq` (implying reflexivity of equality), two `Arc`s that point to the same allocation are always equal.

# Examples

    use std::sync::Arc;

    let five = Arc::new(5);

    assert!(five == Arc::new(5));Run

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

Inequality for two `Arc`s.

Two `Arc`s are unequal if their inner values are unequal.

If `T` also implements `Eq` (implying reflexivity of equality), two `Arc`s that point to the same value are never unequal.

# Examples

    use std::sync::Arc;

    let five = Arc::new(5);

    assert!(five != Arc::new(6));Run

### `impl<T, E> PartialEq<Result<T, E>> for Result<T, E> where
E: PartialEq<E>,
T: PartialEq<T>,` [src]

#### `fn eq(&self, other: &Result<T, E>) -> bool`[src]

#### `fn ne(&self, other: &Result<T, E>) -> bool`[src]

### `impl<T, S> PartialEq<HashSet<T, S>> for std::collections::HashSet<T, S> where
T: Eq + Hash,
S: BuildHasher,` [src]

#### `fn eq(&self, other: &HashSet<T, S>) -> bool`[src]

### `impl<T: PartialEq> PartialEq<TrySendError<T>> for TrySendError<T>`[src]

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

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

### `impl<T: PartialEq> PartialEq<SendError<T>> for SendError<T>`[src]

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

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

### `impl<Y, R> PartialEq<GeneratorState<Y, R>> for GeneratorState<Y, R> where
R: PartialEq<R>,
Y: PartialEq<Y>,` [src]

#### `fn eq(&self, other: &GeneratorState<Y, R>) -> bool`[src]

#### `fn ne(&self, other: &GeneratorState<Y, R>) -> bool`[src]

### `impl<const N: usize, A, B> PartialEq<[A; N]> for [B] where
B: PartialEq<A>,
[A; N]: LengthAtMost32,` [src]

#### `fn eq(&self, other: &[A; N]) -> bool`[src]

#### `fn ne(&self, other: &[A; N]) -> bool`[src]

### `impl<const N: usize, A, B> PartialEq<[B; N]> for [A; N] where
A: PartialEq<B>,
[A; N]: LengthAtMost32,
[B; N]: LengthAtMost32,` [src]

#### `fn eq(&self, other: &[B; N]) -> bool`[src]

#### `fn ne(&self, other: &[B; N]) -> bool`[src]

### `impl<const N: usize, A, B> PartialEq<[B; N]> for VecDeque<A> where
A: PartialEq<B>,
[B; N]: LengthAtMost32,` [src]

#### `fn eq(&self, other: &[B; N]) -> bool`[src]

### `impl<const N: usize, A, B> PartialEq<[B; N]> for Vec<A> where
A: PartialEq<B>,
[B; N]: LengthAtMost32,` [src]

#### `fn eq(&self, other: &[B; N]) -> bool`[src]

#### `fn ne(&self, other: &[B; N]) -> bool`[src]

### `impl<const N: usize, A, B> PartialEq<[B]> for [A; N] where
A: PartialEq<B>,
[A; N]: LengthAtMost32,` [src]

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

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

Loading content...