1.0.0[][src]Trait frame_support::dispatch::PartialEq

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

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

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

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

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

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

Loading content...

Provided methods

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

This method tests for !=.

Loading content...

Implementations on Foreign Types

impl PartialEq<Output> for Output[src]

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

impl PartialEq<IntoStringError> for IntoStringError[src]

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

impl<T> PartialEq<Cursor<T>> for Cursor<T> where
    T: PartialEq<T>, 
[src]

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

impl PartialEq<ThreadId> for ThreadId[src]

impl PartialEq<VarError> for VarError[src]

impl PartialEq<Permissions> for Permissions[src]

impl PartialEq<Ipv4Addr> for IpAddr[src]

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

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

impl PartialEq<ExitStatus> for ExitStatus[src]

impl PartialEq<IpAddr> for Ipv4Addr[src]

impl PartialEq<BacktraceStatus> for BacktraceStatus[src]

impl PartialEq<PathBuf> for PathBuf[src]

impl PartialEq<AddrParseError> for AddrParseError[src]

impl PartialEq<RecvError> for RecvError[src]

impl PartialEq<Instant> for Instant[src]

impl PartialEq<WaitTimeoutResult> for WaitTimeoutResult[src]

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

impl PartialEq<OsStr> for OsStr[src]

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

impl PartialEq<FromVecWithNulError> for FromVecWithNulError[src]

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

impl PartialEq<OsString> for OsString[src]

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

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

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

impl PartialEq<str> for OsStr[src]

impl<T> PartialEq<SyncOnceCell<T>> for SyncOnceCell<T> where
    T: PartialEq<T>, 
[src]

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

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

impl PartialEq<ErrorKind> for ErrorKind[src]

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

impl PartialEq<Path> for Path[src]

impl PartialEq<Ipv4Addr> for Ipv4Addr[src]

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

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

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

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

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

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

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

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

impl PartialEq<NulError> for NulError[src]

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

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

impl PartialEq<TryRecvError> for TryRecvError[src]

impl PartialEq<FromBytesWithNulError> for FromBytesWithNulError[src]

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

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

impl PartialEq<IpAddr> for IpAddr[src]

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

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

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

impl PartialEq<SystemTime> for SystemTime[src]

impl<T> PartialEq<TrySendError<T>> for TrySendError<T> where
    T: PartialEq<T>, 
[src]

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

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

impl PartialEq<Shutdown> for Shutdown[src]

impl PartialEq<OsStr> for str[src]

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

impl PartialEq<UCred> for UCred[src]

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

impl PartialEq<RecvTimeoutError> for RecvTimeoutError[src]

impl PartialEq<SocketAddrV6> for SocketAddrV6[src]

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

impl PartialEq<Ipv6Addr> for IpAddr[src]

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

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

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

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

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

impl PartialEq<Ipv6MulticastScope> for Ipv6MulticastScope[src]

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

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

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

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

impl PartialEq<CStr> for CStr[src]

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

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

impl<T> PartialEq<SendError<T>> for SendError<T> where
    T: PartialEq<T>, 
[src]

impl PartialEq<str> for OsString[src]

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

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

impl PartialEq<SocketAddrV4> for SocketAddrV4[src]

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

impl PartialEq<CString> for CString[src]

impl PartialEq<AccessError> for AccessError[src]

impl PartialEq<SeekFrom> for SeekFrom[src]

impl PartialEq<FileType> for FileType[src]

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

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

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

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

impl PartialEq<SocketAddr> for SocketAddr[src]

impl PartialEq<StripPrefixError> for StripPrefixError[src]

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

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

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

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

impl PartialEq<OsString> for str[src]

impl PartialEq<IpAddr> for Ipv6Addr[src]

impl PartialEq<Ipv6Addr> for Ipv6Addr[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]

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]

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]

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]

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]

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]

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

impl<'a> PartialEq<Location<'a>> for Location<'a>[src]

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

impl PartialEq<NonZeroU64> for NonZeroU64[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]

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

impl PartialEq<isize> for isize[src]

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

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

impl PartialEq<u128> for u128[src]

