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

    pub trait PartialEq<Rhs: ?Sized = Self> {
        fn eq(&self, other: &Rhs) -> bool;

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

Expand description

Trait for equality comparisons which are partial equivalence relations.

`x.eq(y)` can also be written `x == y`, and `x.ne(y)` can be written `x != y`. We use the easier-to-read infix notation in the remainder of this documentation.

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

Implementations must ensure that `eq` and `ne` are consistent with each other:

- `a != b` if and only if `!(a == b)` (ensured by the default implementation).

If `PartialOrd` or `Ord` are also implemented for `Self` and `Rhs`, their methods must also be consistent with `PartialEq` (see the documentation of those traits for the exact requirements). It’s easy to accidentally make them disagree by deriving some of the traits and manually implementing others.

The equality relation `==` must satisfy the following conditions (for all `a`, `b`, `c` of type `A`, `B`, `C`):

- Symmetric: if `A: PartialEq<B>` and `B: PartialEq<A>`, then `a == b` implies `b == a`; and

- Transitive: if `A: PartialEq<B>` and `B: PartialEq<C>` and `A: PartialEq<C>`, then `a == b` and `b == c` implies `a == c`.

Note that the `B: PartialEq<A>` (symmetric) and `A: PartialEq<C>` (transitive) impls are not forced to exist, but these requirements apply whenever they do exist.

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

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

[src]

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

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

## Provided methods

[src]

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

This method tests for `!=`.

## Implementors

[src]

### impl PartialEq<!> for !

[src]

### impl PartialEq<()> for ()

1.34.0[src]

### impl PartialEq<Infallible> for Infallible

[src]

### impl PartialEq<FpCategory> for FpCategory

1.55.0[src]

### impl PartialEq<IntErrorKind> for IntErrorKind

[src]

### impl PartialEq<SearchStep> for SearchStep

[src]

### impl PartialEq<Ordering> for core::sync::atomic::Ordering

[src]

### impl PartialEq<Ordering> for core::cmp::Ordering

[src]

### impl PartialEq<AllocError> for AllocError

1.28.0[src]

### impl PartialEq<Layout> for Layout

1.50.0[src]

### impl PartialEq<LayoutError> for LayoutError

[src]

### impl PartialEq<TypeId> for TypeId

1.27.0[src]

### impl PartialEq<CpuidResult> for CpuidResult

This is supported on x86 or x86-64 only.
1.34.0[src]

### impl PartialEq<CharTryFromError> for CharTryFromError

1.9.0[src]

### impl PartialEq<DecodeUtf16Error> for DecodeUtf16Error

1.20.0[src]

### impl PartialEq<ParseCharError> for ParseCharError

[src]

### impl PartialEq<Error> for Error

1.33.0[src]

### impl PartialEq<PhantomPinned> for PhantomPinned

1.34.0[src]

### impl PartialEq<NonZeroI8> for NonZeroI8

1.34.0[src]

### impl PartialEq<NonZeroI16> for NonZeroI16

1.34.0[src]

### impl PartialEq<NonZeroI32> for NonZeroI32

1.34.0[src]

### impl PartialEq<NonZeroI64> for NonZeroI64

1.34.0[src]

### impl PartialEq<NonZeroI128> for NonZeroI128

1.34.0[src]

### impl PartialEq<NonZeroIsize> for NonZeroIsize

1.28.0[src]

### impl PartialEq<NonZeroU8> for NonZeroU8

1.28.0[src]

### impl PartialEq<NonZeroU16> for NonZeroU16

1.28.0[src]

### impl PartialEq<NonZeroU32> for NonZeroU32

1.28.0[src]

### impl PartialEq<NonZeroU64> for NonZeroU64

1.28.0[src]

### impl PartialEq<NonZeroU128> for NonZeroU128

1.28.0[src]

### impl PartialEq<NonZeroUsize> for NonZeroUsize

[src]

### impl PartialEq<ParseFloatError> for ParseFloatError

[src]

### impl PartialEq<ParseIntError> for ParseIntError

1.34.0[src]

### impl PartialEq<TryFromIntError> for TryFromIntError

[src]

### impl PartialEq<RangeFull> for RangeFull

[src]

### impl PartialEq<ParseBoolError> for ParseBoolError

[src]

### impl PartialEq<Utf8Error> for Utf8Error

1.36.0[src]

### impl PartialEq<RawWaker> for RawWaker

1.36.0[src]

### impl PartialEq<RawWakerVTable> for RawWakerVTable

1.3.0[src]

### impl PartialEq<Duration> for Duration

[src]

### impl PartialEq<FromSecsError> for FromSecsError

[src]

### impl PartialEq<bool> for bool

[src]

### impl PartialEq<char> for char

[src]

### impl PartialEq<f32> for f32

[src]

### impl PartialEq<f64> for f64

[src]

### impl PartialEq<i8> for i8

[src]

### impl PartialEq<i16> for i16

[src]

### impl PartialEq<i32> for i32

[src]

### impl PartialEq<i64> for i64

[src]

### impl PartialEq<i128> for i128

[src]

### impl PartialEq<isize> for isize

[src]

### impl PartialEq<str> for str

[src]

### impl PartialEq<u8> for u8

[src]

### impl PartialEq<u16> for u16

[src]

### impl PartialEq<u32> for u32

[src]

### impl PartialEq<u64> for u64

[src]

### impl PartialEq<u128> for u128

[src]

### impl PartialEq<usize> for usize

1.10.0[src]

### impl<'a> PartialEq<Location<'a>> for Location<'a>

[src]

### impl<'a> PartialEq<Utf8LossyChunk<'a>> for Utf8LossyChunk<'a>

[src]

### impl<A> PartialEq<(A,)> for (A,) where
A: PartialEq + ?Sized,

[src]

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

[src]

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

[src]

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

[src]

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

[src]

### impl<A, B, const N: usize> PartialEq<[A; N]> for &mut [B] where
B: PartialEq<A>,

[src]

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

[src]

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

[src]

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

[src]

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

[src]

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

[src]

### impl<A: PartialEq, B: PartialEq, C: PartialEq, D> PartialEq<(A, B, C, D)> for (A, B, C, D) where
D: PartialEq + ?Sized,

[src]

### impl<A: PartialEq, B: PartialEq, C: PartialEq, D: PartialEq, E> PartialEq<(A, B, C, D, E)> for (A, B, C, D, E) where
E: PartialEq + ?Sized,

[src]

### impl<A: PartialEq, B: PartialEq, C: PartialEq, D: PartialEq, E: PartialEq, F> PartialEq<(A, B, C, D, E, F)> for (A, B, C, D, E, F) where
F: PartialEq + ?Sized,

[src]

### impl<A: PartialEq, B: PartialEq, C: PartialEq, D: PartialEq, E: PartialEq, F: PartialEq, G> PartialEq<(A, B, C, D, E, F, G)> for (A, B, C, D, E, F, G) where
G: PartialEq + ?Sized,

[src]

### impl<A: PartialEq, B: PartialEq, C: PartialEq, D: PartialEq, E: PartialEq, F: PartialEq, G: PartialEq, H> PartialEq<(A, B, C, D, E, F, G, H)> for (A, B, C, D, E, F, G, H) where
H: PartialEq + ?Sized,

[src]

### impl<A: PartialEq, B: PartialEq, C: PartialEq, D: PartialEq, E: PartialEq, F: PartialEq, G: PartialEq, H: PartialEq, I> PartialEq<(A, B, C, D, E, F, G, H, I)> for (A, B, C, D, E, F, G, H, I) where
I: PartialEq + ?Sized,

[src]

### impl<A: PartialEq, B: PartialEq, C: PartialEq, D: PartialEq, E: PartialEq, F: PartialEq, G: PartialEq, H: PartialEq, I: PartialEq, J> PartialEq<(A, B, C, D, E, F, G, H, I, J)> for (A, B, C, D, E, F, G, H, I, J) where
J: PartialEq + ?Sized,

[src]

### impl<A: PartialEq, B: PartialEq, C: PartialEq, D: PartialEq, E: PartialEq, F: PartialEq, G: PartialEq, H: PartialEq, I: PartialEq, J: PartialEq, 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
K: PartialEq + ?Sized,

[src]

### impl<A: PartialEq, B: PartialEq, C: PartialEq, D: PartialEq, E: PartialEq, F: PartialEq, G: PartialEq, H: PartialEq, I: PartialEq, J: PartialEq, K: PartialEq, L> PartialEq<(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
L: PartialEq + ?Sized,

[src]

### impl<A: ?Sized, B: ?Sized> PartialEq<&'_ B> for &A where
A: PartialEq<B>,

[src]

### impl<A: ?Sized, B: ?Sized> PartialEq<&'_ B> for &mut A where
A: PartialEq<B>,

[src]

### impl<A: ?Sized, B: ?Sized> PartialEq<&'_ mut B> for &A where
A: PartialEq<B>,

[src]

### impl<A: ?Sized, B: ?Sized> PartialEq<&'_ mut B> for &mut A where
A: PartialEq<B>,

1.55.0[src]

### impl<B: PartialEq, C: PartialEq> PartialEq<ControlFlow<B, C>> for ControlFlow<B, C>

[src]

### impl<Dyn: ?Sized> PartialEq<DynMetadata<Dyn>> for DynMetadata<Dyn>

1.29.0[src]

### impl<H> PartialEq<BuildHasherDefault<H>> for BuildHasherDefault<H>

[src]

### impl<Idx: PartialEq> PartialEq<Range<Idx>> for Range<Idx>

[src]

### impl<Idx: PartialEq> PartialEq<RangeFrom<Idx>> for RangeFrom<Idx>

1.26.0[src]

### impl<Idx: PartialEq> PartialEq<RangeInclusive<Idx>> for RangeInclusive<Idx>

[src]

### impl<Idx: PartialEq> PartialEq<RangeTo<Idx>> for RangeTo<Idx>

1.26.0[src]

### impl<Idx: PartialEq> PartialEq<RangeToInclusive<Idx>> for RangeToInclusive<Idx>

1.41.0[src]

### impl<P: Deref, Q: Deref> PartialEq<Pin<Q>> for Pin<P> where
P::Target: PartialEq<Q::Target>,

1.4.0[src]

### impl<Ret> PartialEq<extern "C" fn() -> Ret> for extern "C" fn() -> Ret

1.4.0[src]

### impl<Ret> PartialEq<fn() -> Ret> for fn() -> Ret

1.4.0[src]

### impl<Ret> PartialEq<unsafe extern "C" fn() -> Ret> for unsafe extern "C" fn() -> Ret

1.4.0[src]

### impl<Ret> PartialEq<unsafe fn() -> Ret> for unsafe fn() -> Ret

1.4.0[src]

### impl<Ret, A> PartialEq<extern "C" fn(A) -> Ret> for extern "C" fn(_: A) -> Ret

1.4.0[src]

### impl<Ret, A> PartialEq<extern "C" fn(A, ...) -> Ret> for extern "C" fn(_: A, ...) -> Ret

1.4.0[src]

### impl<Ret, A> PartialEq<fn(A) -> Ret> for fn(_: A) -> Ret

1.4.0[src]

### impl<Ret, A> PartialEq<unsafe extern "C" fn(A) -> Ret> for unsafe extern "C" fn(_: A) -> Ret

1.4.0[src]

### impl<Ret, A> PartialEq<unsafe extern "C" fn(A, ...) -> Ret> for unsafe extern "C" fn(_: A, ...) -> Ret

1.4.0[src]

### impl<Ret, A> PartialEq<unsafe fn(A) -> Ret> for unsafe fn(_: A) -> Ret

1.4.0[src]

### impl<Ret, A, B> PartialEq<extern "C" fn(A, B) -> Ret> for extern "C" fn(_: A, _: B) -> Ret

1.4.0[src]

### impl<Ret, A, B> PartialEq<extern "C" fn(A, B, ...) -> Ret> for extern "C" fn(_: A, _: B, ...) -> Ret

1.4.0[src]

### impl<Ret, A, B> PartialEq<fn(A, B) -> Ret> for fn(_: A, _: B) -> Ret

1.4.0[src]

### impl<Ret, A, B> PartialEq<unsafe extern "C" fn(A, B) -> Ret> for unsafe extern "C" fn(_: A, _: B) -> Ret

1.4.0[src]

### impl<Ret, A, B> PartialEq<unsafe extern "C" fn(A, B, ...) -> Ret> for unsafe extern "C" fn(_: A, _: B, ...) -> Ret

1.4.0[src]

### impl<Ret, A, B> PartialEq<unsafe fn(A, B) -> Ret> for unsafe fn(_: A, _: B) -> Ret

1.4.0[src]

### impl<Ret, A, B, C> PartialEq<extern "C" fn(A, B, C) -> Ret> for extern "C" fn(_: A, _: B, _: C) -> Ret

1.4.0[src]

### impl<Ret, A, B, C> PartialEq<extern "C" fn(A, B, C, ...) -> Ret> for extern "C" fn(_: A, _: B, _: C, ...) -> Ret

1.4.0[src]

### impl<Ret, A, B, C> PartialEq<fn(A, B, C) -> Ret> for fn(_: A, _: B, _: C) -> Ret

1.4.0[src]

### impl<Ret, A, B, C> PartialEq<unsafe extern "C" fn(A, B, C) -> Ret> for unsafe extern "C" fn(_: A, _: B, _: C) -> Ret

1.4.0[src]

### impl<Ret, A, B, C> PartialEq<unsafe extern "C" fn(A, B, C, ...) -> Ret> for unsafe extern "C" fn(_: A, _: B, _: C, ...) -> Ret

1.4.0[src]

### impl<Ret, A, B, C> PartialEq<unsafe fn(A, B, C) -> Ret> for unsafe fn(_: A, _: B, _: C) -> Ret

1.4.0[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

1.4.0[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

1.4.0[src]

### impl<Ret, A, B, C, D> PartialEq<fn(A, B, C, D) -> Ret> for fn(_: A, _: B, _: C, _: D) -> Ret

1.4.0[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

1.4.0[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

1.4.0[src]

### impl<Ret, A, B, C, D> PartialEq<unsafe fn(A, B, C, D) -> Ret> for unsafe fn(_: A, _: B, _: C, _: D) -> Ret

1.4.0[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

1.4.0[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

1.4.0[src]

### impl<Ret, A, B, C, D, E> PartialEq<fn(A, B, C, D, E) -> Ret> for fn(_: A, _: B, _: C, _: D, _: E) -> Ret

1.4.0[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

1.4.0[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

1.4.0[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

1.4.0[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

1.4.0[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

1.4.0[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

1.4.0[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

1.4.0[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

1.4.0[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

1.4.0[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

1.4.0[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

1.4.0[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

1.4.0[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

1.4.0[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

1.4.0[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

1.4.0[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

1.4.0[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

1.4.0[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

1.4.0[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

1.4.0[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

1.4.0[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

1.4.0[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

1.4.0[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

1.4.0[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

1.4.0[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

1.4.0[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

1.4.0[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

1.4.0[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

1.4.0[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

1.4.0[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

1.4.0[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

1.4.0[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

1.4.0[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

1.4.0[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

1.4.0[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

1.4.0[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

1.4.0[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

1.4.0[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

1.4.0[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

1.4.0[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

1.4.0[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

1.4.0[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

1.4.0[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

1.4.0[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

1.4.0[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

1.21.0[src]

### impl<T> PartialEq<Discriminant<T>> for Discriminant<T>

[src]

### impl<T: PartialEq + Copy> PartialEq<Cell<T>> for Cell<T>

1.20.0[src]

### impl<T: PartialEq + ?Sized> PartialEq<ManuallyDrop<T>> for ManuallyDrop<T>

1.17.0[src]

### impl<T: PartialEq> PartialEq<Bound<T>> for Bound<T>

[src]

### impl<T: PartialEq> PartialEq<Option<T>> for Option<T>

1.36.0[src]

### impl<T: PartialEq> PartialEq<Poll<T>> for Poll<T>

[src]

### impl<T: PartialEq> PartialEq<OnceCell<T>> for OnceCell<T>

[src]

### impl<T: PartialEq> PartialEq<Wrapping<T>> for Wrapping<T>

1.19.0[src]

### impl<T: PartialEq> PartialEq<Reverse<T>> for Reverse<T>

[src]

### impl<T: PartialEq, E: PartialEq> PartialEq<Result<T, E>> for Result<T, E>

[src]

### impl<T: ?Sized + PartialEq> PartialEq<RefCell<T>> for RefCell<T>

[src]

### impl<T: ?Sized> PartialEq<*const T> for *const T

[src]

### impl<T: ?Sized> PartialEq<*mut T> for *mut T

[src]

### impl<T: ?Sized> PartialEq<PhantomData<T>> for PhantomData<T>

1.25.0[src]

### impl<T: ?Sized> PartialEq<NonNull<T>> for NonNull<T>

[src]

### impl<Y: PartialEq, R: PartialEq> PartialEq<GeneratorState<Y, R>> for GeneratorState<Y, R>