pub trait PartialEq<Rhs = Self> where
    Rhs: ?Sized
{ 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 derived on structs, two instances are equal if all fields are equal, and not equal if any fields are not equal. When derived 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);

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);

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

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
}

Examples

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

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

Required methods

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

Provided methods

This method tests for !=.

Implementations on Foreign Types

Panics

Panics if the value in either RefCell is currently borrowed.

Equality for two Rcs.

Two Rcs 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 Rcs that point to the same allocation are always equal.

Examples
use std::rc::Rc;

let five = Rc::new(5);

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

Inequality for two Rcs.

Two Rcs are unequal if their inner values are unequal.

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

Examples
use std::rc::Rc;

let five = Rc::new(5);

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

Equality for two Arcs.

Two Arcs 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 Arcs that point to the same allocation are always equal.

Examples
use std::sync::Arc;

let five = Arc::new(5);

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

Inequality for two Arcs.

Two Arcs are unequal if their inner values are unequal.

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

Examples
use std::sync::Arc;

let five = Arc::new(5);

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

impl PartialEq<Entry> for Entry

We hide fields largely so that only compairing the compressed forms works.

This doesn’t test if they are in the same state, only if they contains the same data at this state

Implementors

impl<'a, S: PartialEq + 'a + ToOwned + ?Sized> PartialEq<ANSIGenericString<'a, S>> for ANSIGenericString<'a, S> where
    <S as ToOwned>::Owned: Debug

impl<'a, S: PartialEq + 'a + ToOwned + ?Sized> PartialEq<ANSIGenericStrings<'a, S>> for ANSIGenericStrings<'a, S> where
    <S as ToOwned>::Owned: Debug,
    S: PartialEq

impl<T, const CAP: usize> PartialEq<ArrayVec<T, CAP>> for ArrayVec<T, CAP> where
    T: PartialEq

impl<T, const CAP: usize> PartialEq<[T]> for ArrayVec<T, CAP> where
    T: PartialEq

impl<const CAP: usize> PartialEq<ArrayString<CAP>> for ArrayString<CAP>

impl<const CAP: usize> PartialEq<str> for ArrayString<CAP>

impl<const CAP: usize> PartialEq<ArrayString<CAP>> for str

impl<O, V, T> PartialEq<BitArray<O, V>> for BitSlice<O, T> where
    O: BitOrder,
    V: BitView,
    T: BitStore

impl<O, V, Rhs> PartialEq<Rhs> for BitArray<O, V> where
    O: BitOrder,
    V: BitView,
    Rhs: ?Sized,
    BitSlice<O, V::Store>: PartialEq<Rhs>, 

impl<R: PartialEq> PartialEq<BitIdx<R>> for BitIdx<R> where
    R: BitRegister

impl<R: PartialEq> PartialEq<BitIdxError<R>> for BitIdxError<R> where
    R: BitRegister

impl<R: PartialEq> PartialEq<BitTail<R>> for BitTail<R> where
    R: BitRegister

impl<R: PartialEq> PartialEq<BitPos<R>> for BitPos<R> where
    R: BitRegister

impl<R: PartialEq> PartialEq<BitSel<R>> for BitSel<R> where
    R: BitRegister

impl<R: PartialEq> PartialEq<BitMask<R>> for BitMask<R> where
    R: BitRegister

impl PartialEq<Mut> for Mut

impl PartialEq<Lsb0> for Lsb0

impl PartialEq<Msb0> for Msb0

impl<M1, M2, T1, T2> PartialEq<Address<M2, T2>> for Address<M1, T1> where
    M1: Mutability,
    M2: Mutability,
    T1: BitStore,
    T2: BitStore

impl<T: PartialEq> PartialEq<AddressError<T>> for AddressError<T> where
    T: BitStore

impl<M1, M2, O1, O2, T1, T2> PartialEq<BitRef<'_, M2, O2, T2>> for BitRef<'_, M1, O1, T1> where
    M1: Mutability,
    M2: Mutability,
    O1: BitOrder,
    O2: BitOrder,
    T1: BitStore,
    T2: BitStore

impl<M, O, T> PartialEq<bool> for BitRef<'_, M, O, T> where
    M: Mutability,
    O: BitOrder,
    T: BitStore

impl<M, O, T> PartialEq<&'_ bool> for BitRef<'_, M, O, T> where
    M: Mutability,
    O: BitOrder,
    T: BitStore

impl<M1, M2, O, T1, T2> PartialEq<BitPtrRange<M2, O, T2>> for BitPtrRange<M1, O, T1> where
    M1: Mutability,
    M2: Mutability,
    O: BitOrder,
    T1: BitStore,
    T2: BitStore

impl<M1, M2, O, T1, T2> PartialEq<BitPtr<M2, O, T2>> for BitPtr<M1, O, T1> where
    M1: Mutability,
    M2: Mutability,
    O: BitOrder,
    T1: BitStore,
    T2: BitStore

impl<T: PartialEq> PartialEq<BitPtrError<T>> for BitPtrError<T> where
    T: BitStore,
    T::Mem: PartialEq

impl<T: PartialEq> PartialEq<BitSpanError<T>> for BitSpanError<T> where
    T: BitStore

impl<'a, O: PartialEq, T: PartialEq> PartialEq<IterOnes<'a, O, T>> for IterOnes<'a, O, T> where
    O: BitOrder,
    T: BitStore

impl<'a, O: PartialEq, T: PartialEq> PartialEq<IterZeros<'a, O, T>> for IterZeros<'a, O, T> where
    O: BitOrder,
    T: BitStore