impl<Ret, A, B> PartialEq<extern "C" fn(A, B, ...) -> Ret> for extern "C" fn(A, B, ...) -> Ret[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]

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]

impl PartialEq<NonZeroU32> for NonZeroU32[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]

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]

impl PartialEq<NonZeroU128> for NonZeroU128[src]

impl PartialEq<ParseBoolError> for ParseBoolError[src]

impl PartialEq<TypeId> for TypeId[src]

impl PartialEq<bool> for bool[src]

impl<T> PartialEq<Reverse<T>> for Reverse<T> where
    T: PartialEq<T>, 
[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]

impl PartialEq<Ordering> for Ordering[src]

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

impl PartialEq<DecodeUtf16Error> for DecodeUtf16Error[src]

impl PartialEq<NoneError> for NoneError[src]

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

impl<Ret, A, B> PartialEq<unsafe extern "C" fn(A, B) -> Ret> for unsafe extern "C" fn(A, B) -> Ret[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]

impl PartialEq<Duration> for Duration[src]

impl<T> PartialEq<Discriminant<T>> for Discriminant<T>[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]

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

impl<T> PartialEq<*mut T> for *mut T where
    T: ?Sized
[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]

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]

impl<'_, '_, A, B> PartialEq<&'_ B> for &'_ A where
    A: PartialEq<B> + ?Sized,
    B: ?Sized
[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
    C: PartialEq<C>,
    I: PartialEq<I> + ?Sized,
    A: PartialEq<A>,
    F: PartialEq<F>,
    E: PartialEq<E>,
    G: PartialEq<G>,
    H: PartialEq<H>,
    B: PartialEq<B>,
    D: PartialEq<D>, 
[src]

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

impl PartialEq<usize> for usize[src]

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

impl PartialEq<AllocError> for AllocError[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]

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

impl<A> PartialEq<(A,)> for (A,) where
    A: PartialEq<A> + ?Sized
[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]

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
    C: PartialEq<C>,
    A: PartialEq<A>,
    F: PartialEq<F>,
    E: PartialEq<E>,
    G: PartialEq<G>,
    H: PartialEq<H> + ?Sized,
    B: PartialEq<B>,
    D: PartialEq<D>, 
[src]

impl PartialEq<FpCategory> for FpCategory[src]

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

impl PartialEq<Layout> for Layout[src]

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

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

impl PartialEq<Utf8Error> for Utf8Error[src]

impl PartialEq<NonZeroI8> for NonZeroI8[src]

impl<B, C> PartialEq<ControlFlow<B, C>> for ControlFlow<B, C> where
    C: PartialEq<C>,
    B: PartialEq<B>, 
[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]

impl<Ret, A, B> PartialEq<extern "C" fn(A, B) -> Ret> for extern "C" fn(A, B) -> Ret[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]

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]

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

impl PartialEq<f64> for f64[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]

impl PartialEq<Ordering> for Ordering[src]

impl PartialEq<u8> for u8[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]

impl<Ret, A> PartialEq<extern "C" fn(A, ...) -> Ret> for extern "C" fn(A, ...) -> Ret[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]

impl<A, B> PartialEq<[B]> for [A] where
    A: PartialEq<B>, 
[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]

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]

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

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

impl PartialEq<ParseCharError> for ParseCharError[src]

impl PartialEq<i32> for i32[src]

impl PartialEq<NonZeroU8> for NonZeroU8[src]

impl PartialEq<NonZeroIsize> for NonZeroIsize[src]

impl PartialEq<()> for ()[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]

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]

impl<T> PartialEq<Cell<T>> for Cell<T> where
    T: PartialEq<T> + Copy
[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]

impl PartialEq<NonZeroU16> for NonZeroU16[src]

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

impl PartialEq<str> for str[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]

impl<Ret, A, B, C> PartialEq<extern "C" fn(A, B, C, ...) -> Ret> for extern "C" fn(A, B, C, ...) -> Ret[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]

impl PartialEq<RangeFull> for RangeFull[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]

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

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

Panics

Panics if the value in either RefCell is currently borrowed.

impl<A, B, const N: usize> PartialEq<[B; N]> for [A; N] where
    A: PartialEq<B>, 
