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

• symmetric: a == b implies b == a; and
• transitive: a == b and b == c implies a == c.

Note that these requirements mean that the trait itself must be implemented symmetrically and transitively: if T: PartialEq<U> and U: PartialEq<V> then U: PartialEq<T> and T: PartialEq<V>.

Derivable

This trait can be used with #[derive]. When 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

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

This method tests for !=.

Loading content...

Implementations on Foreign Types

impl PartialEq<Output> for Output

pub fn eq(&self, other: &Output) -> bool

pub fn ne(&self, other: &Output) -> bool

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

pub fn eq(&self, other: &&'a Path) -> bool

impl PartialEq<IntoStringError> for IntoStringError

pub fn eq(&self, other: &IntoStringError) -> bool

pub fn ne(&self, other: &IntoStringError) -> bool

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

pub fn eq(&self, other: &Cow<'a, Path>) -> bool

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

pub fn eq(&self, other: &Cursor<T>) -> bool

pub fn ne(&self, other: &Cursor<T>) -> bool

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

pub fn eq(&self, other: &&'a Path) -> bool

impl PartialEq<ThreadId> for ThreadId

pub fn eq(&self, other: &ThreadId) -> bool

pub fn ne(&self, other: &ThreadId) -> bool

impl PartialEq<VarError> for VarError

pub fn eq(&self, other: &VarError) -> bool

pub fn ne(&self, other: &VarError) -> bool

impl PartialEq<Permissions> for Permissions

pub fn eq(&self, other: &Permissions) -> bool

pub fn ne(&self, other: &Permissions) -> bool

impl PartialEq<Ipv4Addr> for IpAddr

pub fn eq(&self, other: &Ipv4Addr) -> bool

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

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

impl<'a, 'b> PartialEq<Path> for Cow<'a, Path>

pub fn eq(&self, other: &Path) -> bool

impl PartialEq<ExitStatus> for ExitStatus

pub fn eq(&self, other: &ExitStatus) -> bool

pub fn ne(&self, other: &ExitStatus) -> bool

impl PartialEq<IpAddr> for Ipv4Addr

pub fn eq(&self, other: &IpAddr) -> bool

impl PartialEq<BacktraceStatus> for BacktraceStatus

pub fn eq(&self, other: &BacktraceStatus) -> bool

impl PartialEq<PathBuf> for PathBuf

pub fn eq(&self, other: &PathBuf) -> bool

impl PartialEq<AddrParseError> for AddrParseError

pub fn eq(&self, other: &AddrParseError) -> bool

pub fn ne(&self, other: &AddrParseError) -> bool

impl PartialEq<RecvError> for RecvError

pub fn eq(&self, other: &RecvError) -> bool

impl PartialEq<Instant> for Instant

pub fn eq(&self, other: &Instant) -> bool

pub fn ne(&self, other: &Instant) -> bool

impl PartialEq<WaitTimeoutResult> for WaitTimeoutResult

pub fn eq(&self, other: &WaitTimeoutResult) -> bool

pub fn ne(&self, other: &WaitTimeoutResult) -> bool

impl<'a, 'b> PartialEq<OsString> for Path

pub fn eq(&self, other: &OsString) -> bool

impl PartialEq<OsStr> for OsStr

pub fn eq(&self, other: &OsStr) -> bool

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

pub fn eq(&self, other: &PathBuf) -> bool

impl PartialEq<FromVecWithNulError> for FromVecWithNulError

pub fn eq(&self, other: &FromVecWithNulError) -> bool

pub fn ne(&self, other: &FromVecWithNulError) -> bool

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

pub fn eq(&self, other: &PathBuf) -> bool

impl PartialEq<OsString> for OsString

pub fn eq(&self, other: &OsString) -> bool

impl<'a, 'b> PartialEq<Path> for PathBuf

pub fn eq(&self, other: &Path) -> bool

impl<'a, 'b> PartialEq<Cow<'a, Path>> for Path

pub fn eq(&self, other: &Cow<'a, Path>) -> bool

impl<'a, 'b> PartialEq<Cow<'a, OsStr>> for OsStr

pub fn eq(&self, other: &Cow<'a, OsStr>) -> bool

impl PartialEq<str> for OsStr

pub fn eq(&self, other: &str) -> bool

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

pub fn eq(&self, other: &SyncOnceCell<T>) -> bool

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

pub fn eq(&self, other: &&'a Path) -> bool

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

pub fn eq(&self, other: &PathBuf) -> bool

impl PartialEq<ErrorKind> for ErrorKind

pub fn eq(&self, other: &ErrorKind) -> bool

impl<'a, 'b> PartialEq<Path> for OsString

pub fn eq(&self, other: &Path) -> bool

impl PartialEq<Path> for Path

pub fn eq(&self, other: &Path) -> bool

impl PartialEq<Ipv4Addr> for Ipv4Addr

pub fn eq(&self, other: &Ipv4Addr) -> bool

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

pub fn eq(&self, other: &PathBuf) -> bool

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

pub fn eq(&self, other: &&'b OsStr) -> bool

impl<'a, 'b> PartialEq<OsStr> for OsString

pub fn eq(&self, other: &OsStr) -> bool

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

pub fn eq(&self, other: &&'b Path) -> bool

impl<'a, 'b> PartialEq<OsString> for OsStr

pub fn eq(&self, other: &OsString) -> bool

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

pub fn eq(&self, other: &OsString) -> bool

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

pub fn eq(&self, other: &Path) -> bool

impl<'a> PartialEq<Prefix<'a>> for Prefix<'a>

pub fn eq(&self, other: &Prefix<'a>) -> bool

pub fn ne(&self, other: &Prefix<'a>) -> bool

impl PartialEq<NulError> for NulError

pub fn eq(&self, other: &NulError) -> bool

pub fn ne(&self, other: &NulError) -> bool

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

pub fn eq(&self, other: &OsString) -> bool

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

pub fn eq(&self, other: &OsString) -> bool

impl PartialEq<TryRecvError> for TryRecvError

pub fn eq(&self, other: &TryRecvError) -> bool

impl PartialEq<FromBytesWithNulError> for FromBytesWithNulError

pub fn eq(&self, other: &FromBytesWithNulError) -> bool

pub fn ne(&self, other: &FromBytesWithNulError) -> bool

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

pub fn eq(&self, other: &Cow<'a, Path>) -> bool

impl<'a> PartialEq<Component<'a>> for Component<'a>

pub fn eq(&self, other: &Component<'a>) -> bool

pub fn ne(&self, other: &Component<'a>) -> bool

impl PartialEq<IpAddr> for IpAddr

pub fn eq(&self, other: &IpAddr) -> bool

pub fn ne(&self, other: &IpAddr) -> bool

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

pub fn eq(&self, other: &Cow<'a, Path>) -> bool

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

pub fn eq(&self, other: &Cow<'a, OsStr>) -> bool

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

pub fn eq(&self, other: &Cow<'a, OsStr>) -> bool

impl PartialEq<SystemTime> for SystemTime

pub fn eq(&self, other: &SystemTime) -> bool

pub fn ne(&self, other: &SystemTime) -> bool

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

pub fn eq(&self, other: &TrySendError<T>) -> bool

pub fn ne(&self, other: &TrySendError<T>) -> bool

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

pub fn eq(&self, other: &OsStr) -> bool

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

pub fn eq(&self, other: &Path) -> bool

impl PartialEq<Shutdown> for Shutdown

pub fn eq(&self, other: &Shutdown) -> bool

impl PartialEq<OsStr> for str

pub fn eq(&self, other: &OsStr) -> bool

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

pub fn eq(&self, other: &OsStr) -> bool

impl PartialEq<UCred> for UCred

pub fn eq(&self, other: &UCred) -> bool

pub fn ne(&self, other: &UCred) -> bool

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

pub fn eq(&self, other: &Cow<'a, Path>) -> bool

impl PartialEq<RecvTimeoutError> for RecvTimeoutError

pub fn eq(&self, other: &RecvTimeoutError) -> bool

impl PartialEq<SocketAddrV6> for SocketAddrV6

pub fn eq(&self, other: &SocketAddrV6) -> bool

impl<'a, 'b> PartialEq<OsStr> for PathBuf

pub fn eq(&self, other: &OsStr) -> bool

impl PartialEq<Ipv6Addr> for IpAddr

pub fn eq(&self, other: &Ipv6Addr) -> bool

impl<'a> PartialEq<Components<'a>> for Components<'a>

pub fn eq(&self, other: &Components<'a>) -> bool

impl<'a, 'b> PartialEq<PathBuf> for OsStr

pub fn eq(&self, other: &PathBuf) -> bool

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

pub fn eq(&self, other: &Cow<'a, Path>) -> bool

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

pub fn eq(&self, other: &Cow<'a, OsStr>) -> bool

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

pub fn eq(&self, other: &&'a OsStr) -> bool

impl PartialEq<Ipv6MulticastScope> for Ipv6MulticastScope

pub fn eq(&self, other: &Ipv6MulticastScope) -> bool

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

pub fn eq(&self, other: &OsString) -> bool

impl<'a> PartialEq<PrefixComponent<'a>> for PrefixComponent<'a>

pub fn eq(&self, other: &PrefixComponent<'a>) -> bool

impl<'a, 'b> PartialEq<OsStr> for Cow<'a, OsStr>

pub fn eq(&self, other: &OsStr) -> bool

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

pub fn eq(&self, other: &Cow<'b, OsStr>) -> bool

impl PartialEq<CStr> for CStr

pub fn eq(&self, other: &CStr) -> bool

impl<'a, 'b> PartialEq<OsString> for PathBuf

pub fn eq(&self, other: &OsString) -> bool

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

pub fn eq(&self, other: &&'b OsStr) -> bool

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

pub fn eq(&self, other: &SendError<T>) -> bool

pub fn ne(&self, other: &SendError<T>) -> bool

impl PartialEq<str> for OsString

pub fn eq(&self, other: &str) -> bool

impl<'a, 'b> PartialEq<PathBuf> for Path

pub fn eq(&self, other: &PathBuf) -> bool

impl<'a, 'b> PartialEq<OsStr> for Path

pub fn eq(&self, other: &OsStr) -> bool

impl PartialEq<SocketAddrV4> for SocketAddrV4

pub fn eq(&self, other: &SocketAddrV4) -> bool

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

pub fn eq(&self, other: &Cow<'a, OsStr>) -> bool

impl PartialEq<CString> for CString

pub fn eq(&self, other: &CString) -> bool

pub fn ne(&self, other: &CString) -> bool

impl PartialEq<AccessError> for AccessError

pub fn eq(&self, other: &AccessError) -> bool

pub fn ne(&self, other: &AccessError) -> bool

impl PartialEq<SeekFrom> for SeekFrom

pub fn eq(&self, other: &SeekFrom) -> bool

pub fn ne(&self, other: &SeekFrom) -> bool

impl PartialEq<FileType> for FileType

pub fn eq(&self, other: &FileType) -> bool

pub fn ne(&self, other: &FileType) -> bool

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

pub fn eq(&self, other: &&'a OsStr) -> bool

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

pub fn eq(&self, other: &&'a OsStr) -> bool

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

pub fn eq(&self, other: &OsString) -> bool

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

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

impl PartialEq<SocketAddr> for SocketAddr

pub fn eq(&self, other: &SocketAddr) -> bool

pub fn ne(&self, other: &SocketAddr) -> bool

impl PartialEq<StripPrefixError> for StripPrefixError

pub fn eq(&self, other: &StripPrefixError) -> bool

pub fn ne(&self, other: &StripPrefixError) -> bool

impl<'a, 'b> PartialEq<Path> for OsStr

pub fn eq(&self, other: &Path) -> bool

impl<'_> PartialEq<&'_ str> for OsString

pub fn eq(&self, other: &&str) -> bool

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

pub fn eq(&self, other: &&'a Path) -> bool

impl<'a, 'b> PartialEq<PathBuf> for OsString

pub fn eq(&self, other: &PathBuf) -> bool

impl PartialEq<OsString> for str

pub fn eq(&self, other: &OsString) -> bool

impl PartialEq<IpAddr> for Ipv6Addr

pub fn eq(&self, other: &IpAddr) -> bool

impl PartialEq<Ipv6Addr> for Ipv6Addr

pub fn eq(&self, other: &Ipv6Addr) -> bool

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

pub fn eq(&self, other: &unsafe extern "C" fn(A, B, C, D, E, F) -> Ret) -> bool

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

pub fn eq(&self, other: &fn(A, B, C, D, E, F, G, H) -> Ret) -> bool

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

pub fn eq(&self, other: &extern "C" fn(A, B, C, D, ...) -> Ret) -> bool

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

pub fn eq(&self, other: &extern "C" fn(A, B, C, D, E) -> Ret) -> bool

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

pub fn eq(&self, other: &extern "C" fn(A, B, C, D) -> Ret) -> bool

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

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

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

pub fn eq(&self, other: &Poll<T>) -> bool

pub fn ne(&self, other: &Poll<T>) -> bool

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

pub fn eq(&self, other: &Location<'a>) -> bool

pub fn ne(&self, other: &Location<'a>) -> bool

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

pub fn eq(&self, other: &&[B]) -> bool

pub fn ne(&self, other: &&[B]) -> bool

impl PartialEq<NonZeroU64> for NonZeroU64

pub fn eq(&self, other: &NonZeroU64) -> bool

pub fn ne(&self, other: &NonZeroU64) -> bool

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

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

impl<Idx> PartialEq<Range<Idx>> for Range<Idx> where
    Idx: PartialEq<Idx>, 

pub fn eq(&self, other: &Range<Idx>) -> bool

pub fn ne(&self, other: &Range<Idx>) -> bool

impl PartialEq<isize> for isize

pub fn eq(&self, other: &isize) -> bool

pub fn ne(&self, other: &isize) -> bool

impl PartialEq<CharTryFromError> for CharTryFromError

pub fn eq(&self, other: &CharTryFromError) -> bool

pub fn ne(&self, other: &CharTryFromError) -> bool

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

pub fn eq(&self, other: &(A, B, C, D, E, F, G, H, I, J, K)) -> bool

pub fn ne(&self, other: &(A, B, C, D, E, F, G, H, I, J, K)) -> bool

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

pub fn eq(&self, other: &unsafe fn(A, B, C, D, E) -> Ret) -> bool

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

pub fn eq(&self, other: &extern "C" fn(A, B, C) -> Ret) -> bool

impl PartialEq<u128> for u128

pub fn eq(&self, other: &u128) -> bool

pub fn ne(&self, other: &u128) -> bool

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

pub fn eq(&self, other: &extern "C" fn(A, B, ...) -> Ret) -> bool

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

pub fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F, G, H) -> Ret) -> bool

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

pub fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret) -> bool

impl PartialEq<NonZeroU32> for NonZeroU32

pub fn eq(&self, other: &NonZeroU32) -> bool

pub fn ne(&self, other: &NonZeroU32) -> bool

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

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

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

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

impl PartialEq<NonZeroU128> for NonZeroU128

pub fn eq(&self, other: &NonZeroU128) -> bool

pub fn ne(&self, other: &NonZeroU128) -> bool

impl PartialEq<ParseBoolError> for ParseBoolError

pub fn eq(&self, other: &ParseBoolError) -> bool

pub fn ne(&self, other: &ParseBoolError) -> bool

impl PartialEq<TypeId> for TypeId

pub fn eq(&self, other: &TypeId) -> bool

pub fn ne(&self, other: &TypeId) -> bool

impl PartialEq<bool> for bool

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

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

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

pub fn eq(&self, other: &Reverse<T>) -> bool

pub fn ne(&self, other: &Reverse<T>) -> bool

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

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

impl PartialEq<Ordering> for Ordering

pub fn eq(&self, other: &Ordering) -> bool

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

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

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

impl PartialEq<DecodeUtf16Error> for DecodeUtf16Error

pub fn eq(&self, other: &DecodeUtf16Error) -> bool

pub fn ne(&self, other: &DecodeUtf16Error) -> bool

impl PartialEq<NoneError> for NoneError

pub fn eq(&self, other: &NoneError) -> bool

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

pub fn eq(&self, other: &(A, B)) -> bool

pub fn ne(&self, other: &(A, B)) -> bool

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

pub fn eq(&self, other: &unsafe extern "C" fn(A, B) -> Ret) -> bool

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

pub fn eq(&self, other: &unsafe fn(A, B, C, D, E, F, G, H) -> Ret) -> bool

impl PartialEq<Duration> for Duration

pub fn eq(&self, other: &Duration) -> bool

pub fn ne(&self, other: &Duration) -> bool

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

pub fn eq(&self, rhs: &Discriminant<T>) -> bool

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

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

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

pub fn eq(&self, other: &[B]) -> bool

pub fn ne(&self, other: &[B]) -> bool

impl<T> PartialEq<*mut T> for *mut T where
    T: ?Sized, 

pub fn eq(&self, other: &*mut T) -> bool

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

pub fn eq(&self, other: &unsafe fn(A, B, C, D, E, F) -> Ret) -> bool

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

pub fn eq(&self, other: &unsafe fn(A, B, C, D, E, F, G) -> Ret) -> bool

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

pub fn eq(&self, other: &&B) -> bool

pub fn ne(&self, other: &&B) -> bool

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

pub fn eq(&self, other: &(A, B, C, D, E, F, G, H, I)) -> bool

pub fn ne(&self, other: &(A, B, C, D, E, F, G, H, I)) -> bool

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

pub fn eq(&self, other: &unsafe extern "C" fn(A, B, ...) -> Ret) -> bool

impl PartialEq<usize> for usize

pub fn eq(&self, other: &usize) -> bool

pub fn ne(&self, other: &usize) -> bool

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

pub fn eq(&self, other: &Wrapping<T>) -> bool

pub fn ne(&self, other: &Wrapping<T>) -> bool

impl PartialEq<AllocError> for AllocError

pub fn eq(&self, other: &AllocError) -> bool

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

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

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

pub fn eq(&self, other: &&mut B) -> bool

pub fn ne(&self, other: &&mut B) -> bool

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

pub fn eq(&self, other: &(A,)) -> bool

pub fn ne(&self, other: &(A,)) -> bool

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

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

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

pub fn eq(&self, other: &(A, B, C, D, E, F, G, H)) -> bool

pub fn ne(&self, other: &(A, B, C, D, E, F, G, H)) -> bool

impl PartialEq<FpCategory> for FpCategory

pub fn eq(&self, other: &FpCategory) -> bool

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

pub fn eq(&self, other: &extern "C" fn() -> Ret) -> bool

impl PartialEq<Layout> for Layout

pub fn eq(&self, other: &Layout) -> bool

pub fn ne(&self, other: &Layout) -> bool

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, 

pub fn eq(&self, other: &(A, B, C, D)) -> bool

pub fn ne(&self, other: &(A, B, C, D)) -> bool

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

pub fn eq(&self, other: &fn() -> Ret) -> bool

impl PartialEq<Utf8Error> for Utf8Error

pub fn eq(&self, other: &Utf8Error) -> bool

pub fn ne(&self, other: &Utf8Error) -> bool

impl PartialEq<NonZeroI8> for NonZeroI8

pub fn eq(&self, other: &NonZeroI8) -> bool

pub fn ne(&self, other: &NonZeroI8) -> bool

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

pub fn eq(&self, other: &ControlFlow<B, C>) -> bool

pub fn ne(&self, other: &ControlFlow<B, C>) -> bool

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

pub fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F, ...) -> Ret) -> bool

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

pub fn eq(&self, other: &extern "C" fn(A, B) -> Ret) -> bool

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

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

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

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

impl<Idx> PartialEq<RangeFrom<Idx>> for RangeFrom<Idx> where
    Idx: PartialEq<Idx>, 

pub fn eq(&self, other: &RangeFrom<Idx>) -> bool

pub fn ne(&self, other: &RangeFrom<Idx>) -> bool

impl PartialEq<f64> for f64

pub fn eq(&self, other: &f64) -> bool

pub fn ne(&self, other: &f64) -> bool

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

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

impl PartialEq<Ordering> for Ordering

pub fn eq(&self, other: &Ordering) -> bool

impl PartialEq<u8> for u8

pub fn eq(&self, other: &u8) -> bool

pub fn ne(&self, other: &u8) -> bool

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

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

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

pub fn eq(&self, other: &extern "C" fn(A, ...) -> Ret) -> bool

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

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

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

pub fn eq(&self, other: &[B]) -> bool

pub fn ne(&self, other: &[B]) -> bool

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

pub fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F) -> Ret) -> bool

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

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

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

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

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

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

pub fn eq(&self, other: &(A, B, C)) -> bool

pub fn ne(&self, other: &(A, B, C)) -> bool

impl PartialEq<ParseCharError> for ParseCharError

pub fn eq(&self, other: &ParseCharError) -> bool

pub fn ne(&self, other: &ParseCharError) -> bool

impl PartialEq<i32> for i32

pub fn eq(&self, other: &i32) -> bool

pub fn ne(&self, other: &i32) -> bool

impl PartialEq<NonZeroU8> for NonZeroU8

pub fn eq(&self, other: &NonZeroU8) -> bool

pub fn ne(&self, other: &NonZeroU8) -> bool

impl PartialEq<NonZeroIsize> for NonZeroIsize

pub fn eq(&self, other: &NonZeroIsize) -> bool

pub fn ne(&self, other: &NonZeroIsize) -> bool

impl PartialEq<()> for ()

pub fn eq(&self, _other: &()) -> bool

pub fn ne(&self, _other: &()) -> bool

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

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

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

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

impl<T> PartialEq<Cell<T>> for Cell<T> where
    T: PartialEq<T> + Copy, 

pub fn eq(&self, other: &Cell<T>) -> bool

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

pub fn eq(&self, other: &unsafe extern "C" fn(A, B, C) -> Ret) -> bool

impl PartialEq<NonZeroU16> for NonZeroU16

pub fn eq(&self, other: &NonZeroU16) -> bool

pub fn ne(&self, other: &NonZeroU16) -> bool

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

pub fn eq(&self, other: &unsafe extern "C" fn() -> Ret) -> bool

impl PartialEq<str> for str

pub fn eq(&self, other: &str) -> bool

pub fn ne(&self, other: &str) -> bool

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

pub fn eq(&self, other: &unsafe extern "C" fn(A, B, C, D, E) -> Ret) -> bool

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

pub fn eq(&self, other: &extern "C" fn(A, B, C, ...) -> Ret) -> bool

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

pub fn eq(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret
) -> bool

impl PartialEq<RangeFull> for RangeFull

pub fn eq(&self, other: &RangeFull) -> bool

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

pub fn eq(&self, other: &unsafe extern "C" fn(A, B, C, ...) -> Ret) -> bool

impl<T> PartialEq<RefCell<T>> for RefCell<T> where
    T: PartialEq<T> + ?Sized, 

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

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

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

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

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

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

impl PartialEq<RawWaker> for RawWaker

pub fn eq(&self, other: &RawWaker) -> bool

pub fn ne(&self, other: &RawWaker) -> bool

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

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

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

impl PartialEq<ParseFloatError> for ParseFloatError

pub fn eq(&self, other: &ParseFloatError) -> bool

pub fn ne(&self, other: &ParseFloatError) -> bool

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

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

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

pub fn eq(&self, other: &unsafe fn(A, B, C, D) -> Ret) -> bool

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

pub fn eq(&self, other: &unsafe fn(A, B, C) -> Ret) -> bool

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

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

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

pub fn eq(&self, other: &fn(A, B, C, D, E, F, G, H, I, J) -> Ret) -> bool

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

pub fn eq(&self, other: &extern "C" fn(A, B, C, D, E, ...) -> Ret) -> bool

impl<T> PartialEq<NonNull<T>> for NonNull<T> where
    T: ?Sized, 

pub fn eq(&self, other: &NonNull<T>) -> bool

impl PartialEq<NonZeroI32> for NonZeroI32

pub fn eq(&self, other: &NonZeroI32) -> bool

pub fn ne(&self, other: &NonZeroI32) -> bool

impl PartialEq<NonZeroUsize> for NonZeroUsize

pub fn eq(&self, other: &NonZeroUsize) -> bool

pub fn ne(&self, other: &NonZeroUsize) -> bool

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

pub fn eq(&self, other: &GeneratorState<Y, R>) -> bool

pub fn ne(&self, other: &GeneratorState<Y, R>) -> bool

impl PartialEq<IntErrorKind> for IntErrorKind

pub fn eq(&self, other: &IntErrorKind) -> bool

impl PartialEq<f32> for f32

pub fn eq(&self, other: &f32) -> bool

pub fn ne(&self, other: &f32) -> bool

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

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

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

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

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

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

pub fn eq(&self, other: &(A, B, C, D, E)) -> bool

pub fn ne(&self, other: &(A, B, C, D, E)) -> bool

impl PartialEq<CpuidResult> for CpuidResult

pub fn eq(&self, other: &CpuidResult) -> bool

pub fn ne(&self, other: &CpuidResult) -> bool

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

pub fn eq(&self, other: &fn(A, B, C, D, E) -> Ret) -> bool

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

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

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

pub fn eq(&self, other: &unsafe fn(A, B) -> Ret) -> bool

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

pub fn eq(&self, other: &&mut B) -> bool

pub fn ne(&self, other: &&mut B) -> bool

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

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

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

pub fn eq(&self, other: &fn(A, B, C, D, E, F, G, H, I) -> Ret) -> bool

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

pub fn eq(&self, other: &unsafe extern "C" fn(A, B, C, D) -> Ret) -> bool

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

pub fn eq(&self, other: &Bound<T>) -> bool

pub fn ne(&self, other: &Bound<T>) -> bool

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

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

impl<T> PartialEq<*const T> for *const T where
    T: ?Sized, 

pub fn eq(&self, other: &*const T) -> bool

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

pub fn eq(&self, other: &Utf8LossyChunk<'a>) -> bool

pub fn ne(&self, other: &Utf8LossyChunk<'a>) -> bool

impl<Idx> PartialEq<RangeInclusive<Idx>> for RangeInclusive<Idx> where
    Idx: PartialEq<Idx>, 

pub fn eq(&self, other: &RangeInclusive<Idx>) -> bool

pub fn ne(&self, other: &RangeInclusive<Idx>) -> bool

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

pub fn eq(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret
) -> bool

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

pub fn eq(&self, other: &unsafe extern "C" fn(A) -> Ret) -> bool

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

pub fn eq(&self, other: &fn(A, B) -> Ret) -> bool

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

pub fn eq(&self, other: &unsafe extern "C" fn(A, ...) -> Ret) -> bool

impl PartialEq<NonZeroI128> for NonZeroI128

pub fn eq(&self, other: &NonZeroI128) -> bool

pub fn ne(&self, other: &NonZeroI128) -> bool

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

pub fn eq(&self, _other: &BuildHasherDefault<H>) -> bool

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

pub fn eq(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret
) -> bool

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

pub fn eq(&self, other: &fn(A, B, C, D) -> Ret) -> bool

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

pub fn eq(&self, other: &OnceCell<T>) -> bool

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

pub fn eq(&self, other: &Pin<Q>) -> bool

pub fn ne(&self, other: &Pin<Q>) -> bool

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

pub fn eq(&self, other: &fn(A) -> Ret) -> bool

impl PartialEq<char> for char

pub fn eq(&self, other: &char) -> bool

pub fn ne(&self, other: &char) -> bool

impl<Idx> PartialEq<RangeToInclusive<Idx>> for RangeToInclusive<Idx> where
    Idx: PartialEq<Idx>, 

pub fn eq(&self, other: &RangeToInclusive<Idx>) -> bool

pub fn ne(&self, other: &RangeToInclusive<Idx>) -> bool

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

pub fn eq(&self, other: &unsafe fn(A) -> Ret) -> bool

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

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

impl PartialEq<RawWakerVTable> for RawWakerVTable

pub fn eq(&self, other: &RawWakerVTable) -> bool

pub fn ne(&self, other: &RawWakerVTable) -> bool

impl PartialEq<ParseIntError> for ParseIntError

pub fn eq(&self, other: &ParseIntError) -> bool

pub fn ne(&self, other: &ParseIntError) -> bool

impl<Idx> PartialEq<RangeTo<Idx>> for RangeTo<Idx> where
    Idx: PartialEq<Idx>, 

pub fn eq(&self, other: &RangeTo<Idx>) -> bool

pub fn ne(&self, other: &RangeTo<Idx>) -> bool

impl PartialEq<Infallible> for Infallible

pub fn eq(&self, &Infallible) -> bool

impl PartialEq<NonZeroI16> for NonZeroI16

pub fn eq(&self, other: &NonZeroI16) -> bool

pub fn ne(&self, other: &NonZeroI16) -> bool

impl<T> PartialEq<ManuallyDrop<T>> for ManuallyDrop<T> where
    T: PartialEq<T> + ?Sized, 

pub fn eq(&self, other: &ManuallyDrop<T>) -> bool

pub fn ne(&self, other: &ManuallyDrop<T>) -> bool

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

pub fn eq(&self, other: &(A, B, C, D, E, F)) -> bool

pub fn ne(&self, other: &(A, B, C, D, E, F)) -> bool

impl PartialEq<u64> for u64

pub fn eq(&self, other: &u64) -> bool

pub fn ne(&self, other: &u64) -> bool

impl PartialEq<u32> for u32

pub fn eq(&self, other: &u32) -> bool

pub fn ne(&self, other: &u32) -> bool

impl PartialEq<!> for !

pub fn eq(&self, &!) -> bool

impl PartialEq<i16> for i16

pub fn eq(&self, other: &i16) -> bool

pub fn ne(&self, other: &i16) -> bool

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

pub fn eq(&self, other: &Option<T>) -> bool

pub fn ne(&self, other: &Option<T>) -> bool

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, 

pub fn eq(&self, other: &(A, B, C, D, E, F, G, H, I, J)) -> bool

pub fn ne(&self, other: &(A, B, C, D, E, F, G, H, I, J)) -> bool

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

pub fn eq(&self, other: &(A, B, C, D, E, F, G)) -> bool

pub fn ne(&self, other: &(A, B, C, D, E, F, G)) -> bool

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

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

impl PartialEq<SearchStep> for SearchStep

pub fn eq(&self, other: &SearchStep) -> bool

pub fn ne(&self, other: &SearchStep) -> bool

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

pub fn eq(&self, other: &fn(A, B, C, D, E, F) -> Ret) -> bool

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

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

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

impl PartialEq<NonZeroI64> for NonZeroI64

pub fn eq(&self, other: &NonZeroI64) -> bool

pub fn ne(&self, other: &NonZeroI64) -> bool

impl PartialEq<LayoutError> for LayoutError

pub fn eq(&self, other: &LayoutError) -> bool

pub fn ne(&self, other: &LayoutError) -> bool

impl PartialEq<i64> for i64

pub fn eq(&self, other: &i64) -> bool

pub fn ne(&self, other: &i64) -> bool

impl PartialEq<i8> for i8

pub fn eq(&self, other: &i8) -> bool

pub fn ne(&self, other: &i8) -> bool

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

pub fn eq(&self, other: &fn(A, B, C, D, E, F, G) -> Ret) -> bool

impl PartialEq<i128> for i128

pub fn eq(&self, other: &i128) -> bool

pub fn ne(&self, other: &i128) -> bool

impl PartialEq<TryFromIntError> for TryFromIntError

pub fn eq(&self, other: &TryFromIntError) -> bool

pub fn ne(&self, other: &TryFromIntError) -> bool

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

pub fn eq(&self, other: &fn(A, B, C) -> Ret) -> bool

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

pub fn eq(&self, other: &unsafe extern "C" fn(A, B, C, D, ...) -> Ret) -> bool

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

pub fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F, G) -> Ret) -> bool

impl PartialEq<u16> for u16

pub fn eq(&self, other: &u16) -> bool

pub fn ne(&self, other: &u16) -> bool

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

pub fn eq(&self, other: &unsafe fn() -> Ret) -> bool

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

pub fn eq(&self, other: &extern "C" fn(A) -> Ret) -> bool

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

pub fn eq(&self, other: &unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret) -> bool

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

pub fn eq(&self, other: &&B) -> bool

pub fn ne(&self, other: &&B) -> bool

impl<'a, 'b> PartialEq<str> for String

pub fn eq(&self, other: &str) -> bool

pub fn ne(&self, other: &str) -> bool

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

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

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

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

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

pub fn eq(&self, other: &Box<T, A>) -> bool

pub fn ne(&self, other: &Box<T, A>) -> bool

impl<'a, 'b> PartialEq<String> for str

pub fn eq(&self, other: &String) -> bool

pub fn ne(&self, other: &String) -> bool

impl PartialEq<FromUtf8Error> for FromUtf8Error

pub fn eq(&self, other: &FromUtf8Error) -> bool

pub fn ne(&self, other: &FromUtf8Error) -> bool

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

pub fn eq(&self, other: &LinkedList<T>) -> bool

pub fn ne(&self, other: &LinkedList<T>) -> bool

impl<T> PartialEq<Rc<T>> for Rc<T> where
    T: PartialEq<T> + ?Sized, 

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

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

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

pub fn eq(&self, other: &BTreeMap<K, V>) -> bool

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

pub fn eq(&self, other: &BTreeSet<T>) -> bool

pub fn ne(&self, other: &BTreeSet<T>) -> bool

impl<'a, 'b> PartialEq<Cow<'a, str>> for str

pub fn eq(&self, other: &Cow<'a, str>) -> bool

pub fn ne(&self, other: &Cow<'a, str>) -> bool

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

pub fn eq(&self, other: &&'a str) -> bool

pub fn ne(&self, other: &&'a str) -> bool

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

pub fn eq(&self, other: &&[U]) -> bool

pub fn ne(&self, other: &&[U]) -> bool

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

pub fn eq(&self, other: &&mut [U]) -> bool

pub fn ne(&self, other: &&mut [U]) -> bool

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

pub fn eq(&self, other: &String) -> bool

pub fn ne(&self, other: &String) -> bool

impl<'a, 'b> PartialEq<str> for Cow<'a, str>

pub fn eq(&self, other: &str) -> bool

pub fn ne(&self, other: &str) -> bool

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

pub fn eq(&self, other: &String) -> bool

pub fn ne(&self, other: &String) -> bool

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

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

impl<A> PartialEq<VecDeque<A>> for VecDeque<A> where
    A: PartialEq<A>, 

pub fn eq(&self, other: &VecDeque<A>) -> bool

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

pub fn eq(&self, other: &Vec<U, A>) -> bool

pub fn ne(&self, other: &Vec<U, A>) -> bool

impl PartialEq<String> for String

pub fn eq(&self, other: &String) -> bool

pub fn ne(&self, other: &String) -> bool

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

pub fn eq(&self, other: &Vec<B, Global>) -> bool

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

pub fn eq(&self, other: &&[B]) -> bool

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

pub fn eq(&self, other: &Vec<U, A>) -> bool

pub fn ne(&self, other: &Vec<U, A>) -> bool

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

pub fn eq(&self, other: &Vec<U, A>) -> bool

pub fn ne(&self, other: &Vec<U, A>) -> bool

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

pub fn eq(&self, other: &&'b str) -> bool

pub fn ne(&self, other: &&'b str) -> bool

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

pub fn eq(&self, other: &Cow<'a, str>) -> bool

pub fn ne(&self, other: &Cow<'a, str>) -> bool

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

pub fn eq(&self, other: &Vec<U, A>) -> bool

pub fn ne(&self, other: &Vec<U, A>) -> bool

impl PartialEq<TryReserveError> for TryReserveError

pub fn eq(&self, other: &TryReserveError) -> bool

pub fn ne(&self, other: &TryReserveError) -> bool

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

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

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

pub fn eq(&self, other: &Cow<'b, C>) -> bool

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

pub fn eq(&self, other: &Cow<'a, str>) -> bool

pub fn ne(&self, other: &Cow<'a, str>) -> bool

impl<T> PartialEq<Arc<T>> for Arc<T> where
    T: PartialEq<T> + ?Sized, 

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

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

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

pub fn eq(&self, other: &_Unwind_Reason_Code) -> bool

impl PartialEq<_Unwind_Action> for _Unwind_Action

pub fn eq(&self, other: &_Unwind_Action) -> bool

impl PartialEq<Error> for Error

pub fn eq(&self, other: &Error) -> bool

pub fn ne(&self, other: &Error) -> bool

impl PartialEq<OptionBool> for OptionBool

pub fn eq(&self, other: &OptionBool) -> bool

pub fn ne(&self, other: &OptionBool) -> bool

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

pub fn eq(&self, other: &Compact<T>) -> bool

pub fn ne(&self, other: &Compact<T>) -> bool

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

pub fn eq(&self, rhs: &str) -> bool

impl<A> PartialEq<ArrayString<A>> for ArrayString<A> where
    A: Array<Item = u8> + Copy, 

pub fn eq(&self, rhs: &ArrayString<A>) -> bool

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

pub fn eq(&self, other: &ArrayVec<A>) -> bool

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

pub fn eq(&self, other: &CapacityError<T>) -> bool

pub fn ne(&self, other: &CapacityError<T>) -> bool

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

pub fn eq(&self, rhs: &ArrayString<A>) -> bool

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

pub fn eq(&self, other: &[<A as Array>::Item]) -> bool

impl PartialEq<Error> for Error

pub fn eq(&self, other: &Error) -> bool

pub fn ne(&self, other: &Error) -> bool

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

pub fn eq(&self, other: &Unexpected<'a>) -> bool

pub fn ne(&self, other: &Unexpected<'a>) -> bool

impl PartialEq<Error> for Error

pub fn eq(&self, other: &Error) -> bool

pub fn ne(&self, other: &Error) -> bool

impl PartialEq<Level> for LevelFilter

pub fn eq(&self, other: &Level) -> bool

impl PartialEq<Id> for Id

pub fn eq(&self, other: &Id) -> bool

pub fn ne(&self, other: &Id) -> bool

impl PartialEq<LevelFilter> for LevelFilter

pub fn eq(&self, other: &LevelFilter) -> bool

pub fn ne(&self, other: &LevelFilter) -> bool

impl PartialEq<Kind> for Kind

pub fn eq(&self, other: &Kind) -> bool

pub fn ne(&self, other: &Kind) -> bool

impl PartialEq<Level> for Level

pub fn eq(&self, other: &Level) -> bool

pub fn ne(&self, other: &Level) -> bool

impl PartialEq<LevelFilter> for Level

pub fn eq(&self, other: &LevelFilter) -> bool

impl PartialEq<Field> for Field

pub fn eq(&self, other: &Field) -> bool

impl PartialEq<Empty> for Empty

pub fn eq(&self, other: &Empty) -> bool

impl PartialEq<Identifier> for Identifier

pub fn eq(&self, other: &Identifier) -> bool

impl PartialEq<Span> for Span

pub fn eq(&self, other: &Span) -> bool

impl PartialEq<LevelFilter> for Level

pub fn eq(&self, other: &LevelFilter) -> bool

impl<'a> PartialEq<MetadataBuilder<'a>> for MetadataBuilder<'a>

pub fn eq(&self, other: &MetadataBuilder<'a>) -> bool

pub fn ne(&self, other: &MetadataBuilder<'a>) -> bool

impl PartialEq<Level> for LevelFilter

pub fn eq(&self, other: &Level) -> bool

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

pub fn eq(&self, other: &Metadata<'a>) -> bool

pub fn ne(&self, other: &Metadata<'a>) -> bool

impl PartialEq<ParseLevelError> for ParseLevelError

pub fn eq(&self, other: &ParseLevelError) -> bool

pub fn ne(&self, other: &ParseLevelError) -> bool

impl<'k, 'ko> PartialEq<Key<'ko>> for Key<'k>

pub fn eq(&self, other: &Key<'ko>) -> bool

impl PartialEq<Level> for Level

pub fn eq(&self, other: &Level) -> bool

impl PartialEq<LevelFilter> for LevelFilter

pub fn eq(&self, other: &LevelFilter) -> bool

impl PartialEq<Uptime> for Uptime

pub fn eq(&self, other: &Uptime) -> bool

pub fn ne(&self, other: &Uptime) -> bool

impl PartialEq<SystemTime> for SystemTime

pub fn eq(&self, other: &SystemTime) -> bool

impl PartialEq<Directive> for Directive

pub fn eq(&self, other: &Directive) -> bool

pub fn ne(&self, other: &Directive) -> bool

impl PartialEq<Full> for Full

pub fn eq(&self, other: &Full) -> bool

impl PartialEq<Pretty> for Pretty

pub fn eq(&self, other: &Pretty) -> bool

pub fn ne(&self, other: &Pretty) -> bool

impl PartialEq<ChronoLocal> for ChronoLocal

pub fn eq(&self, other: &ChronoLocal) -> bool

pub fn ne(&self, other: &ChronoLocal) -> bool

impl PartialEq<ChronoUtc> for ChronoUtc

pub fn eq(&self, other: &ChronoUtc) -> bool

pub fn ne(&self, other: &ChronoUtc) -> bool

impl PartialEq<FmtSpan> for FmtSpan

pub fn eq(&self, other: &FmtSpan) -> bool

pub fn ne(&self, other: &FmtSpan) -> bool

impl PartialEq<Compact> for Compact

pub fn eq(&self, other: &Compact) -> bool

impl PartialEq<Json> for Json

pub fn eq(&self, other: &Json) -> bool

pub fn ne(&self, other: &Json) -> bool

impl PartialEq<Char> for char

pub fn eq(&self, other: &Char) -> bool

impl PartialEq<Error> for Error

pub fn eq(&self, other: &Error) -> bool

pub fn ne(&self, other: &Error) -> bool

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

pub fn eq(&self, other: &Match<'t>) -> bool

pub fn ne(&self, other: &Match<'t>) -> bool

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

pub fn eq(&self, other: &Match<'t>) -> bool

pub fn ne(&self, other: &Match<'t>) -> bool

impl PartialEq<Match> for Match

pub fn eq(&self, other: &Match) -> bool

pub fn ne(&self, other: &Match) -> bool

impl PartialEq<MatchKind> for MatchKind

pub fn eq(&self, other: &MatchKind) -> bool

impl PartialEq<MatchKind> for MatchKind

pub fn eq(&self, other: &MatchKind) -> bool

impl PartialEq<WordBoundary> for WordBoundary

pub fn eq(&self, other: &WordBoundary) -> bool

impl PartialEq<ClassPerlKind> for ClassPerlKind

pub fn eq(&self, other: &ClassPerlKind) -> bool

impl PartialEq<Literal> for Literal

pub fn eq(&self, other: &Literal) -> bool

pub fn ne(&self, other: &Literal) -> bool

impl PartialEq<ClassSetBinaryOp> for ClassSetBinaryOp

pub fn eq(&self, other: &ClassSetBinaryOp) -> bool

pub fn ne(&self, other: &ClassSetBinaryOp) -> bool

impl PartialEq<Position> for Position

pub fn eq(&self, other: &Position) -> bool

pub fn ne(&self, other: &Position) -> bool

impl PartialEq<Assertion> for Assertion

pub fn eq(&self, other: &Assertion) -> bool

pub fn ne(&self, other: &Assertion) -> bool

impl PartialEq<ClassAscii> for ClassAscii

pub fn eq(&self, other: &ClassAscii) -> bool

pub fn ne(&self, other: &ClassAscii) -> bool

impl PartialEq<ClassBytes> for ClassBytes

pub fn eq(&self, other: &ClassBytes) -> bool

pub fn ne(&self, other: &ClassBytes) -> bool

impl PartialEq<ClassSetRange> for ClassSetRange

pub fn eq(&self, other: &ClassSetRange) -> bool

pub fn ne(&self, other: &ClassSetRange) -> bool

impl PartialEq<Literals> for Literals

pub fn eq(&self, other: &Literals) -> bool

pub fn ne(&self, other: &Literals) -> bool

impl PartialEq<Flag> for Flag

pub fn eq(&self, other: &Flag) -> bool

impl PartialEq<Literal> for Literal

pub fn eq(&self, other: &Literal) -> bool

pub fn ne(&self, other: &Literal) -> bool

impl PartialEq<Literal> for Literal

pub fn eq(&self, other: &Literal) -> bool

impl PartialEq<Concat> for Concat

pub fn eq(&self, other: &Concat) -> bool

pub fn ne(&self, other: &Concat) -> bool

impl PartialEq<Comment> for Comment

pub fn eq(&self, other: &Comment) -> bool

pub fn ne(&self, other: &Comment) -> bool

impl PartialEq<Flags> for Flags

pub fn eq(&self, other: &Flags) -> bool

pub fn ne(&self, other: &Flags) -> bool

impl PartialEq<ClassUnicodeRange> for ClassUnicodeRange

pub fn eq(&self, other: &ClassUnicodeRange) -> bool

pub fn ne(&self, other: &ClassUnicodeRange) -> bool

impl PartialEq<ClassUnicode> for ClassUnicode

pub fn eq(&self, other: &ClassUnicode) -> bool

pub fn ne(&self, other: &ClassUnicode) -> bool

impl PartialEq<ClassSetItem> for ClassSetItem

pub fn eq(&self, other: &ClassSetItem) -> bool

pub fn ne(&self, other: &ClassSetItem) -> bool

impl PartialEq<Anchor> for Anchor

pub fn eq(&self, other: &Anchor) -> bool

impl PartialEq<Hir> for Hir

pub fn eq(&self, other: &Hir) -> bool

pub fn ne(&self, other: &Hir) -> bool

impl PartialEq<ClassBytesRange> for ClassBytesRange

pub fn eq(&self, other: &ClassBytesRange) -> bool

pub fn ne(&self, other: &ClassBytesRange) -> bool

impl PartialEq<LiteralKind> for LiteralKind

pub fn eq(&self, other: &LiteralKind) -> bool

pub fn ne(&self, other: &LiteralKind) -> bool

impl PartialEq<Utf8Sequence> for Utf8Sequence

pub fn eq(&self, other: &Utf8Sequence) -> bool

pub fn ne(&self, other: &Utf8Sequence) -> bool

impl PartialEq<Group> for Group

pub fn eq(&self, other: &Group) -> bool

pub fn ne(&self, other: &Group) -> bool

impl PartialEq<ClassSetUnion> for ClassSetUnion

pub fn eq(&self, other: &ClassSetUnion) -> bool

pub fn ne(&self, other: &ClassSetUnion) -> bool

impl PartialEq<RepetitionOp> for RepetitionOp

pub fn eq(&self, other: &RepetitionOp) -> bool

pub fn ne(&self, other: &RepetitionOp) -> bool

impl PartialEq<RepetitionKind> for RepetitionKind

pub fn eq(&self, other: &RepetitionKind) -> bool

pub fn ne(&self, other: &RepetitionKind) -> bool

impl PartialEq<SpecialLiteralKind> for SpecialLiteralKind

pub fn eq(&self, other: &SpecialLiteralKind) -> bool

impl PartialEq<Group> for Group

pub fn eq(&self, other: &Group) -> bool

pub fn ne(&self, other: &Group) -> bool

impl PartialEq<ClassBracketed> for ClassBracketed

pub fn eq(&self, other: &ClassBracketed) -> bool

pub fn ne(&self, other: &ClassBracketed) -> bool

impl PartialEq<RepetitionRange> for RepetitionRange

pub fn eq(&self, other: &RepetitionRange) -> bool

pub fn ne(&self, other: &RepetitionRange) -> bool

impl PartialEq<Repetition> for Repetition

pub fn eq(&self, other: &Repetition) -> bool

pub fn ne(&self, other: &Repetition) -> bool

impl PartialEq<SetFlags> for SetFlags

pub fn eq(&self, other: &SetFlags) -> bool

pub fn ne(&self, other: &SetFlags) -> bool

impl PartialEq<ErrorKind> for ErrorKind

pub fn eq(&self, other: &ErrorKind) -> bool

impl PartialEq<Class> for Class

pub fn eq(&self, other: &Class) -> bool

pub fn ne(&self, other: &Class) -> bool

impl PartialEq<Alternation> for Alternation

pub fn eq(&self, other: &Alternation) -> bool

pub fn ne(&self, other: &Alternation) -> bool

impl PartialEq<Class> for Class

pub fn eq(&self, other: &Class) -> bool

pub fn ne(&self, other: &Class) -> bool

impl PartialEq<RepetitionKind> for RepetitionKind

pub fn eq(&self, other: &RepetitionKind) -> bool

pub fn ne(&self, other: &RepetitionKind) -> bool

impl PartialEq<HexLiteralKind> for HexLiteralKind

pub fn eq(&self, other: &HexLiteralKind) -> bool

impl PartialEq<HirKind> for HirKind

pub fn eq(&self, other: &HirKind) -> bool

pub fn ne(&self, other: &HirKind) -> bool

impl PartialEq<GroupKind> for GroupKind

pub fn eq(&self, other: &GroupKind) -> bool

pub fn ne(&self, other: &GroupKind) -> bool

impl PartialEq<GroupKind> for GroupKind

pub fn eq(&self, other: &GroupKind) -> bool

pub fn ne(&self, other: &GroupKind) -> bool

impl PartialEq<FlagsItem> for FlagsItem

pub fn eq(&self, other: &FlagsItem) -> bool

pub fn ne(&self, other: &FlagsItem) -> bool

impl PartialEq<ClassSetBinaryOpKind> for ClassSetBinaryOpKind

pub fn eq(&self, other: &ClassSetBinaryOpKind) -> bool

impl PartialEq<ClassPerl> for ClassPerl

pub fn eq(&self, other: &ClassPerl) -> bool

pub fn ne(&self, other: &ClassPerl) -> bool

impl PartialEq<CaptureName> for CaptureName

pub fn eq(&self, other: &CaptureName) -> bool

pub fn ne(&self, other: &CaptureName) -> bool

impl PartialEq<ClassSet> for ClassSet

pub fn eq(&self, other: &ClassSet) -> bool

pub fn ne(&self, other: &ClassSet) -> bool

impl PartialEq<ErrorKind> for ErrorKind

pub fn eq(&self, other: &ErrorKind) -> bool

pub fn ne(&self, other: &ErrorKind) -> bool

impl PartialEq<ClassUnicodeKind> for ClassUnicodeKind

pub fn eq(&self, other: &ClassUnicodeKind) -> bool

pub fn ne(&self, other: &ClassUnicodeKind) -> bool

impl PartialEq<Utf8Range> for Utf8Range

pub fn eq(&self, other: &Utf8Range) -> bool

pub fn ne(&self, other: &Utf8Range) -> bool

impl PartialEq<Repetition> for Repetition

pub fn eq(&self, other: &Repetition) -> bool

pub fn ne(&self, other: &Repetition) -> bool

impl PartialEq<FlagsItemKind> for FlagsItemKind

pub fn eq(&self, other: &FlagsItemKind) -> bool

pub fn ne(&self, other: &FlagsItemKind) -> bool

impl PartialEq<AssertionKind> for AssertionKind

pub fn eq(&self, other: &AssertionKind) -> bool

impl PartialEq<ClassUnicode> for ClassUnicode

pub fn eq(&self, other: &ClassUnicode) -> bool

pub fn ne(&self, other: &ClassUnicode) -> bool

impl PartialEq<WithComments> for WithComments

pub fn eq(&self, other: &WithComments) -> bool

pub fn ne(&self, other: &WithComments) -> bool

impl PartialEq<Span> for Span

pub fn eq(&self, other: &Span) -> bool

pub fn ne(&self, other: &Span) -> bool

impl PartialEq<Error> for Error

pub fn eq(&self, other: &Error) -> bool

pub fn ne(&self, other: &Error) -> bool

impl PartialEq<Error> for Error

pub fn eq(&self, other: &Error) -> bool

pub fn ne(&self, other: &Error) -> bool

impl PartialEq<Error> for Error

pub fn eq(&self, other: &Error) -> bool

pub fn ne(&self, other: &Error) -> bool

impl PartialEq<ClassAsciiKind> for ClassAsciiKind

pub fn eq(&self, other: &ClassAsciiKind) -> bool

impl PartialEq<Ast> for Ast

pub fn eq(&self, other: &Ast) -> bool

pub fn ne(&self, other: &Ast) -> bool

impl PartialEq<ClassUnicodeOpKind> for ClassUnicodeOpKind

pub fn eq(&self, other: &ClassUnicodeOpKind) -> bool

impl PartialEq<RepetitionRange> for RepetitionRange

pub fn eq(&self, other: &RepetitionRange) -> bool

pub fn ne(&self, other: &RepetitionRange) -> bool

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

pub fn eq(&self, other: &OnceCell<T>) -> bool

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

pub fn eq(&self, other: &OnceCell<T>) -> bool

impl PartialEq<WaitTimeoutResult> for WaitTimeoutResult

pub fn eq(&self, other: &WaitTimeoutResult) -> bool

pub fn ne(&self, other: &WaitTimeoutResult) -> bool

impl PartialEq<OnceState> for OnceState

pub fn eq(&self, other: &OnceState) -> bool

impl PartialEq<UnparkToken> for UnparkToken

pub fn eq(&self, other: &UnparkToken) -> bool

pub fn ne(&self, other: &UnparkToken) -> bool

impl PartialEq<UnparkResult> for UnparkResult

pub fn eq(&self, other: &UnparkResult) -> bool

pub fn ne(&self, other: &UnparkResult) -> bool

impl PartialEq<RequeueOp> for RequeueOp

pub fn eq(&self, other: &RequeueOp) -> bool

impl PartialEq<ParkToken> for ParkToken

pub fn eq(&self, other: &ParkToken) -> bool

pub fn ne(&self, other: &ParkToken) -> bool

impl PartialEq<ParkResult> for ParkResult

pub fn eq(&self, other: &ParkResult) -> bool

pub fn ne(&self, other: &ParkResult) -> bool

impl PartialEq<FilterOp> for FilterOp

pub fn eq(&self, other: &FilterOp) -> bool

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

pub fn eq(&self, other: &SmallVec<B>) -> bool

impl PartialEq<regmatch_t> for regmatch_t

pub fn eq(&self, other: &regmatch_t) -> bool

pub fn ne(&self, other: &regmatch_t) -> bool

impl PartialEq<ff_effect> for ff_effect

pub fn eq(&self, other: &ff_effect) -> bool

pub fn ne(&self, other: &ff_effect) -> bool

impl PartialEq<Elf64_Chdr> for Elf64_Chdr

pub fn eq(&self, other: &Elf64_Chdr) -> bool

pub fn ne(&self, other: &Elf64_Chdr) -> bool

impl PartialEq<lconv> for lconv

pub fn eq(&self, other: &lconv) -> bool

pub fn ne(&self, other: &lconv) -> bool

impl PartialEq<stat> for stat

pub fn eq(&self, other: &stat) -> bool

pub fn ne(&self, other: &stat) -> bool

impl PartialEq<pthread_cond_t> for pthread_cond_t

pub fn eq(&self, other: &pthread_cond_t) -> bool

impl PartialEq<glob_t> for glob_t

pub fn eq(&self, other: &glob_t) -> bool

pub fn ne(&self, other: &glob_t) -> bool

impl PartialEq<_libc_fpstate> for _libc_fpstate

pub fn eq(&self, other: &_libc_fpstate) -> bool

pub fn ne(&self, other: &_libc_fpstate) -> bool

impl PartialEq<sockaddr_nl> for sockaddr_nl

pub fn eq(&self, other: &sockaddr_nl) -> bool

impl PartialEq<aiocb> for aiocb

pub fn eq(&self, other: &aiocb) -> bool

pub fn ne(&self, other: &aiocb) -> bool

impl PartialEq<tm> for tm

pub fn eq(&self, other: &tm) -> bool

pub fn ne(&self, other: &tm) -> bool

impl PartialEq<group> for group

pub fn eq(&self, other: &group) -> bool

pub fn ne(&self, other: &group) -> bool

impl PartialEq<ip_mreqn> for ip_mreqn

pub fn eq(&self, other: &ip_mreqn) -> bool

pub fn ne(&self, other: &ip_mreqn) -> bool

impl PartialEq<statvfs64> for statvfs64

pub fn eq(&self, other: &statvfs64) -> bool

pub fn ne(&self, other: &statvfs64) -> bool

impl PartialEq<Elf64_Ehdr> for Elf64_Ehdr

pub fn eq(&self, other: &Elf64_Ehdr) -> bool

pub fn ne(&self, other: &Elf64_Ehdr) -> bool

impl PartialEq<spwd> for spwd

pub fn eq(&self, other: &spwd) -> bool

pub fn ne(&self, other: &spwd) -> bool

impl PartialEq<Dl_info> for Dl_info

pub fn eq(&self, other: &Dl_info) -> bool

pub fn ne(&self, other: &Dl_info) -> bool

impl PartialEq<fd_set> for fd_set

pub fn eq(&self, other: &fd_set) -> bool

pub fn ne(&self, other: &fd_set) -> bool

impl PartialEq<sem_t> for sem_t

pub fn eq(&self, other: &sem_t) -> bool

pub fn ne(&self, other: &sem_t) -> bool

impl PartialEq<__exit_status> for __exit_status

pub fn eq(&self, other: &__exit_status) -> bool

pub fn ne(&self, other: &__exit_status) -> bool

impl PartialEq<Elf32_Sym> for Elf32_Sym

pub fn eq(&self, other: &Elf32_Sym) -> bool

pub fn ne(&self, other: &Elf32_Sym) -> bool

impl PartialEq<nlmsgerr> for nlmsgerr

pub fn eq(&self, other: &nlmsgerr) -> bool

pub fn ne(&self, other: &nlmsgerr) -> bool

impl PartialEq<timeval> for timeval

pub fn eq(&self, other: &timeval) -> bool

pub fn ne(&self, other: &timeval) -> bool

impl PartialEq<stack_t> for stack_t

pub fn eq(&self, other: &stack_t) -> bool

pub fn ne(&self, other: &stack_t) -> bool

impl PartialEq<pthread_mutex_t> for pthread_mutex_t

pub fn eq(&self, other: &pthread_mutex_t) -> bool

impl PartialEq<msginfo> for msginfo

pub fn eq(&self, other: &msginfo) -> bool

pub fn ne(&self, other: &msginfo) -> bool

impl PartialEq<termios> for termios

pub fn eq(&self, other: &termios) -> bool

pub fn ne(&self, other: &termios) -> bool

impl PartialEq<_libc_fpxreg> for _libc_fpxreg

pub fn eq(&self, other: &_libc_fpxreg) -> bool

pub fn ne(&self, other: &_libc_fpxreg) -> bool

impl PartialEq<rlimit> for rlimit

pub fn eq(&self, other: &rlimit) -> bool

pub fn ne(&self, other: &rlimit) -> bool

impl PartialEq<stat64> for stat64

pub fn eq(&self, other: &stat64) -> bool

pub fn ne(&self, other: &stat64) -> bool

impl PartialEq<dirent> for dirent

pub fn eq(&self, other: &dirent) -> bool

impl PartialEq<flock> for flock

pub fn eq(&self, other: &flock) -> bool

pub fn ne(&self, other: &flock) -> bool

impl PartialEq<pollfd> for pollfd

pub fn eq(&self, other: &pollfd) -> bool

pub fn ne(&self, other: &pollfd) -> bool

impl PartialEq<shmid_ds> for shmid_ds

pub fn eq(&self, other: &shmid_ds) -> bool

pub fn ne(&self, other: &shmid_ds) -> bool

impl PartialEq<Elf32_Phdr> for Elf32_Phdr

pub fn eq(&self, other: &Elf32_Phdr) -> bool

pub fn ne(&self, other: &Elf32_Phdr) -> bool

impl PartialEq<mntent> for mntent

pub fn eq(&self, other: &mntent) -> bool

pub fn ne(&self, other: &mntent) -> bool

impl PartialEq<sockaddr_ll> for sockaddr_ll

pub fn eq(&self, other: &sockaddr_ll) -> bool

pub fn ne(&self, other: &sockaddr_ll) -> bool

impl PartialEq<_libc_xmmreg> for _libc_xmmreg

pub fn eq(&self, other: &_libc_xmmreg) -> bool

pub fn ne(&self, other: &_libc_xmmreg) -> bool

impl PartialEq<sched_param> for sched_param

pub fn eq(&self, other: &sched_param) -> bool

pub fn ne(&self, other: &sched_param) -> bool

impl PartialEq<if_nameindex> for if_nameindex

pub fn eq(&self, other: &if_nameindex) -> bool

pub fn ne(&self, other: &if_nameindex) -> bool

impl PartialEq<ff_rumble_effect> for ff_rumble_effect

pub fn eq(&self, other: &ff_rumble_effect) -> bool

pub fn ne(&self, other: &ff_rumble_effect) -> bool

impl PartialEq<genlmsghdr> for genlmsghdr

pub fn eq(&self, other: &genlmsghdr) -> bool

pub fn ne(&self, other: &genlmsghdr) -> bool

impl PartialEq<itimerval> for itimerval

pub fn eq(&self, other: &itimerval) -> bool

pub fn ne(&self, other: &itimerval) -> bool

impl PartialEq<statfs> for statfs

pub fn eq(&self, other: &statfs) -> bool

pub fn ne(&self, other: &statfs) -> bool

impl PartialEq<winsize> for winsize

pub fn eq(&self, other: &winsize) -> bool

pub fn ne(&self, other: &winsize) -> bool

impl PartialEq<Elf32_Chdr> for Elf32_Chdr

pub fn eq(&self, other: &Elf32_Chdr) -> bool

pub fn ne(&self, other: &Elf32_Chdr) -> bool

impl PartialEq<sockaddr_un> for sockaddr_un

pub fn eq(&self, other: &sockaddr_un) -> bool

impl PartialEq<posix_spawnattr_t> for posix_spawnattr_t

pub fn eq(&self, other: &posix_spawnattr_t) -> bool

pub fn ne(&self, other: &posix_spawnattr_t) -> bool

impl PartialEq<utimbuf> for utimbuf

pub fn eq(&self, other: &utimbuf) -> bool

pub fn ne(&self, other: &utimbuf) -> bool

impl PartialEq<in6_pktinfo> for in6_pktinfo

pub fn eq(&self, other: &in6_pktinfo) -> bool

pub fn ne(&self, other: &in6_pktinfo) -> bool

impl PartialEq<ipc_perm> for ipc_perm

pub fn eq(&self, other: &ipc_perm) -> bool

pub fn ne(&self, other: &ipc_perm) -> bool

impl PartialEq<sigaction> for sigaction

pub fn eq(&self, other: &sigaction) -> bool

pub fn ne(&self, other: &sigaction) -> bool

impl PartialEq<nl_mmap_hdr> for nl_mmap_hdr

pub fn eq(&self, other: &nl_mmap_hdr) -> bool

pub fn ne(&self, other: &nl_mmap_hdr) -> bool

impl PartialEq<signalfd_siginfo> for signalfd_siginfo

pub fn eq(&self, other: &signalfd_siginfo) -> bool

pub fn ne(&self, other: &signalfd_siginfo) -> bool

impl PartialEq<dqblk> for dqblk

pub fn eq(&self, other: &dqblk) -> bool

pub fn ne(&self, other: &dqblk) -> bool

impl PartialEq<pthread_rwlockattr_t> for pthread_rwlockattr_t

pub fn eq(&self, other: &pthread_rwlockattr_t) -> bool

pub fn ne(&self, other: &pthread_rwlockattr_t) -> bool

impl PartialEq<statx> for statx

pub fn eq(&self, other: &statx) -> bool

pub fn ne(&self, other: &statx) -> bool

impl PartialEq<dirent64> for dirent64

pub fn eq(&self, other: &dirent64) -> bool

impl PartialEq<rtentry> for rtentry

pub fn eq(&self, other: &rtentry) -> bool

pub fn ne(&self, other: &rtentry) -> bool

impl PartialEq<Elf64_Phdr> for Elf64_Phdr

pub fn eq(&self, other: &Elf64_Phdr) -> bool

pub fn ne(&self, other: &Elf64_Phdr) -> bool

impl PartialEq<epoll_event> for epoll_event

pub fn eq(&self, other: &epoll_event) -> bool

impl PartialEq<ucontext_t> for ucontext_t

pub fn eq(&self, other: &ucontext_t) -> bool

impl PartialEq<ff_periodic_effect> for ff_periodic_effect

pub fn eq(&self, other: &ff_periodic_effect) -> bool

pub fn ne(&self, other: &ff_periodic_effect) -> bool

impl PartialEq<Elf32_Ehdr> for Elf32_Ehdr

pub fn eq(&self, other: &Elf32_Ehdr) -> bool

pub fn ne(&self, other: &Elf32_Ehdr) -> bool

impl PartialEq<__c_anonymous_sockaddr_can_tp> for __c_anonymous_sockaddr_can_tp

pub fn eq(&self, other: &__c_anonymous_sockaddr_can_tp) -> bool

pub fn ne(&self, other: &__c_anonymous_sockaddr_can_tp) -> bool

impl PartialEq<nl_pktinfo> for nl_pktinfo

pub fn eq(&self, other: &nl_pktinfo) -> bool

pub fn ne(&self, other: &nl_pktinfo) -> bool

impl PartialEq<ff_envelope> for ff_envelope

pub fn eq(&self, other: &ff_envelope) -> bool

pub fn ne(&self, other: &ff_envelope) -> bool

impl PartialEq<flock64> for flock64

pub fn eq(&self, other: &flock64) -> bool

pub fn ne(&self, other: &flock64) -> bool

impl PartialEq<fsid_t> for fsid_t

pub fn eq(&self, other: &fsid_t) -> bool

pub fn ne(&self, other: &fsid_t) -> bool

impl PartialEq<sockaddr> for sockaddr

pub fn eq(&self, other: &sockaddr) -> bool

pub fn ne(&self, other: &sockaddr) -> bool

impl PartialEq<ff_replay> for ff_replay

pub fn eq(&self, other: &ff_replay) -> bool

pub fn ne(&self, other: &ff_replay) -> bool

impl PartialEq<iovec> for iovec

pub fn eq(&self, other: &iovec) -> bool

pub fn ne(&self, other: &iovec) -> bool

impl PartialEq<packet_mreq> for packet_mreq

pub fn eq(&self, other: &packet_mreq) -> bool

pub fn ne(&self, other: &packet_mreq) -> bool

impl PartialEq<statvfs> for statvfs

pub fn eq(&self, other: &statvfs) -> bool

pub fn ne(&self, other: &statvfs) -> bool

impl PartialEq<in_addr> for in_addr

pub fn eq(&self, other: &in_addr) -> bool

pub fn ne(&self, other: &in_addr) -> bool

impl PartialEq<input_keymap_entry> for input_keymap_entry

pub fn eq(&self, other: &input_keymap_entry) -> bool

pub fn ne(&self, other: &input_keymap_entry) -> bool

impl PartialEq<statfs64> for statfs64

pub fn eq(&self, other: &statfs64) -> bool

pub fn ne(&self, other: &statfs64) -> bool

impl PartialEq<user_regs_struct> for user_regs_struct

pub fn eq(&self, other: &user_regs_struct) -> bool

pub fn ne(&self, other: &user_regs_struct) -> bool

impl PartialEq<ifaddrs> for ifaddrs

pub fn eq(&self, other: &ifaddrs) -> bool

pub fn ne(&self, other: &ifaddrs) -> bool

impl PartialEq<af_alg_iv> for af_alg_iv

pub fn eq(&self, other: &af_alg_iv) -> bool

impl PartialEq<linger> for linger

pub fn eq(&self, other: &linger) -> bool

pub fn ne(&self, other: &linger) -> bool

impl PartialEq<cmsghdr> for cmsghdr

pub fn eq(&self, other: &cmsghdr) -> bool

pub fn ne(&self, other: &cmsghdr) -> bool

impl PartialEq<sembuf> for sembuf

pub fn eq(&self, other: &sembuf) -> bool

pub fn ne(&self, other: &sembuf) -> bool

impl PartialEq<ntptimeval> for ntptimeval

pub fn eq(&self, other: &ntptimeval) -> bool

pub fn ne(&self, other: &ntptimeval) -> bool

impl PartialEq<sysinfo> for sysinfo

pub fn eq(&self, other: &sysinfo) -> bool

pub fn ne(&self, other: &sysinfo) -> bool

impl PartialEq<Elf64_Sym> for Elf64_Sym

pub fn eq(&self, other: &Elf64_Sym) -> bool

pub fn ne(&self, other: &Elf64_Sym) -> bool

impl PartialEq<pthread_rwlock_t> for pthread_rwlock_t

pub fn eq(&self, other: &pthread_rwlock_t) -> bool

impl PartialEq<regex_t> for regex_t

pub fn eq(&self, other: &regex_t) -> bool

pub fn ne(&self, other: &regex_t) -> bool

impl PartialEq<termios2> for termios2

pub fn eq(&self, other: &termios2) -> bool

pub fn ne(&self, other: &termios2) -> bool

impl PartialEq<Elf64_Shdr> for Elf64_Shdr

pub fn eq(&self, other: &Elf64_Shdr) -> bool

pub fn ne(&self, other: &Elf64_Shdr) -> bool

impl PartialEq<siginfo_t> for siginfo_t

pub fn eq(&self, other: &siginfo_t) -> bool

pub fn ne(&self, other: &siginfo_t) -> bool

impl PartialEq<tms> for tms

pub fn eq(&self, other: &tms) -> bool

pub fn ne(&self, other: &tms) -> bool

impl PartialEq<sigset_t> for sigset_t

pub fn eq(&self, other: &sigset_t) -> bool

pub fn ne(&self, other: &sigset_t) -> bool

impl PartialEq<posix_spawn_file_actions_t> for posix_spawn_file_actions_t

pub fn eq(&self, other: &posix_spawn_file_actions_t) -> bool

pub fn ne(&self, other: &posix_spawn_file_actions_t) -> bool

impl PartialEq<sock_extended_err> for sock_extended_err

pub fn eq(&self, other: &sock_extended_err) -> bool

pub fn ne(&self, other: &sock_extended_err) -> bool

impl PartialEq<__timeval> for __timeval

pub fn eq(&self, other: &__timeval) -> bool

pub fn ne(&self, other: &__timeval) -> bool

impl PartialEq<itimerspec> for itimerspec

pub fn eq(&self, other: &itimerspec) -> bool

pub fn ne(&self, other: &itimerspec) -> bool

impl PartialEq<utmpx> for utmpx

pub fn eq(&self, other: &utmpx) -> bool

impl PartialEq<msghdr> for msghdr

pub fn eq(&self, other: &msghdr) -> bool

pub fn ne(&self, other: &msghdr) -> bool

impl PartialEq<timespec> for timespec

pub fn eq(&self, other: &timespec) -> bool

pub fn ne(&self, other: &timespec) -> bool

impl PartialEq<cpu_set_t> for cpu_set_t

pub fn eq(&self, other: &cpu_set_t) -> bool

pub fn ne(&self, other: &cpu_set_t) -> bool

impl PartialEq<input_event> for input_event

pub fn eq(&self, other: &input_event) -> bool

pub fn ne(&self, other: &input_event) -> bool

impl PartialEq<__c_anonymous_sockaddr_can_j1939> for __c_anonymous_sockaddr_can_j1939

pub fn eq(&self, other: &__c_anonymous_sockaddr_can_j1939) -> bool

pub fn ne(&self, other: &__c_anonymous_sockaddr_can_j1939) -> bool

impl PartialEq<protoent> for protoent

pub fn eq(&self, other: &protoent) -> bool

pub fn ne(&self, other: &protoent) -> bool

impl PartialEq<mallinfo> for mallinfo

pub fn eq(&self, other: &mallinfo) -> bool

pub fn ne(&self, other: &mallinfo) -> bool

impl PartialEq<rusage> for rusage

pub fn eq(&self, other: &rusage) -> bool

pub fn ne(&self, other: &rusage) -> bool

impl PartialEq<sigval> for sigval

pub fn eq(&self, other: &sigval) -> bool

pub fn ne(&self, other: &sigval) -> bool

impl PartialEq<msqid_ds> for msqid_ds

pub fn eq(&self, other: &msqid_ds) -> bool

pub fn ne(&self, other: &msqid_ds) -> bool

impl PartialEq<in_pktinfo> for in_pktinfo

pub fn eq(&self, other: &in_pktinfo) -> bool

pub fn ne(&self, other: &in_pktinfo) -> bool

impl PartialEq<sigevent> for sigevent

pub fn eq(&self, other: &sigevent) -> bool

impl PartialEq<ff_condition_effect> for ff_condition_effect

pub fn eq(&self, other: &ff_condition_effect) -> bool

pub fn ne(&self, other: &ff_condition_effect) -> bool

impl PartialEq<dl_phdr_info> for dl_phdr_info

pub fn eq(&self, other: &dl_phdr_info) -> bool

pub fn ne(&self, other: &dl_phdr_info) -> bool

impl PartialEq<input_mask> for input_mask

pub fn eq(&self, other: &input_mask) -> bool

pub fn ne(&self, other: &input_mask) -> bool

impl PartialEq<utsname> for utsname

pub fn eq(&self, other: &utsname) -> bool

impl PartialEq<ipv6_mreq> for ipv6_mreq

pub fn eq(&self, other: &ipv6_mreq) -> bool

pub fn ne(&self, other: &ipv6_mreq) -> bool

impl PartialEq<in6_rtmsg> for in6_rtmsg

pub fn eq(&self, other: &in6_rtmsg) -> bool

pub fn ne(&self, other: &in6_rtmsg) -> bool

impl PartialEq<ff_trigger> for ff_trigger

pub fn eq(&self, other: &ff_trigger) -> bool

pub fn ne(&self, other: &ff_trigger) -> bool

impl PartialEq<nlattr> for nlattr

pub fn eq(&self, other: &nlattr) -> bool

pub fn ne(&self, other: &nlattr) -> bool

impl PartialEq<timex> for timex

pub fn eq(&self, other: &timex) -> bool

pub fn ne(&self, other: &timex) -> bool

impl PartialEq<mq_attr> for mq_attr

pub fn eq(&self, other: &mq_attr) -> bool

impl PartialEq<ff_ramp_effect> for ff_ramp_effect

pub fn eq(&self, other: &ff_ramp_effect) -> bool

pub fn ne(&self, other: &ff_ramp_effect) -> bool

impl PartialEq<arphdr> for arphdr

pub fn eq(&self, other: &arphdr) -> bool

pub fn ne(&self, other: &arphdr) -> bool

impl PartialEq<glob64_t> for glob64_t

pub fn eq(&self, other: &glob64_t) -> bool

pub fn ne(&self, other: &glob64_t) -> bool

impl PartialEq<input_absinfo> for input_absinfo

pub fn eq(&self, other: &input_absinfo) -> bool

pub fn ne(&self, other: &input_absinfo) -> bool

impl PartialEq<servent> for servent

pub fn eq(&self, other: &servent) -> bool

pub fn ne(&self, other: &servent) -> bool

impl PartialEq<ff_constant_effect> for ff_constant_effect

pub fn eq(&self, other: &ff_constant_effect) -> bool

pub fn ne(&self, other: &ff_constant_effect) -> bool

impl PartialEq<sockaddr_vm> for sockaddr_vm

pub fn eq(&self, other: &sockaddr_vm) -> bool

pub fn ne(&self, other: &sockaddr_vm) -> bool

impl PartialEq<nlmsghdr> for nlmsghdr

pub fn eq(&self, other: &nlmsghdr) -> bool

pub fn ne(&self, other: &nlmsghdr) -> bool

impl PartialEq<in6_addr> for in6_addr

pub fn eq(&self, other: &in6_addr) -> bool

pub fn ne(&self, other: &in6_addr) -> bool

impl PartialEq<arpreq> for arpreq

pub fn eq(&self, other: &arpreq) -> bool

pub fn ne(&self, other: &arpreq) -> bool

impl PartialEq<inotify_event> for inotify_event

pub fn eq(&self, other: &inotify_event) -> bool

pub fn ne(&self, other: &inotify_event) -> bool

impl PartialEq<ucred> for ucred

pub fn eq(&self, other: &ucred) -> bool

pub fn ne(&self, other: &ucred) -> bool

impl PartialEq<pthread_condattr_t> for pthread_condattr_t

pub fn eq(&self, other: &pthread_condattr_t) -> bool

pub fn ne(&self, other: &pthread_condattr_t) -> bool

impl PartialEq<mcontext_t> for mcontext_t

pub fn eq(&self, other: &mcontext_t) -> bool

pub fn ne(&self, other: &mcontext_t) -> bool

impl PartialEq<user_fpregs_struct> for user_fpregs_struct

pub fn eq(&self, other: &user_fpregs_struct) -> bool

impl PartialEq<nl_mmap_req> for nl_mmap_req

pub fn eq(&self, other: &nl_mmap_req) -> bool

pub fn ne(&self, other: &nl_mmap_req) -> bool

impl PartialEq<statx_timestamp> for statx_timestamp

pub fn eq(&self, other: &statx_timestamp) -> bool

pub fn ne(&self, other: &statx_timestamp) -> bool

impl PartialEq<Elf32_Shdr> for Elf32_Shdr

pub fn eq(&self, other: &Elf32_Shdr) -> bool

pub fn ne(&self, other: &Elf32_Shdr) -> bool

impl PartialEq<passwd> for passwd

pub fn eq(&self, other: &passwd) -> bool

pub fn ne(&self, other: &passwd) -> bool

impl PartialEq<hostent> for hostent

pub fn eq(&self, other: &hostent) -> bool

pub fn ne(&self, other: &hostent) -> bool

impl PartialEq<arpreq_old> for arpreq_old

pub fn eq(&self, other: &arpreq_old) -> bool

pub fn ne(&self, other: &arpreq_old) -> bool

impl PartialEq<rlimit64> for rlimit64

pub fn eq(&self, other: &rlimit64) -> bool

pub fn ne(&self, other: &rlimit64) -> bool

impl PartialEq<can_filter> for can_filter

pub fn eq(&self, other: &can_filter) -> bool

pub fn ne(&self, other: &can_filter) -> bool

impl PartialEq<arpd_request> for arpd_request

pub fn eq(&self, other: &arpd_request) -> bool

pub fn ne(&self, other: &arpd_request) -> bool

impl PartialEq<addrinfo> for addrinfo

pub fn eq(&self, other: &addrinfo) -> bool

pub fn ne(&self, other: &addrinfo) -> bool

impl PartialEq<fanotify_response> for fanotify_response

pub fn eq(&self, other: &fanotify_response) -> bool

pub fn ne(&self, other: &fanotify_response) -> bool

impl PartialEq<sockaddr_alg> for sockaddr_alg

pub fn eq(&self, other: &sockaddr_alg) -> bool

impl PartialEq<user> for user

pub fn eq(&self, other: &user) -> bool

pub fn ne(&self, other: &user) -> bool

impl PartialEq<ip_mreq> for ip_mreq

pub fn eq(&self, other: &ip_mreq) -> bool

pub fn ne(&self, other: &ip_mreq) -> bool

impl PartialEq<input_id> for input_id

pub fn eq(&self, other: &input_id) -> bool

pub fn ne(&self, other: &input_id) -> bool

impl PartialEq<pthread_mutexattr_t> for pthread_mutexattr_t

pub fn eq(&self, other: &pthread_mutexattr_t) -> bool

pub fn ne(&self, other: &pthread_mutexattr_t) -> bool

impl PartialEq<sockaddr_in6> for sockaddr_in6

pub fn eq(&self, other: &sockaddr_in6) -> bool

pub fn ne(&self, other: &sockaddr_in6) -> bool

impl PartialEq<sockaddr_in> for sockaddr_in

pub fn eq(&self, other: &sockaddr_in) -> bool

pub fn ne(&self, other: &sockaddr_in) -> bool

impl PartialEq<pthread_attr_t> for pthread_attr_t

pub fn eq(&self, other: &pthread_attr_t) -> bool

pub fn ne(&self, other: &pthread_attr_t) -> bool

impl PartialEq<ip_mreq_source> for ip_mreq_source

pub fn eq(&self, other: &ip_mreq_source) -> bool

pub fn ne(&self, other: &ip_mreq_source) -> bool

impl PartialEq<mmsghdr> for mmsghdr

pub fn eq(&self, other: &mmsghdr) -> bool

pub fn ne(&self, other: &mmsghdr) -> bool

impl PartialEq<sockaddr_storage> for sockaddr_storage

pub fn eq(&self, other: &sockaddr_storage) -> bool

impl PartialEq<fanotify_event_metadata> for fanotify_event_metadata

pub fn eq(&self, other: &fanotify_event_metadata) -> bool

pub fn ne(&self, other: &fanotify_event_metadata) -> bool

impl PartialEq<BigEndian> for BigEndian

pub fn eq(&self, other: &BigEndian) -> bool

impl PartialEq<LittleEndian> for LittleEndian

pub fn eq(&self, other: &LittleEndian) -> bool

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

pub fn eq(&self, other: &ANSIGenericString<'a, S>) -> bool

pub fn ne(&self, other: &ANSIGenericString<'a, S>) -> bool

impl PartialEq<Style> for Style

pub fn eq(&self, other: &Style) -> bool

pub fn ne(&self, other: &Style) -> bool

impl PartialEq<Colour> for Colour

pub fn eq(&self, other: &Colour) -> bool

pub fn ne(&self, other: &Colour) -> bool

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

pub fn eq(&self, other: &ANSIGenericStrings<'a, S>) -> bool

pub fn ne(&self, other: &ANSIGenericStrings<'a, S>) -> bool

impl PartialEq<Value> for bool

pub fn eq(&self, other: &Value) -> bool

impl PartialEq<Value> for f64

pub fn eq(&self, other: &Value) -> bool

impl PartialEq<Number> for Number

pub fn eq(&self, other: &Number) -> bool

pub fn ne(&self, other: &Number) -> bool

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

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

impl PartialEq<Map<String, Value>> for Map<String, Value>

pub fn eq(&self, other: &Map<String, Value>) -> bool

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

pub fn eq(&self, other: &i64) -> bool

impl PartialEq<Value> for usize

pub fn eq(&self, other: &Value) -> bool

impl PartialEq<Value> for i8

pub fn eq(&self, other: &Value) -> bool

impl PartialEq<i32> for Value

pub fn eq(&self, other: &i32) -> bool

impl PartialEq<Value> for f32

pub fn eq(&self, other: &Value) -> bool

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

pub fn eq(&self, other: &i8) -> bool

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

pub fn eq(&self, other: &i16) -> bool

impl PartialEq<i8> for Value

pub fn eq(&self, other: &i8) -> bool

impl PartialEq<u32> for Value

pub fn eq(&self, other: &u32) -> bool

impl PartialEq<u8> for Value

pub fn eq(&self, other: &u8) -> bool

impl PartialEq<usize> for Value

pub fn eq(&self, other: &usize) -> bool

impl PartialEq<i16> for Value

pub fn eq(&self, other: &i16) -> bool

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

pub fn eq(&self, other: &i32) -> bool

impl PartialEq<Value> for isize

pub fn eq(&self, other: &Value) -> bool

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

pub fn eq(&self, other: &f32) -> bool

impl PartialEq<u64> for Value

pub fn eq(&self, other: &u64) -> bool

impl PartialEq<Value> for i16

pub fn eq(&self, other: &Value) -> bool

impl PartialEq<Value> for u32

pub fn eq(&self, other: &Value) -> bool

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

pub fn eq(&self, other: &u16) -> bool

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

pub fn eq(&self, other: &u16) -> bool

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

pub fn eq(&self, other: &u64) -> bool

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

pub fn eq(&self, other: &u32) -> bool

impl PartialEq<Value> for Value

pub fn eq(&self, other: &Value) -> bool

pub fn ne(&self, other: &Value) -> bool

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

pub fn eq(&self, other: &Value) -> bool

impl PartialEq<Value> for i64

pub fn eq(&self, other: &Value) -> bool

impl PartialEq<bool> for Value

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

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

pub fn eq(&self, other: &i8) -> bool

impl PartialEq<f64> for Value

pub fn eq(&self, other: &f64) -> bool

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

pub fn eq(&self, other: &isize) -> bool

impl PartialEq<i64> for Value

pub fn eq(&self, other: &i64) -> bool

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

pub fn eq(&self, other: &u8) -> bool

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

pub fn eq(&self, other: &u8) -> bool

impl PartialEq<Value> for i32

pub fn eq(&self, other: &Value) -> bool

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

pub fn eq(&self, other: &i16) -> bool

impl PartialEq<Category> for Category

pub fn eq(&self, other: &Category) -> bool

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

pub fn eq(&self, other: &f64) -> bool

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

pub fn eq(&self, other: &u64) -> bool

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

pub fn eq(&self, other: &usize) -> bool

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

pub fn eq(&self, other: &&str) -> bool

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

pub fn eq(&self, other: &i64) -> bool

impl PartialEq<Value> for String

pub fn eq(&self, other: &Value) -> bool

impl PartialEq<Value> for u16

pub fn eq(&self, other: &Value) -> bool

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

pub fn eq(&self, other: &isize) -> bool

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

pub fn eq(&self, other: &i32) -> bool

impl PartialEq<str> for Value

pub fn eq(&self, other: &str) -> bool

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

pub fn eq(&self, other: &usize) -> bool

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

pub fn eq(&self, other: &f32) -> bool

impl PartialEq<Value> for u64

pub fn eq(&self, other: &Value) -> bool

impl PartialEq<Value> for str

pub fn eq(&self, other: &Value) -> bool

impl PartialEq<u16> for Value

pub fn eq(&self, other: &u16) -> bool

impl PartialEq<String> for Value

pub fn eq(&self, other: &String) -> bool

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

pub fn eq(&self, other: &u32) -> bool

impl PartialEq<isize> for Value

pub fn eq(&self, other: &isize) -> bool

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

pub fn eq(&self, other: &f64) -> bool

impl PartialEq<f32> for Value

pub fn eq(&self, other: &f32) -> bool

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

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

impl PartialEq<Value> for u8

pub fn eq(&self, other: &Value) -> bool

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

pub fn eq(&self, other: &T) -> bool

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

pub fn eq(&self, other: &T) -> bool

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

pub fn eq(&self, other: &T) -> bool

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

pub fn eq(&self, other: &T) -> bool

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

pub fn eq(&self, other: &T) -> bool

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

pub fn eq(&self, other: &T) -> bool

impl PartialEq<IsoWeek> for IsoWeek

pub fn eq(&self, other: &IsoWeek) -> bool

pub fn ne(&self, other: &IsoWeek) -> bool

impl PartialEq<InternalNumeric> for InternalNumeric

pub fn eq(&self, _other: &InternalNumeric) -> bool

impl