impl<O1, O2, T1, T2> PartialEq<BitSlice<O2, T2>> for BitSlice<O1, T1> where
    O1: BitOrder,
    O2: BitOrder,
    T1: BitStore,
    T2: BitStore

impl<O1, O2, T1, T2> PartialEq<BitSlice<O2, T2>> for &BitSlice<O1, T1> where
    O1: BitOrder,
    O2: BitOrder,
    T1: BitStore,
    T2: BitStore

impl<O1, O2, T1, T2> PartialEq<BitSlice<O2, T2>> for &mut BitSlice<O1, T1> where
    O1: BitOrder,
    O2: BitOrder,
    T1: BitStore,
    T2: BitStore

impl<O1, O2, T1, T2> PartialEq<&'_ BitSlice<O2, T2>> for BitSlice<O1, T1> where
    O1: BitOrder,
    O2: BitOrder,
    T1: BitStore,
    T2: BitStore

impl<O1, O2, T1, T2> PartialEq<&'_ mut BitSlice<O2, T2>> for BitSlice<O1, T1> where
    O1: BitOrder,
    O2: BitOrder,
    T1: BitStore,
    T2: BitStore

impl<O1, O2, T1, T2> PartialEq<BitBox<O2, T2>> for BitSlice<O1, T1> where
    O1: BitOrder,
    O2: BitOrder,
    T1: BitStore,
    T2: BitStore

impl<O1, O2, T1, T2> PartialEq<BitBox<O2, T2>> for &BitSlice<O1, T1> where
    O1: BitOrder,
    O2: BitOrder,
    T1: BitStore,
    T2: BitStore

impl<O1, O2, T1, T2> PartialEq<BitBox<O2, T2>> for &mut BitSlice<O1, T1> where
    O1: BitOrder,
    O2: BitOrder,
    T1: BitStore,
    T2: BitStore

impl<O, T, Rhs> PartialEq<Rhs> for BitBox<O, T> where
    O: BitOrder,
    T: BitStore,
    Rhs: ?Sized + PartialEq<BitSlice<O, T>>, 

impl<O1, O2, T1, T2> PartialEq<BitVec<O2, T2>> for BitSlice<O1, T1> where
    O1: BitOrder,
    O2: BitOrder,
    T1: BitStore,
    T2: BitStore

impl<O1, O2, T1, T2> PartialEq<BitVec<O2, T2>> for &BitSlice<O1, T1> where
    O1: BitOrder,
    O2: BitOrder,
    T1: BitStore,
    T2: BitStore

impl<O1, O2, T1, T2> PartialEq<BitVec<O2, T2>> for &mut BitSlice<O1, T1> where
    O1: BitOrder,
    O2: BitOrder,
    T1: BitStore,
    T2: BitStore

impl<O, T, Rhs> PartialEq<Rhs> for BitVec<O, T> where
    O: BitOrder,
    T: BitStore,
    Rhs: ?Sized + PartialEq<BitSlice<O, T>>, 

impl PartialEq<Utc> for Utc

impl<Tz: TimeZone, Tz2: TimeZone> PartialEq<Date<Tz2>> for Date<Tz>

impl<Tz: TimeZone, Tz2: TimeZone> PartialEq<DateTime<Tz2>> for DateTime<Tz>

impl PartialEq<Pad> for Pad

impl<'a> PartialEq<Item<'a>> for Item<'a>

impl PartialEq<Case> for Case

impl<M: Mac> PartialEq<Output<M>> for Output<M>

impl<L: PartialEq, R: PartialEq> PartialEq<Either<L, R>> for Either<L, R>

impl<T: PartialEq + Form> PartialEq<ExtrinsicMetadata<T>> for ExtrinsicMetadata<T> where
    T::Type: PartialEq

impl<T: PartialEq + Form> PartialEq<SignedExtensionMetadata<T>> for SignedExtensionMetadata<T> where
    T::String: PartialEq,
    T::Type: PartialEq,
    T::Type: PartialEq

impl<T: PartialEq + Form> PartialEq<PalletMetadata<T>> for PalletMetadata<T> where
    T::String: PartialEq

impl<T: PartialEq + Form> PartialEq<StorageEntryMetadata<T>> for StorageEntryMetadata<T> where
    T::String: PartialEq,
    T::String: PartialEq

impl<T: PartialEq + Form> PartialEq<StorageEntryType<T>> for StorageEntryType<T> where
    T::Type: PartialEq,
    T::Type: PartialEq,
    T::Type: PartialEq

impl<T: PartialEq + Form> PartialEq<PalletCallMetadata<T>> for PalletCallMetadata<T> where
    T::Type: PartialEq

impl<T: PartialEq + Form> PartialEq<PalletEventMetadata<T>> for PalletEventMetadata<T> where
    T::Type: PartialEq

impl<T: PartialEq + Form> PartialEq<PalletConstantMetadata<T>> for PalletConstantMetadata<T> where
    T::String: PartialEq,
    T::Type: PartialEq,
    T::String: PartialEq

impl<T: PartialEq + Form> PartialEq<PalletErrorMetadata<T>> for PalletErrorMetadata<T> where
    T::Type: PartialEq

impl<T: PartialEq + SigningTypes> PartialEq<Account<T>> for Account<T> where
    T::AccountId: PartialEq,
    T::Public: PartialEq

impl<T: PartialEq + Config> PartialEq<CheckNonce<T>> for CheckNonce<T> where
    T::Index: PartialEq

impl<T> PartialEq<Pallet<T>> for Pallet<T>

impl<T: Config> PartialEq<Event<T>> for Event<T>

impl<T: Config> PartialEq<Call<T>> for Call<T>