[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]

impl PartialEq<RawWaker> for RawWaker[src]

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

impl PartialEq<ParseFloatError> for ParseFloatError[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]

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

impl<Ret, A, B, C> PartialEq<unsafe fn(A, B, C) -> Ret> for unsafe fn(A, B, C) -> Ret[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]

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]

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]

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

impl PartialEq<NonZeroI32> for NonZeroI32[src]

impl PartialEq<NonZeroUsize> for NonZeroUsize[src]

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

impl PartialEq<IntErrorKind> for IntErrorKind[src]

impl PartialEq<f32> for f32[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]

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

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

impl PartialEq<CpuidResult> for CpuidResult[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]

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]

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

impl<'_, '_, A, B> PartialEq<&'_ mut B> for &'_ A where
    A: PartialEq<B> + ?Sized,
    B: ?Sized
[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]

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]

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]

impl<T> PartialEq<Bound<T>> for Bound<T> where
    T: PartialEq<T>, 
[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]

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

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

impl<Idx> PartialEq<RangeInclusive<Idx>> for RangeInclusive<Idx> where
    Idx: PartialEq<Idx>, 
[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]

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

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

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

impl PartialEq<NonZeroI128> for NonZeroI128[src]

impl<H> PartialEq<BuildHasherDefault<H>> for BuildHasherDefault<H>[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]

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

impl<T> PartialEq<OnceCell<T>> for OnceCell<T> where
    T: PartialEq<T>, 
[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]

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

impl PartialEq<char> for char[src]

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

impl<Ret, A> PartialEq<unsafe fn(A) -> Ret> for unsafe fn(A) -> Ret[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]

impl PartialEq<RawWakerVTable> for RawWakerVTable[src]

impl PartialEq<ParseIntError> for ParseIntError[src]

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

impl PartialEq<Infallible> for Infallible[src]

impl PartialEq<NonZeroI16> for NonZeroI16[src]

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

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

impl PartialEq<u64> for u64[src]

impl PartialEq<u32> for u32[src]

impl PartialEq<!> for ![src]

impl PartialEq<i16> for i16[src]

impl<T> PartialEq<Option<T>> for Option<T> where
    T: PartialEq<T>, 