impl<AccountId: PartialEq> PartialEq<RawOrigin<AccountId>> for RawOrigin<AccountId>

impl<Index: PartialEq, AccountData: PartialEq> PartialEq<AccountInfo<Index, AccountData>> for AccountInfo<Index, AccountData>

impl<T: PartialEq, N> PartialEq<GenericArray<T, N>> for GenericArray<T, N> where
    N: ArrayLength<T>, 

impl PartialEq<DwUt> for DwUt

impl PartialEq<DwAt> for DwAt

impl PartialEq<DwDs> for DwDs

impl PartialEq<DwId> for DwId

impl PartialEq<DwCc> for DwCc

impl PartialEq<DwOp> for DwOp

impl<R: PartialEq + Reader> PartialEq<EhFrame<R>> for EhFrame<R>

impl<'bases, Section: PartialEq, R: PartialEq> PartialEq<CieOrFde<'bases, Section, R>> for CieOrFde<'bases, Section, R> where
    R: Reader,
    Section: UnwindSection<R>, 

impl<R: PartialEq, Offset: PartialEq> PartialEq<CommonInformationEntry<R, Offset>> for CommonInformationEntry<R, Offset> where
    R: Reader<Offset = Offset>,
    Offset: ReaderOffset

impl<'bases, Section: PartialEq, R: PartialEq> PartialEq<PartialFrameDescriptionEntry<'bases, Section, R>> for PartialFrameDescriptionEntry<'bases, Section, R> where
    R: Reader,
    Section: UnwindSection<R>,
    R::Offset: PartialEq,
    R::Offset: PartialEq,
    Section::Offset: PartialEq

impl<R: PartialEq, Offset: PartialEq> PartialEq<FrameDescriptionEntry<R, Offset>> for FrameDescriptionEntry<R, Offset> where
    R: Reader<Offset = Offset>,
    Offset: ReaderOffset

impl<R: PartialEq + Reader, A: PartialEq + UnwindContextStorage<R>> PartialEq<UnwindContext<R, A>> for UnwindContext<R, A> where
    A::Stack: PartialEq

impl<R: PartialEq + Reader> PartialEq<CfaRule<R>> for CfaRule<R>

impl<'input, Endian: PartialEq> PartialEq<EndianSlice<'input, Endian>> for EndianSlice<'input, Endian> where
    Endian: Endianity

impl<R: PartialEq, Offset: PartialEq> PartialEq<ArangeHeader<R, Offset>> for ArangeHeader<R, Offset> where
    R: Reader<Offset = Offset>,
    Offset: ReaderOffset

impl<R: PartialEq, Offset: PartialEq> PartialEq<LineInstruction<R, Offset>> for LineInstruction<R, Offset> where
    R: Reader<Offset = Offset>,
    Offset: ReaderOffset

impl<R: PartialEq, Offset: PartialEq> PartialEq<LineProgramHeader<R, Offset>> for LineProgramHeader<R, Offset> where
    R: Reader<Offset = Offset>,
    Offset: ReaderOffset

impl<R: PartialEq, Offset: PartialEq> PartialEq<IncompleteLineProgram<R, Offset>> for IncompleteLineProgram<R, Offset> where
    R: Reader<Offset = Offset>,
    Offset: ReaderOffset

impl<R: PartialEq, Offset: PartialEq> PartialEq<CompleteLineProgram<R, Offset>> for CompleteLineProgram<R, Offset> where
    R: Reader<Offset = Offset>,
    Offset: ReaderOffset

impl<R: PartialEq, Offset: PartialEq> PartialEq<FileEntry<R, Offset>> for FileEntry<R, Offset> where
    R: Reader<Offset = Offset>,
    Offset: ReaderOffset

impl<R: PartialEq, Offset: PartialEq> PartialEq<Operation<R, Offset>> for Operation<R, Offset> where
    R: Reader<Offset = Offset>,
    Offset: ReaderOffset

impl<R: PartialEq, Offset: PartialEq> PartialEq<Location<R, Offset>> for Location<R, Offset> where
    R: Reader<Offset = Offset>,
    Offset: ReaderOffset

impl<R: PartialEq, Offset: PartialEq> PartialEq<Piece<R, Offset>> for Piece<R, Offset> where
    R: Reader<Offset = Offset>,
    Offset: ReaderOffset

impl<R: PartialEq + Reader> PartialEq<EvaluationResult<R>> for EvaluationResult<R> where
    R::Offset: PartialEq,
    R::Offset: PartialEq,
    R::Offset: PartialEq,
    R::Offset: PartialEq,
    R::Offset: PartialEq,
    R::Offset: PartialEq

impl<Offset: PartialEq> PartialEq<UnitType<Offset>> for UnitType<Offset> where
    Offset: ReaderOffset

impl<R: PartialEq, Offset: PartialEq> PartialEq<UnitHeader<R, Offset>> for UnitHeader<R, Offset> where
    R: Reader<Offset = Offset>,
    Offset: ReaderOffset

impl<R: PartialEq, Offset: PartialEq> PartialEq<AttributeValue<R, Offset>> for AttributeValue<R, Offset> where
    R: Reader<Offset = Offset>,
    Offset: ReaderOffset

impl<K, V, S, A> PartialEq<HashMap<K, V, S, A>> for HashMap<K, V, S, A> where
    K: Eq + Hash,
    V: PartialEq,
    S: BuildHasher,
    A: Allocator + Clone

impl<T, S, A> PartialEq<HashSet<T, S, A>> for HashSet<T, S, A> where
    T: Eq + Hash,
    S: BuildHasher,
    A: Allocator + Clone

impl<D: PartialEq + Digest> PartialEq<SharedSecret<D>> for SharedSecret<D> where
    D::OutputSize: PartialEq

impl<'a> PartialEq<Metadata<'a>> for Metadata<'a>

impl<H, KF, T, M> PartialEq<MemoryDB<H, KF, T, M>> for MemoryDB<H, KF, T, M> where
    H: KeyHasher,
    KF: KeyFunction<H>,
    <KF as KeyFunction<H>>::Key: Eq + MaybeDebug,
    T: Eq + MaybeDebug,
    M: MemTracker<T> + PartialEq

impl<T: PartialEq + Scalar> PartialEq<X<T>> for X<T>

impl<T: PartialEq + Scalar> PartialEq<XY<T>> for XY<T>

impl<T: PartialEq + Scalar> PartialEq<XYZ<T>> for XYZ<T>

impl<T: PartialEq + Scalar> PartialEq<XYZW<T>> for XYZW<T>

impl<T: PartialEq + Scalar> PartialEq<XYZWA<T>> for XYZWA<T>

impl<T: PartialEq + Scalar> PartialEq<XYZWAB<T>> for XYZWAB<T>

impl<T: PartialEq + Scalar> PartialEq<IJKW<T>> for IJKW<T>

impl<T: PartialEq + Scalar> PartialEq<M2x2<T>> for M2x2<T>

impl<T: PartialEq + Scalar> PartialEq<M2x3<T>> for M2x3<T>

impl<T: PartialEq + Scalar> PartialEq<M2x4<T>> for M2x4<T>

impl<T: PartialEq + Scalar> PartialEq<M2x5<T>> for M2x5<T>

impl<T: PartialEq + Scalar> PartialEq<M2x6<T>> for M2x6<T>

impl<T: PartialEq + Scalar> PartialEq<M3x2<T>> for M3x2<T>

impl<T: PartialEq + Scalar> PartialEq<M3x3<T>> for M3x3<T>

impl<T: PartialEq + Scalar> PartialEq<M3x4<T>> for M3x4<T>

impl<T: PartialEq + Scalar> PartialEq<M3x5<T>> for M3x5<T>

impl<T: PartialEq + Scalar> PartialEq<M3x6<T>> for M3x6<T>

impl<T: PartialEq + Scalar> PartialEq<M4x2<T>> for M4x2<T>

impl<T: PartialEq + Scalar> PartialEq<M4x3<T>> for M4x3<T>

impl<T: PartialEq + Scalar> PartialEq<M4x4<T>> for M4x4<T>

impl<T: PartialEq + Scalar> PartialEq<M4x5<T>> for M4x5<T>

impl<T: PartialEq + Scalar> PartialEq<M4x6<T>> for M4x6<T>

impl<T: PartialEq + Scalar> PartialEq<M5x2<T>> for M5x2<T>

impl<T: PartialEq + Scalar> PartialEq<M5x3<T>> for M5x3<T>

impl<T: PartialEq + Scalar> PartialEq<M5x4<T>> for M5x4<T>

impl<T: PartialEq + Scalar> PartialEq<M5x5<T>> for M5x5<T>

impl<T: PartialEq + Scalar> PartialEq<M5x6<T>> for M5x6<T>

impl<T: PartialEq + Scalar> PartialEq<M6x2<T>> for M6x2<T>

impl<T: PartialEq + Scalar> PartialEq<M6x3<T>> for M6x3<T>

impl<T: PartialEq + Scalar> PartialEq<M6x4<T>> for M6x4<T>

impl<T: PartialEq + Scalar> PartialEq<M6x5<T>> for M6x5<T>

impl<T: PartialEq + Scalar> PartialEq<M6x6<T>> for M6x6<T>

impl<const R: usize> PartialEq<Const<R>> for Const<R>

impl<T: PartialEq, const R: usize, const C: usize> PartialEq<ArrayStorage<T, R, C>> for ArrayStorage<T, R, C>

impl<T, R, R2, C, C2, S, S2> PartialEq<Matrix<T, R2, C2, S2>> for Matrix<T, R, C, S> where
    T: Scalar + PartialEq,
    C: Dim,
    C2: Dim,
    R: Dim,
    R2: Dim,
    S: Storage<T, R, C>,
    S2: Storage<T, R2, C2>, 

impl<T, R, C, S> PartialEq<Unit<Matrix<T, R, C, S>>> for Unit<Matrix<T, R, C, S>> where
    T: Scalar + PartialEq,
    R: Dim,
    C: Dim,
    S: Storage<T, R, C>, 

impl<T: PartialEq, R: PartialEq + Dim, C: PartialEq + Dim> PartialEq<VecStorage<T, R, C>> for VecStorage<T, R, C>

impl<T: Scalar, const D: usize> PartialEq<Point<T, D>> for Point<T, D>

impl<T: Scalar + PartialEq, const D: usize> PartialEq<Rotation<T, D>> for Rotation<T, D>

impl<T: Scalar> PartialEq<Quaternion<T>> for Quaternion<T>

impl<T: Scalar + PartialEq, const D: usize> PartialEq<Translation<T, D>> for Translation<T, D>

impl<T: SimdRealField, R, const D: usize> PartialEq<Isometry<T, R, D>> for Isometry<T, R, D> where
    R: AbstractRotation<T, D> + PartialEq

impl<T: SimdRealField, R, const D: usize> PartialEq<Similarity<T, R, D>> for Similarity<T, R, D> where
    R: AbstractRotation<T, D> + PartialEq

impl<T: RealField, C: TCategory, const D: usize> PartialEq<Transform<T, C, D>> for Transform<T, C, D> where
    Const<D>: DimNameAdd<U1>,
    DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>, 