[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
    C: PartialEq<C>,
    I: PartialEq<I>,
    A: PartialEq<A>,
    F: PartialEq<F>,
    E: PartialEq<E>,
    G: PartialEq<G>,
    H: PartialEq<H>,
    B: PartialEq<B>,
    D: PartialEq<D>,
    J: PartialEq<J> + ?Sized
[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
    C: PartialEq<C>,
    A: PartialEq<A>,
    F: PartialEq<F>,
    E: PartialEq<E>,
    G: PartialEq<G> + ?Sized,
    B: PartialEq<B>,
    D: PartialEq<D>, 
[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]

impl PartialEq<SearchStep> for SearchStep[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]

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

impl PartialEq<NonZeroI64> for NonZeroI64[src]

impl PartialEq<LayoutError> for LayoutError[src]

impl PartialEq<i64> for i64[src]

impl PartialEq<i8> for i8[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]

impl PartialEq<i128> for i128[src]

impl PartialEq<TryFromIntError> for TryFromIntError[src]

impl<Ret, A, B, C> PartialEq<fn(A, B, C) -> Ret> for fn(A, B, C) -> Ret[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]

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]

impl PartialEq<u16> for u16[src]

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

impl<Ret, A> PartialEq<extern "C" fn(A) -> Ret> for extern "C" fn(A) -> Ret[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]

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

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

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

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

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

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

impl PartialEq<FromUtf8Error> for FromUtf8Error[src]

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

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

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

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

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

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

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

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

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

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

impl<'_, '_, T, U> PartialEq<&'_ [U]> for Cow<'_, [T]> where
    T: PartialEq<U> + Clone
[src]

impl<'_, '_, T, U> PartialEq<&'_ mut [U]> for Cow<'_, [T]> where
    T: PartialEq<U> + Clone
[src]

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

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

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

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

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

impl<'_, T, U, A> PartialEq<Vec<U, A>> for Cow<'_, [T]> where
    T: PartialEq<U> + Clone,
    A: Allocator
[src]

impl PartialEq<String> for String[src]

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

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

impl<T, U, A> PartialEq<Vec<U, A>> for [T] where
    T: PartialEq<U>,
    A: Allocator
[src]

impl<'_, T, U, A> PartialEq<Vec<U, A>> for &'_ mut [T] where
    T: PartialEq<U>,
    A: Allocator
[src]

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

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

impl<'_, T, U, A> PartialEq<Vec<U, A>> for &'_ [T] where
    T: PartialEq<U>,
    A: Allocator
[src]

impl PartialEq<TryReserveError> for TryReserveError[src]

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

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

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

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

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

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

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

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<_Unwind_Reason_Code> for _Unwind_Reason_Code

impl PartialEq<_Unwind_Action> for _Unwind_Action

impl PartialEq<Error> for Error

impl PartialEq<OptionBool> for OptionBool

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

impl<A> PartialEq<str> for ArrayString<A> where
    A: Array<Item = u8> + Copy
[src]

impl<A> PartialEq<ArrayString<A>> for ArrayString<A> where
    A: Array<Item = u8> + Copy
[src]

impl<A> PartialEq<ArrayVec<A>> for ArrayVec<A> where
    A: Array,
    <A as Array>::Item: PartialEq<<A as Array>::Item>, 
[src]

impl<T> PartialEq<CapacityError<T>> for CapacityError<T> where
    T: PartialEq<T>, 
[src]

impl<A> PartialEq<ArrayString<A>> for str where
    A: Array<Item = u8> + Copy
[src]

impl<A> PartialEq<[<A as Array>::Item]> for ArrayVec<A> where
    A: Array,
    <A as Array>::Item: PartialEq<<A as Array>::Item>, 
[src]

impl PartialEq<Error> for Error

impl<'a> PartialEq<Unexpected<'a>> for Unexpected<'a>[src]

impl PartialEq<Error> for Error[src]

impl PartialEq<Level> for LevelFilter[src]

impl PartialEq<Id> for Id[src]

impl PartialEq<LevelFilter> for LevelFilter[src]

impl PartialEq<Kind> for Kind[src]

impl PartialEq<Level> for Level[src]

impl PartialEq<LevelFilter> for Level[src]

impl PartialEq<Field> for Field[src]

impl PartialEq<Empty> for Empty[src]

impl PartialEq<Identifier> for Identifier[src]

impl PartialEq<Span> for Span[src]

impl PartialEq<LevelFilter> for Level[src]

impl<'a> PartialEq<MetadataBuilder<'a>> for MetadataBuilder<'a>[src]

impl PartialEq<Level> for LevelFilter[src]

impl<'a> PartialEq<Metadata<'a>> for Metadata<'a>[src]

impl PartialEq<ParseLevelError> for ParseLevelError[src]

impl<'k, 'ko> PartialEq<Key<'ko>> for Key<'k>[src]

impl PartialEq<Level> for Level[src]

impl PartialEq<LevelFilter> for LevelFilter[src]

impl PartialEq<Uptime> for Uptime[src]

impl PartialEq<SystemTime> for SystemTime[src]

impl PartialEq<Directive> for Directive[src]

impl PartialEq<Full> for Full[src]

impl PartialEq<Pretty> for Pretty[src]

impl PartialEq<ChronoLocal> for ChronoLocal[src]

impl PartialEq<ChronoUtc> for ChronoUtc[src]

impl PartialEq<FmtSpan> for FmtSpan[src]

impl PartialEq<Compact> for Compact[src]

impl PartialEq<Json> for Json[src]

impl PartialEq<Char> for char

impl PartialEq<Error> for Error

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

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

impl PartialEq<Match> for Match

impl PartialEq<MatchKind> for MatchKind

impl PartialEq<MatchKind> for MatchKind

impl PartialEq<WordBoundary> for WordBoundary

impl PartialEq<ClassPerlKind> for ClassPerlKind

impl PartialEq<Literal> for Literal

impl PartialEq<ClassSetBinaryOp> for ClassSetBinaryOp

impl PartialEq<Position> for Position

impl PartialEq<Assertion> for Assertion

impl PartialEq<ClassAscii> for ClassAscii

impl PartialEq<ClassBytes> for ClassBytes

impl PartialEq<ClassSetRange> for ClassSetRange

impl PartialEq<Literals> for Literals

impl PartialEq<Flag> for Flag

impl PartialEq<Literal> for Literal

impl PartialEq<Literal> for Literal

impl PartialEq<Concat> for Concat

impl PartialEq<Comment> for Comment

impl PartialEq<Flags> for Flags

impl PartialEq<ClassUnicodeRange> for ClassUnicodeRange

impl PartialEq<ClassUnicode> for ClassUnicode

impl PartialEq<ClassSetItem> for ClassSetItem

impl PartialEq<Anchor> for Anchor

impl PartialEq<Hir> for Hir

impl PartialEq<ClassBytesRange> for ClassBytesRange

impl PartialEq<LiteralKind> for LiteralKind

impl PartialEq<Utf8Sequence> for Utf8Sequence

impl PartialEq<Group> for Group

impl PartialEq<ClassSetUnion> for ClassSetUnion

impl PartialEq<RepetitionOp> for RepetitionOp

impl PartialEq<RepetitionKind> for RepetitionKind

impl PartialEq<SpecialLiteralKind> for SpecialLiteralKind

impl PartialEq<Group> for Group

impl PartialEq<ClassBracketed> for ClassBracketed

impl PartialEq<RepetitionRange> for RepetitionRange

impl PartialEq<Repetition> for Repetition

impl PartialEq<SetFlags> for SetFlags

impl PartialEq<ErrorKind> for ErrorKind

impl PartialEq<Class> for Class

impl PartialEq<Alternation> for Alternation

impl PartialEq<Class> for Class

impl PartialEq<RepetitionKind> for RepetitionKind

impl PartialEq<HexLiteralKind> for HexLiteralKind

impl PartialEq<HirKind> for HirKind

impl PartialEq<GroupKind> for GroupKind

impl PartialEq<GroupKind> for GroupKind

impl PartialEq<FlagsItem> for FlagsItem

impl PartialEq<ClassSetBinaryOpKind> for ClassSetBinaryOpKind

impl PartialEq<ClassPerl> for ClassPerl

impl PartialEq<CaptureName> for CaptureName

impl PartialEq<ClassSet> for ClassSet

impl PartialEq<ErrorKind> for ErrorKind

impl PartialEq<ClassUnicodeKind> for ClassUnicodeKind

impl PartialEq<Utf8Range> for Utf8Range

impl PartialEq<Repetition> for Repetition

impl PartialEq<FlagsItemKind> for FlagsItemKind

impl PartialEq<AssertionKind> for AssertionKind

impl PartialEq<ClassUnicode> for ClassUnicode

impl PartialEq<WithComments> for WithComments

impl PartialEq<Span> for Span

impl PartialEq<Error> for Error

impl PartialEq<Error> for Error

impl PartialEq<Error> for Error

impl PartialEq<ClassAsciiKind> for ClassAsciiKind

impl PartialEq<Ast> for Ast

impl PartialEq<ClassUnicodeOpKind> for ClassUnicodeOpKind

impl PartialEq<RepetitionRange> for RepetitionRange

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

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

impl PartialEq<WaitTimeoutResult> for WaitTimeoutResult

impl PartialEq<OnceState> for OnceState

impl PartialEq<UnparkToken> for UnparkToken

impl PartialEq<UnparkResult> for UnparkResult

impl PartialEq<RequeueOp> for RequeueOp

impl PartialEq<ParkToken> for ParkToken

impl PartialEq<ParkResult> for ParkResult

impl PartialEq<FilterOp> for FilterOp

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

impl PartialEq<regmatch_t> for regmatch_t

impl PartialEq<ff_effect> for ff_effect

impl PartialEq<Elf64_Chdr> for Elf64_Chdr

impl PartialEq<lconv> for lconv

impl PartialEq<stat> for stat

impl PartialEq<pthread_cond_t> for pthread_cond_t

impl PartialEq<glob_t> for glob_t

impl PartialEq<_libc_fpstate> for _libc_fpstate

impl PartialEq<sockaddr_nl> for sockaddr_nl

impl PartialEq<aiocb> for aiocb

impl PartialEq<tm> for tm

impl PartialEq<group> for group

impl PartialEq<ip_mreqn> for ip_mreqn

impl PartialEq<statvfs64> for statvfs64

impl PartialEq<Elf64_Ehdr> for Elf64_Ehdr

impl PartialEq<spwd> for spwd

impl PartialEq<Dl_info> for Dl_info

impl PartialEq<fd_set> for fd_set

impl PartialEq<sem_t> for sem_t

impl PartialEq<__exit_status> for __exit_status

impl PartialEq<Elf32_Sym> for Elf32_Sym

impl PartialEq<nlmsgerr> for nlmsgerr

impl PartialEq<timeval> for timeval

impl PartialEq<stack_t> for stack_t

impl PartialEq<pthread_mutex_t> for pthread_mutex_t

impl PartialEq<msginfo> for msginfo

impl PartialEq<termios> for termios

impl PartialEq<_libc_fpxreg> for _libc_fpxreg

impl PartialEq<rlimit> for rlimit

impl PartialEq<stat64> for stat64

impl PartialEq<dirent> for dirent

impl PartialEq<flock> for flock

impl PartialEq<pollfd> for pollfd

impl PartialEq<shmid_ds> for shmid_ds

impl PartialEq<Elf32_Phdr> for Elf32_Phdr

impl PartialEq<mntent> for mntent

impl PartialEq<sockaddr_ll> for sockaddr_ll

impl PartialEq<_libc_xmmreg> for _libc_xmmreg

impl PartialEq<sched_param> for sched_param

impl PartialEq<if_nameindex> for if_nameindex

impl PartialEq<ff_rumble_effect> for ff_rumble_effect

impl PartialEq<genlmsghdr> for genlmsghdr

impl PartialEq<itimerval> for itimerval

impl PartialEq<statfs> for statfs

impl PartialEq<winsize> for winsize

impl PartialEq<Elf32_Chdr> for Elf32_Chdr

impl PartialEq<sockaddr_un> for sockaddr_un

impl PartialEq<posix_spawnattr_t> for posix_spawnattr_t

impl PartialEq<utimbuf> for utimbuf

impl PartialEq<in6_pktinfo> for in6_pktinfo

impl PartialEq<ipc_perm> for ipc_perm

impl PartialEq<sigaction> for sigaction

impl PartialEq<nl_mmap_hdr> for nl_mmap_hdr

impl PartialEq<signalfd_siginfo> for signalfd_siginfo

impl PartialEq<dqblk> for dqblk

impl PartialEq<pthread_rwlockattr_t> for pthread_rwlockattr_t

impl PartialEq<statx> for statx

impl PartialEq<dirent64> for dirent64

impl PartialEq<rtentry> for rtentry

impl PartialEq<Elf64_Phdr> for Elf64_Phdr

impl PartialEq<epoll_event> for epoll_event

impl PartialEq<ucontext_t> for ucontext_t

impl PartialEq<ff_periodic_effect> for ff_periodic_effect

impl PartialEq<Elf32_Ehdr> for Elf32_Ehdr

impl PartialEq<__c_anonymous_sockaddr_can_tp> for __c_anonymous_sockaddr_can_tp

impl PartialEq<nl_pktinfo> for nl_pktinfo

impl PartialEq<ff_envelope> for ff_envelope

impl PartialEq<flock64> for flock64

impl PartialEq<fsid_t> for fsid_t

impl PartialEq<sockaddr> for sockaddr

impl PartialEq<ff_replay> for ff_replay

impl PartialEq<iovec> for iovec

impl PartialEq<packet_mreq> for packet_mreq

impl PartialEq<statvfs> for statvfs

impl PartialEq<in_addr> for in_addr

impl PartialEq<input_keymap_entry> for input_keymap_entry

impl PartialEq<statfs64> for statfs64

impl PartialEq<user_regs_struct> for user_regs_struct

impl PartialEq<ifaddrs> for ifaddrs

impl PartialEq<af_alg_iv> for af_alg_iv

impl PartialEq<linger> for linger

impl PartialEq<cmsghdr> for cmsghdr

impl PartialEq<sembuf> for sembuf

impl PartialEq<ntptimeval> for ntptimeval

impl PartialEq<sysinfo> for sysinfo

impl PartialEq<Elf64_Sym> for Elf64_Sym

impl PartialEq<pthread_rwlock_t> for pthread_rwlock_t

impl PartialEq<regex_t> for regex_t

impl PartialEq<termios2> for termios2

impl PartialEq<Elf64_Shdr> for Elf64_Shdr

impl PartialEq<siginfo_t> for siginfo_t

impl PartialEq<tms> for tms

impl PartialEq<sigset_t> for sigset_t

impl PartialEq<posix_spawn_file_actions_t> for posix_spawn_file_actions_t

impl PartialEq<sock_extended_err> for sock_extended_err

impl PartialEq<__timeval> for __timeval

impl PartialEq<itimerspec> for itimerspec

impl PartialEq<utmpx> for utmpx

impl PartialEq<msghdr> for msghdr

impl PartialEq<timespec> for timespec

impl PartialEq<cpu_set_t> for cpu_set_t

impl PartialEq<input_event> for input_event

impl PartialEq<__c_anonymous_sockaddr_can_j1939> for __c_anonymous_sockaddr_can_j1939

impl PartialEq<protoent> for protoent

impl PartialEq<mallinfo> for mallinfo

impl PartialEq<rusage> for rusage

impl PartialEq<sigval> for sigval

impl PartialEq<msqid_ds> for msqid_ds

impl PartialEq<in_pktinfo> for in_pktinfo

impl PartialEq<sigevent> for sigevent

impl PartialEq<ff_condition_effect> for ff_condition_effect

impl PartialEq<dl_phdr_info> for dl_phdr_info

impl PartialEq<input_mask> for input_mask

impl PartialEq<utsname> for utsname

impl PartialEq<ipv6_mreq> for ipv6_mreq

impl PartialEq<in6_rtmsg> for in6_rtmsg

impl PartialEq<ff_trigger> for ff_trigger

impl PartialEq<nlattr> for nlattr

impl PartialEq<timex> for timex

impl PartialEq<mq_attr> for mq_attr

impl PartialEq<ff_ramp_effect> for ff_ramp_effect

impl PartialEq<arphdr> for arphdr

impl PartialEq<glob64_t> for glob64_t

impl PartialEq<input_absinfo> for input_absinfo

impl PartialEq<servent> for servent

impl PartialEq<ff_constant_effect> for ff_constant_effect

impl PartialEq<sockaddr_vm> for sockaddr_vm

impl PartialEq<nlmsghdr> for nlmsghdr

impl PartialEq<in6_addr> for in6_addr

impl PartialEq<arpreq> for arpreq

impl PartialEq<inotify_event> for inotify_event

impl PartialEq<ucred> for ucred

impl PartialEq<pthread_condattr_t> for pthread_condattr_t

impl PartialEq<mcontext_t> for mcontext_t

impl PartialEq<user_fpregs_struct> for user_fpregs_struct

impl PartialEq<nl_mmap_req> for nl_mmap_req

impl PartialEq<statx_timestamp> for statx_timestamp

impl PartialEq<Elf32_Shdr> for Elf32_Shdr

impl PartialEq<passwd> for passwd

impl PartialEq<hostent> for hostent

impl PartialEq<arpreq_old> for arpreq_old

impl PartialEq<rlimit64> for rlimit64

impl PartialEq<can_filter> for can_filter

impl PartialEq<arpd_request> for arpd_request

impl PartialEq<addrinfo> for addrinfo

impl PartialEq<fanotify_response> for fanotify_response

impl PartialEq<sockaddr_alg> for sockaddr_alg

impl PartialEq<user> for user

impl PartialEq<ip_mreq> for ip_mreq

impl PartialEq<input_id> for input_id

impl PartialEq<pthread_mutexattr_t> for pthread_mutexattr_t

impl PartialEq<sockaddr_in6> for sockaddr_in6

impl PartialEq<sockaddr_in> for sockaddr_in

impl PartialEq<pthread_attr_t> for pthread_attr_t

impl PartialEq<ip_mreq_source> for ip_mreq_source

impl PartialEq<mmsghdr> for mmsghdr

impl PartialEq<sockaddr_storage> for sockaddr_storage

impl PartialEq<fanotify_event_metadata> for fanotify_event_metadata

impl PartialEq<BigEndian> for BigEndian

impl PartialEq<LittleEndian> for LittleEndian

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

impl PartialEq<Style> for Style

impl PartialEq<Colour> for Colour

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

impl PartialEq<Value> for bool[src]

impl PartialEq<Value> for f64[src]

impl PartialEq<Number> for Number[src]

impl<'a> PartialEq<bool> for &'a Value[src]

impl PartialEq<Map<String, Value>> for Map<String, Value>[src]

impl<'a> PartialEq<i64> for &'a Value[src]

impl PartialEq<Value> for usize[src]

impl PartialEq<Value> for i8[src]

impl PartialEq<i32> for Value[src]

impl PartialEq<Value> for f32[src]

impl<'a> PartialEq<i8> for &'a mut Value[src]

impl<'a> PartialEq<i16> for &'a mut Value[src]

impl PartialEq<i8> for Value[src]

impl PartialEq<u32> for Value[src]

impl PartialEq<u8> for Value[src]

impl PartialEq<usize> for Value[src]

impl PartialEq<i16> for Value[src]

impl<'a> PartialEq<i32> for &'a Value[src]

impl PartialEq<Value> for isize[src]

impl<'a> PartialEq<f32> for &'a mut Value[src]

impl PartialEq<u64> for Value[src]

impl PartialEq<Value> for i16[src]

impl PartialEq<Value> for u32[src]

impl<'a> PartialEq<u16> for &'a Value[src]

impl<'a> PartialEq<u16> for &'a mut Value[src]

impl<'a> PartialEq<u64> for &'a mut Value[src]

impl<'a> PartialEq<u32> for &'a Value[src]

impl PartialEq<Value> for Value[src]

impl<'a> PartialEq<Value> for &'a str[src]

impl PartialEq<Value> for i64[src]

impl PartialEq<bool> for Value[src]

impl<'a> PartialEq<i8> for &'a Value[src]

impl PartialEq<f64> for Value[src]

impl<'a> PartialEq<isize> for &'a mut Value[src]

impl PartialEq<i64> for Value[src]

impl<'a> PartialEq<u8> for &'a Value[src]

impl<'a> PartialEq<u8> for &'a mut Value[src]

impl PartialEq<Value> for i32[src]

impl<'a> PartialEq<i16> for &'a Value[src]

impl PartialEq<Category> for Category[src]

impl<'a> PartialEq<f64> for &'a mut Value[src]

impl<'a> PartialEq<u64> for &'a Value[src]

impl<'a> PartialEq<usize> for &'a mut Value[src]

impl<'a> PartialEq<&'a str> for Value[src]

impl<'a> PartialEq<i64> for &'a mut Value[src]

impl PartialEq<Value> for String[src]

impl PartialEq<Value> for u16[src]

impl<'a> PartialEq<isize> for &'a Value[src]

impl<'a> PartialEq<i32> for &'a mut Value[src]

impl PartialEq<str> for Value[src]

impl<'a> PartialEq<usize> for &'a Value[src]

impl<'a> PartialEq<f32> for &'a Value[src]

impl PartialEq<Value> for u64[src]

impl PartialEq<Value> for str[src]

impl PartialEq<u16> for Value[src]

impl PartialEq<String> for Value[src]

impl<'a> PartialEq<u32> for &'a mut Value[src]

impl PartialEq<isize> for Value[src]

impl<'a> PartialEq<f64> for &'a Value[src]

impl PartialEq<f32> for Value[src]

impl<'a> PartialEq<bool> for &'a mut Value[src]

impl PartialEq<Value> for u8[src]

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

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

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

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

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

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

impl PartialEq<IsoWeek> for IsoWeek[src]

impl PartialEq<InternalNumeric> for InternalNumeric[src]

impl