impl<T: PartialEq> PartialEq<Complex<T>> for Complex<T>

impl<T: Clone + Integer> PartialEq<Ratio<T>> for Ratio<T>

impl<Section: PartialEq> PartialEq<SymbolFlags<Section>> for SymbolFlags<Section>

impl<E: PartialEq + Endian> PartialEq<U16Bytes<E>> for U16Bytes<E>

impl<E: PartialEq + Endian> PartialEq<U32Bytes<E>> for U32Bytes<E>

impl<E: PartialEq + Endian> PartialEq<U64Bytes<E>> for U64Bytes<E>

impl<E: PartialEq + Endian> PartialEq<I16Bytes<E>> for I16Bytes<E>

impl<E: PartialEq + Endian> PartialEq<I32Bytes<E>> for I32Bytes<E>

impl<E: PartialEq + Endian> PartialEq<I64Bytes<E>> for I64Bytes<E>

impl<'data> PartialEq<Bytes<'data>> for Bytes<'data>

impl<'data> PartialEq<SymbolMapName<'data>> for SymbolMapName<'data>

impl<'data> PartialEq<ObjectMapEntry<'data>> for ObjectMapEntry<'data>

impl<'data> PartialEq<Import<'data>> for Import<'data>

impl<'data> PartialEq<Export<'data>> for Export<'data>

impl<'data> PartialEq<CodeView<'data>> for CodeView<'data>

impl<'data> PartialEq<CompressedData<'data>> for CompressedData<'data>

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

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

impl<T> PartialEq<Pallet<T>> for Pallet<T>

impl<T: Config> PartialEq<Event<T>> for Event<T>

impl<T: Config> PartialEq<Call<T>> for Call<T>

impl<T> PartialEq<Pallet<T>> for Pallet<T>

impl<T: Config> PartialEq<Event<T>> for Event<T>

impl<T: Config> PartialEq<Call<T>> for Call<T>

impl<T, I> PartialEq<Pallet<T, I>> for Pallet<T, I>

impl<T: Config<I>, I: 'static> PartialEq<Event<T, I>> for Event<T, I>

impl<T: Config<I>, I: 'static> PartialEq<Call<T, I>> for Call<T, I>

impl<Balance: PartialEq> PartialEq<BalanceLock<Balance>> for BalanceLock<Balance>

impl<ReserveIdentifier: PartialEq, Balance: PartialEq> PartialEq<ReserveData<ReserveIdentifier, Balance>> for ReserveData<ReserveIdentifier, Balance>

impl<Balance: PartialEq> PartialEq<AccountData<Balance>> for AccountData<Balance>

impl<T: PartialEq + Config<I>, I: PartialEq + 'static> PartialEq<PositiveImbalance<T, I>> for PositiveImbalance<T, I> where
    T::Balance: PartialEq

impl<T: PartialEq + Config<I>, I: PartialEq + 'static> PartialEq<NegativeImbalance<T, I>> for NegativeImbalance<T, I> where
    T::Balance: PartialEq

impl<T, I> PartialEq<Pallet<T, I>> for Pallet<T, I>

impl<T: Config<I>, I: 'static> PartialEq<Event<T, I>> for Event<T, I>

impl<T: Config<I>, I: 'static> PartialEq<Call<T, I>> for Call<T, I>

impl<Balance: PartialEq> PartialEq<BalanceLock<Balance>> for BalanceLock<Balance>

impl<ReserveIdentifier: PartialEq, Balance: PartialEq> PartialEq<ReserveData<ReserveIdentifier, Balance>> for ReserveData<ReserveIdentifier, Balance>

impl<Balance: PartialEq> PartialEq<AccountData<Balance>> for AccountData<Balance>

impl<T: PartialEq + Config<I>, I: PartialEq + 'static> PartialEq<PositiveImbalance<T, I>> for PositiveImbalance<T, I> where
    T::Balance: PartialEq

impl<T: PartialEq + Config<I>, I: PartialEq + 'static> PartialEq<NegativeImbalance<T, I>> for NegativeImbalance<T, I> where
    T::Balance: PartialEq

impl<T> PartialEq<Pallet<T>> for Pallet<T>

impl<T: Config> PartialEq<Event<T>> for Event<T>

impl<T: Config> PartialEq<Call<T>> for Call<T>

impl<T> PartialEq<Pallet<T>> for Pallet<T>

impl<T: Config> PartialEq<Event<T>> for Event<T>

impl<Balance: PartialEq, BlockNumber: PartialEq> PartialEq<EscrowedAmount<Balance, BlockNumber>> for EscrowedAmount<Balance, BlockNumber>

impl<T: Config> PartialEq<Call<T>> for Call<T>

impl<T> PartialEq<Pallet<T>> for Pallet<T>

impl<T: Config> PartialEq<Event<T>> for Event<T>

impl<T: Config> PartialEq<Call<T>> for Call<T>

impl<T> PartialEq<Pallet<T>> for Pallet<T>

impl<T: Config> PartialEq<Event<T>> for Event<T>

impl<T: Config> PartialEq<Call<T>> for Call<T>

impl<T> PartialEq<Pallet<T>> for Pallet<T>

impl<T: Config> PartialEq<Event<T>> for Event<T>

impl<T: Config> PartialEq<Call<T>> for Call<T>

impl<T> PartialEq<Pallet<T>> for Pallet<T>

impl<T: Config> PartialEq<Call<T>> for Call<T>

impl<T> PartialEq<Pallet<T>> for Pallet<T>

impl<T: Config> PartialEq<Event<T>> for Event<T>

impl<T: Config> PartialEq<Call<T>> for Call<T>

impl<T> PartialEq<Pallet<T>> for Pallet<T>

impl<T: Config> PartialEq<Event<T>> for Event<T>

impl<T: Config> PartialEq<Call<T>> for Call<T>

impl<T> PartialEq<Pallet<T>> for Pallet<T>

impl<T: Config> PartialEq<Call<T>> for Call<T>

impl<Balance: PartialEq> PartialEq<InclusionFee<Balance>> for InclusionFee<Balance>

impl<Balance: PartialEq> PartialEq<FeeDetails<Balance>> for FeeDetails<Balance>

impl<Balance: PartialEq> PartialEq<RuntimeDispatchInfo<Balance>> for RuntimeDispatchInfo<Balance>

impl<T> PartialEq<Pallet<T>> for Pallet<T>

impl<T: Config> PartialEq<Call<T>> for Call<T>

impl<T> PartialEq<Pallet<T>> for Pallet<T>

impl<T: Config> PartialEq<Call<T>> for Call<T>

impl<T> PartialEq<Pallet<T>> for Pallet<T>

impl<T: Config> PartialEq<Event<T>> for Event<T>

impl<T: Config> PartialEq<Call<T>> for Call<T>

impl<T: PartialEq> PartialEq<Compact<T>> for Compact<T>

impl PartialEq<Type> for Type

impl PartialEq<Func> for Func

impl<T: PartialEq> PartialEq<IndexMap<T>> for IndexMap<T>

impl PartialEq<U128> for U128

impl PartialEq<U256> for U256

impl PartialEq<U512> for U512

impl PartialEq<H128> for H128

impl PartialEq<H160> for H160

impl PartialEq<H256> for H256

impl PartialEq<H512> for H512

impl<T> PartialEq<T> for Ident where
    T: ?Sized + AsRef<str>, 

impl<'t> PartialEq<Match<'t>> for Match<'t>

impl<'t> PartialEq<Match<'t>> for Match<'t>

impl PartialEq<Span> for Span

impl PartialEq<Ast> for Ast

impl PartialEq<Flag> for Flag

impl PartialEq<Hir> for Hir

impl<'a> PartialEq<Unexpected<'a>> for Unexpected<'a>

impl PartialEq<str> for Value

impl<'a> PartialEq<&'a str> for Value

impl PartialEq<Value> for str

impl<'a> PartialEq<Value> for &'a str

impl PartialEq<i8> for Value

impl PartialEq<Value> for i8

impl<'a> PartialEq<i8> for &'a Value

impl<'a> PartialEq<i8> for &'a mut Value

impl PartialEq<i16> for Value

impl PartialEq<Value> for i16

impl<'a> PartialEq<i16> for &'a Value

impl<'a> PartialEq<i16> for &'a mut Value

impl PartialEq<i32> for Value

impl PartialEq<Value> for i32

impl<'a> PartialEq<i32> for &'a Value

impl<'a> PartialEq<i32> for &'a mut Value

impl PartialEq<i64> for Value

impl PartialEq<Value> for i64

impl<'a> PartialEq<i64> for &'a Value

impl<'a> PartialEq<i64> for &'a mut Value

impl<'a> PartialEq<isize> for &'a Value

impl<'a> PartialEq<isize> for &'a mut Value

impl PartialEq<u8> for Value

impl PartialEq<Value> for u8

impl<'a> PartialEq<u8> for &'a Value

impl<'a> PartialEq<u8> for &'a mut Value

impl PartialEq<u16> for Value

impl PartialEq<Value> for u16

impl<'a> PartialEq<u16> for &'a Value

impl<'a> PartialEq<u16> for &'a mut Value

impl PartialEq<u32> for Value

impl PartialEq<Value> for u32

impl<'a> PartialEq<u32> for &'a Value

impl<'a> PartialEq<u32> for &'a mut Value

impl PartialEq<u64> for Value

impl PartialEq<Value> for u64

impl<'a> PartialEq<u64> for &'a Value

impl<'a> PartialEq<u64> for &'a mut Value

impl<'a> PartialEq<usize> for &'a Value

impl<'a> PartialEq<usize> for &'a mut Value

impl PartialEq<f32> for Value

impl PartialEq<Value> for f32

impl<'a> PartialEq<f32> for &'a Value

impl<'a> PartialEq<f32> for &'a mut Value

impl PartialEq<f64> for Value

impl PartialEq<Value> for f64

impl<'a> PartialEq<f64> for &'a Value

impl<'a> PartialEq<f64> for &'a mut Value

impl PartialEq<bool> for Value

impl PartialEq<Value> for bool

impl<'a> PartialEq<bool> for &'a Value

impl<'a> PartialEq<bool> for &'a mut Value

impl<'a, T, C> PartialEq<T> for Ref<'a, T, C> where
    T: PartialEq<T> + Clear + Default,
    C: Config

impl<'a, T, C> PartialEq<T> for RefMut<'a, T, C> where
    T: PartialEq<T> + Clear + Default,
    C: Config

impl<T, C> PartialEq<T> for OwnedRef<T, C> where
    T: PartialEq<T> + Clear + Default,
    C: Config

impl<T, C> PartialEq<T> for OwnedRefMut<T, C> where
    T: PartialEq<T> + Clear + Default,
    C: Config

impl<'a, T, C> PartialEq<T> for Entry<'a, T, C> where
    T: PartialEq<T>,
    C: Config

impl<T, C> PartialEq<T> for OwnedEntry<T, C> where
    T: PartialEq<T>,
    C: Config

impl<N: PartialEq> PartialEq<AutoSimd<N>> for AutoSimd<N>

impl<A: Array, B: Array> PartialEq<SmallVec<B>> for SmallVec<A> where
    A::Item: PartialEq<B::Item>, 

impl<'a> PartialEq<RuntimeCode<'a>> for RuntimeCode<'a>

impl PartialEq<Void> for Void

impl<Block: PartialEq + BlockT> PartialEq<BlockId<Block>> for BlockId<Block> where
    Block::Hash: PartialEq

impl<Header: PartialEq, Extrinsic: PartialEq + MaybeSerialize> PartialEq<Block<Header, Extrinsic>> for Block<Header, Extrinsic>

impl<Block: PartialEq> PartialEq<SignedBlock<Block>> for SignedBlock<Block>

impl<AccountId: PartialEq, Call: PartialEq, Extra: PartialEq> PartialEq<CheckedExtrinsic<AccountId, Call, Extra>> for CheckedExtrinsic<AccountId, Call, Extra>

impl<'a> PartialEq<DigestItemRef<'a>> for DigestItemRef<'a>

impl PartialEq<Era> for Era

impl<Number: PartialEq + Copy + Into<U256> + TryFrom<U256>, Hash: PartialEq + HashT> PartialEq<Header<Number, Hash>> for Header<Number, Hash> where
    Hash::Output: PartialEq,
    Hash::Output: PartialEq,
    Hash::Output: PartialEq

impl<Address: PartialEq, Call: PartialEq, Signature: PartialEq, Extra: PartialEq> PartialEq<UncheckedExtrinsic<Address, Call, Signature, Extra>> for UncheckedExtrinsic<Address, Call, Signature, Extra> where
    Extra: SignedExtension

impl<AccountId: PartialEq, AccountIndex: PartialEq> PartialEq<MultiAddress<AccountId, AccountIndex>> for MultiAddress<AccountId, AccountIndex>

impl<'a, T: PartialEq> PartialEq<Request<'a, T>> for Request<'a, T>

impl<Xt: PartialEq> PartialEq<Block<Xt>> for Block<Xt>

impl<Call: PartialEq, Extra: PartialEq> PartialEq<TestXt<Call, Extra>> for TestXt<Call, Extra>

impl<Info: PartialEq> PartialEq<DispatchErrorWithPostInfo<Info>> for DispatchErrorWithPostInfo<Info> where
    Info: Eq + PartialEq + Clone + Copy + Encode + Decode + Printable

impl<Reporter: PartialEq, Offender: PartialEq> PartialEq<OffenceDetails<Reporter, Offender>> for OffenceDetails<Reporter, Offender>

impl<H: Hasher> PartialEq<TestExternalities<H>> for TestExternalities<H> where
    H::Out: Ord + 'static + Codec

impl<T: Into<u64> + Copy> PartialEq<T> for Timestamp

impl PartialEq<dyn Function + 'static> for dyn Function

impl PartialEq<Beta> for Beta

impl PartialEq<Chi> for Chi

impl PartialEq<Exp> for Exp

impl<D: PartialEq> PartialEq<Data<D>> for Data<D>

impl PartialEq<As> for As

impl PartialEq<Auto> for Auto

impl PartialEq<Box> for Box

impl PartialEq<Do> for Do

impl PartialEq<Dyn> for Dyn

impl PartialEq<Else> for Else

impl PartialEq<Enum> for Enum

impl PartialEq<Fn> for Fn

impl PartialEq<For> for For

impl PartialEq<If> for If

impl PartialEq<Impl> for Impl

impl PartialEq<In> for In

impl PartialEq<Let> for Let

impl PartialEq<Loop> for Loop

impl PartialEq<Mod> for Mod

impl PartialEq<Move> for Move

impl PartialEq<Mut> for Mut

impl PartialEq<Priv> for Priv

impl PartialEq<Pub> for Pub

impl PartialEq<Ref> for Ref

impl PartialEq<Try> for Try

impl PartialEq<Type> for Type

impl PartialEq<Use> for Use

impl PartialEq<Add> for Add

impl PartialEq<And> for And

impl PartialEq<At> for At

impl PartialEq<Bang> for Bang

impl PartialEq<Div> for Div

impl PartialEq<Dot> for Dot

impl PartialEq<Dot2> for Dot2

impl PartialEq<Dot3> for Dot3

impl PartialEq<Eq> for Eq

impl PartialEq<EqEq> for EqEq

impl PartialEq<Ge> for Ge

impl PartialEq<Gt> for Gt

impl PartialEq<Le> for Le

impl PartialEq<Lt> for Lt

impl PartialEq<Ne> for Ne

impl PartialEq<Or> for Or

impl PartialEq<OrEq> for OrEq

impl PartialEq<OrOr> for OrOr

impl PartialEq<Rem> for Rem

impl PartialEq<Semi> for Semi

impl PartialEq<Shl> for Shl

impl PartialEq<Shr> for Shr

impl PartialEq<Star> for Star

impl PartialEq<Sub> for Sub

impl<'a> PartialEq<ImplGenerics<'a>> for ImplGenerics<'a>

impl<'a> PartialEq<TypeGenerics<'a>> for TypeGenerics<'a>

impl<'a> PartialEq<Turbofish<'a>> for Turbofish<'a>

impl<'a> PartialEq<Cursor<'a>> for Cursor<'a>

impl<T, P> PartialEq<Punctuated<T, P>> for Punctuated<T, P> where
    T: PartialEq,
    P: PartialEq

impl PartialEq<Abi> for Abi

impl PartialEq<Arm> for Arm

impl PartialEq<Data> for Data

impl PartialEq<Expr> for Expr

impl PartialEq<File> for File

impl PartialEq<Item> for Item

impl PartialEq<Lit> for Lit

impl PartialEq<Meta> for Meta

impl PartialEq<Pat> for Pat

impl PartialEq<Path> for Path

impl PartialEq<Stmt> for Stmt

impl PartialEq<Type> for Type

impl PartialEq<UnOp> for UnOp

impl<'a> PartialEq<BindingInfo<'a>> for BindingInfo<'a>

impl<'a> PartialEq<VariantAst<'a>> for VariantAst<'a>

impl<'a> PartialEq<VariantInfo<'a>> for VariantInfo<'a>

impl<'a> PartialEq<Structure<'a>> for Structure<'a>

impl<A: Array> PartialEq<ArrayVec<A>> for ArrayVec<A> where
    A::Item: PartialEq

impl<A: Array> PartialEq<&'_ A> for ArrayVec<A> where
    A::Item: PartialEq

impl<A: Array> PartialEq<&'_ [<A as Array>::Item]> for ArrayVec<A> where
    A::Item: PartialEq

impl<'s, T> PartialEq<SliceVec<'s, T>> for SliceVec<'s, T> where
    T: PartialEq

impl<'s, T> PartialEq<&'_ [T]> for SliceVec<'s, T> where
    T: PartialEq

impl<A: Array> PartialEq<TinyVec<A>> for TinyVec<A> where
    A::Item: PartialEq

impl<A: Array> PartialEq<&'_ A> for TinyVec<A> where
    A::Item: PartialEq

impl<A: Array> PartialEq<&'_ [<A as Array>::Item]> for TinyVec<A> where
    A::Item: PartialEq

impl<T: PartialEq> PartialEq<Spanned<T>> for Spanned<T>

impl PartialEq<Cogs> for Cogs

impl PartialEq<A> for A

impl PartialEq<L> for L

impl PartialEq<E> for E

impl PartialEq<I> for I

impl PartialEq<X> for X

impl PartialEq<P> for P

impl PartialEq<B> for B

impl<Hash: PartialEq> PartialEq<TxKeysT<Hash>> for TxKeysT<Hash>

impl<AccountId: PartialEq> PartialEq<OrderHeader<AccountId>> for OrderHeader<AccountId>

impl<Hash: PartialEq> PartialEq<OrderItem<Hash>> for OrderItem<Hash>

impl<Hash: PartialEq> PartialEq<TxKeysL<Hash>> for TxKeysL<Hash>

impl<Hash: PartialEq> PartialEq<TxKeysM<Hash>> for TxKeysM<Hash>

impl<Hash: PartialEq> PartialEq<TxKeysS<Hash>> for TxKeysS<Hash>

impl<AccountId: PartialEq, ProjectStatus: PartialEq> PartialEq<DeletedProject<AccountId, ProjectStatus>> for DeletedProject<AccountId, ProjectStatus>

impl<AccountId: PartialEq, ReferenceHash: PartialEq, NumberOfBlocks: PartialEq, LockStatus: PartialEq, StatusOfTimeRecord: PartialEq, ReasonCodeStruct: PartialEq, PostingPeriod: PartialEq, StartOrEndBlockNumber: PartialEq, NumberOfBreaks: PartialEq> PartialEq<Timekeeper<AccountId, ReferenceHash, NumberOfBlocks, LockStatus, StatusOfTimeRecord, ReasonCodeStruct, PostingPeriod, StartOrEndBlockNumber, NumberOfBreaks>> for Timekeeper<AccountId, ReferenceHash, NumberOfBlocks, LockStatus, StatusOfTimeRecord, ReasonCodeStruct, PostingPeriod, StartOrEndBlockNumber, NumberOfBreaks>

impl PartialEq<Span> for Span

impl PartialEq<Kind> for Kind

impl PartialEq<Id> for Id

impl PartialEq<Json> for Json

impl PartialEq<Full> for Full

impl<A: PartialEq, B: PartialEq> PartialEq<EitherWriter<A, B>> for EitherWriter<A, B>

impl<M: PartialEq, F: PartialEq> PartialEq<WithFilter<M, F>> for WithFilter<M, F>

impl<A: PartialEq, B: PartialEq> PartialEq<OrElse<A, B>> for OrElse<A, B>

impl<A: PartialEq, B: PartialEq> PartialEq<Tee<A, B>> for Tee<A, B>

impl<'a> PartialEq<NodeHandle<'a>> for NodeHandle<'a>

impl<'a> PartialEq<Node<'a>> for Node<'a>

impl<HO: PartialEq, CE: PartialEq> PartialEq<Error<HO, CE>> for Error<HO, CE>

impl<HO: PartialEq> PartialEq<Record<HO>> for Record<HO>

impl<'a> PartialEq<NibbleSlice<'a>> for NibbleSlice<'a>

impl<T: PartialEq, E: PartialEq> PartialEq<TrieError<T, E>> for TrieError<T, E>

impl PartialEq<B0> for B0

impl PartialEq<B1> for B1

impl<U: PartialEq + Unsigned + NonZero> PartialEq<PInt<U>> for PInt<U>

impl<U: PartialEq + Unsigned + NonZero> PartialEq<NInt<U>> for NInt<U>

impl PartialEq<Z0> for Z0

impl<U: PartialEq, B: PartialEq> PartialEq<UInt<U, B>> for UInt<U, B>

impl<V: PartialEq, A: PartialEq> PartialEq<TArr<V, A>> for TArr<V, A>

impl PartialEq<Less> for Less

impl<T: Into<F32> + Copy> PartialEq<T> for F32

impl<T: Into<F64> + Copy> PartialEq<T> for F64