Trait wasmer_types::entity::__core::cmp::PartialEq

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

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

Trait for equality comparisons which are partial equivalence relations.

This trait allows for partial equality, for types that do not have a full equivalence relation. For example, in floating point numbers NaN != NaN, so floating point types implement PartialEq but not Eq.

Formally, the equality must be (for all a, b and c):

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

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

Derivable

This trait can be used with #[derive]. When 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]fn eq(&self, other: &Rhs) -> bool

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

Loading content...

Provided methods

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

This method tests for !=.

Loading content...

Implementations on Foreign Types

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

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

impl PartialEq<SocketAddrV6> for SocketAddrV6

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

impl PartialEq<RecvTimeoutError> for RecvTimeoutError

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

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

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

impl PartialEq<Ipv4Addr> for Ipv4Addr

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

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

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

impl PartialEq<NulError> for NulError

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

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

impl PartialEq<IpAddr> for Ipv4Addr

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

impl PartialEq<OsStr> for str

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

impl PartialEq<OsString> for OsString

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

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

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

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

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

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

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

impl PartialEq<ErrorKind> for ErrorKind

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

impl PartialEq<Ipv6Addr> for Ipv6Addr

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

impl PartialEq<Instant> for Instant

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

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

impl PartialEq<SystemTime> for SystemTime

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

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

impl PartialEq<Shutdown> for Shutdown

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

impl PartialEq<IpAddr> for Ipv6Addr

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

impl PartialEq<AddrParseError> for AddrParseError

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

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

impl PartialEq<str> for OsStr

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

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

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

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

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

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

impl PartialEq<RecvError> for RecvError

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

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

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

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

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

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

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

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

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

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

impl PartialEq<CStr> for CStr

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

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

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

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

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

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

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

impl PartialEq<WaitTimeoutResult> for WaitTimeoutResult

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl PartialEq<ExitStatus> for ExitStatus

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

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

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

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

impl PartialEq<FileType> for FileType

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

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

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

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

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

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

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

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

impl PartialEq<Permissions> for Permissions

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

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

impl PartialEq<FromVecWithNulError> for FromVecWithNulError

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

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

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

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

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

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

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

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

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

impl PartialEq<AccessError> for AccessError

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

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

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

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

impl PartialEq<ThreadId> for ThreadId

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

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

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

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

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

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

impl PartialEq<Output> for Output

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

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

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

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

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

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

impl PartialEq<str> for OsString

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

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

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

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

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

impl PartialEq<Path> for Path

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

impl PartialEq<CString> for CString

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

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

impl PartialEq<SocketAddr> for SocketAddr

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

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

impl PartialEq<VarError> for VarError

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl PartialEq<FromBytesWithNulError> for FromBytesWithNulError

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

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

impl PartialEq<Ipv6MulticastScope> for Ipv6MulticastScope

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

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

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

impl PartialEq<Ipv6Addr> for IpAddr

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

impl PartialEq<SocketAddrV4> for SocketAddrV4

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

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

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

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

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

impl PartialEq<Ipv4Addr> for IpAddr

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

impl PartialEq<SeekFrom> for SeekFrom

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

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

impl PartialEq<BacktraceStatus> for BacktraceStatus

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

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

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

impl PartialEq<PathBuf> for PathBuf

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

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

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

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

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

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

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

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

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

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

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

impl PartialEq<OsString> for str

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

impl PartialEq<IntoStringError> for IntoStringError

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

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

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

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

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

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

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

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

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

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

impl PartialEq<StripPrefixError> for StripPrefixError

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

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

impl PartialEq<OsStr> for OsStr

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

impl PartialEq<IpAddr> for IpAddr

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

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

impl PartialEq<TryRecvError> for TryRecvError

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

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

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

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

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

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

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

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

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

fn ne(&self, other: &TrySendError<T>) -> 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

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

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

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

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

impl PartialEq<str> for str

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

fn ne(&self, other: &str) -> 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

fn eq(&self, other: &extern "C" fn(A, B, C, D, ...) -> 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

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> PartialEq<unsafe fn(A, B, C, D, E, F) -> Ret> for unsafe fn(A, B, C, D, E, F) -> Ret

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

impl PartialEq<i128> for i128

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

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

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

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

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

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

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

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

fn eq(&self, other: &fn(A, B, C, D) -> 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

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> PartialEq<extern "C" fn(A, B, C, D, E, F, G) -> Ret> for extern "C" fn(A, B, C, D, E, F, G) -> Ret

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

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

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

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

impl PartialEq<u8> for u8

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

fn ne(&self, other: &u8) -> 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

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

fn eq(&self, other: &fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret) -> 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
    A: PartialEq<A>,
    B: PartialEq<B>,
    C: PartialEq<C>,
    D: PartialEq<D>,
    E: PartialEq<E>,
    F: PartialEq<F>,
    G: PartialEq<G>,
    H: PartialEq<H>,
    I: PartialEq<I>,
    J: PartialEq<J>,
    K: PartialEq<K> + ?Sized, 

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

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

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

fn eq(&self, other: &unsafe fn() -> 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

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

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

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

fn eq(&self, other: &fn(A, B, C, D, E) -> 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

fn eq(&self, other: &unsafe fn(A, B, C, D, E, F, G, H) -> 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

fn eq(&self, other: &unsafe extern "C" fn(A, B, C, D, ...) -> 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

fn eq(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> 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

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

impl PartialEq<u64> for u64

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

fn ne(&self, other: &u64) -> 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

fn eq(&self, other: &extern "C" fn(A, B, C, D) -> Ret) -> 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

fn eq(&self, other: &unsafe fn(A, B, C, D, E) -> 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

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

impl PartialEq<u32> for u32

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

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

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

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

fn ne(&self, other: &[A; N]) -> 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

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> PartialEq<fn(A, B, C, D, E, F, G) -> Ret> for fn(A, B, C, D, E, F, G) -> Ret

fn eq(&self, other: &fn(A, B, C, D, E, F, G) -> Ret) -> 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

fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F) -> Ret) -> 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

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

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

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

fn ne(&self, other: &&'b [B]) -> 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

fn eq(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret
) -> 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

fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F, ...) -> 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

fn eq(&self, other: &unsafe extern "C" fn(A, B, C, D) -> Ret) -> 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
    A: PartialEq<A>,
    B: PartialEq<B>,
    C: PartialEq<C>,
    D: PartialEq<D>,
    E: PartialEq<E>,
    F: PartialEq<F>,
    G: PartialEq<G>,
    H: PartialEq<H>,
    I: PartialEq<I> + ?Sized, 

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

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

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

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

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

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

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

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

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

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

fn eq(&self, other: &unsafe extern "C" fn() -> 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

fn eq(&self, other: &extern "C" fn(A, B, C, D, E) -> 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

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

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

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

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

impl PartialEq<i8> for i8

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

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

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

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

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

impl PartialEq<!> for !

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

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

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

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

impl PartialEq<char> for char

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

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

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

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

impl PartialEq<i64> for i64

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

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

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

fn eq(&self, other: &extern "C" fn() -> 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

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

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

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

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

fn ne(&self, other: &[A; N]) -> 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

fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> 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

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

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

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

fn ne(&self, other: &(A,)) -> 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

fn eq(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret
) -> 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

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

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

fn eq(&self, other: &unsafe extern "C" fn(A) -> Ret) -> 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

fn eq(&self, other: &unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret) -> 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

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

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

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

fn ne(&self, other: &[B]) -> 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

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

impl PartialEq<f32> for f32

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

fn ne(&self, other: &f32) -> 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
    A: PartialEq<A>,
    B: PartialEq<B>,
    C: PartialEq<C>,
    D: PartialEq<D>,
    E: PartialEq<E>,
    F: PartialEq<F>,
    G: PartialEq<G>,
    H: PartialEq<H>,
    I: PartialEq<I>,
    J: PartialEq<J> + ?Sized, 

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

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

impl PartialEq<bool> for bool

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

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

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

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

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

fn eq(&self, other: &fn(A, B) -> 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

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

impl PartialEq<usize> for usize

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

fn ne(&self, other: &usize) -> 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

fn eq(
    &self,
    other: &unsafe 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> 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

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

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

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

fn ne(&self, other: &(A, B, C, D)) -> 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

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

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

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

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

fn eq(&self, other: &*const T) -> 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

fn eq(&self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret) -> 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

fn eq(&self, other: &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

fn eq(&self, other: &unsafe fn(A, B, C, D, E, F, G) -> Ret) -> 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

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

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

impl PartialEq<i16> for i16

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

fn ne(&self, other: &i16) -> 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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn eq(&self, other: &unsafe extern "C" fn(A, ...) -> 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

fn eq(&self, other: &extern "C" fn(A, B, C, D, E, ...) -> 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
    A: PartialEq<A>,
    B: PartialEq<B>,
    C: PartialEq<C>,
    D: PartialEq<D>,
    E: PartialEq<E>,
    F: PartialEq<F>,
    G: PartialEq<G>,
    H: PartialEq<H>,
    I: PartialEq<I>,
    J: PartialEq<J>,
    K: PartialEq<K>,
    L: PartialEq<L> + ?Sized, 

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

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

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

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

impl PartialEq<()> for ()

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

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

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

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

fn ne(&self, other: &[A; N]) -> 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

fn eq(
    &self,
    other: &unsafe 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> PartialEq<fn(A, B, C, D, E, F, G, H) -> Ret> for fn(A, B, C, D, E, F, G, H) -> Ret

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

impl PartialEq<i32> for i32

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

fn ne(&self, other: &i32) -> 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

fn eq(&self, other: &fn(A, B, C, D, E, F, G, H, I, J) -> 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

fn eq(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret
) -> 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
    A: PartialEq<A>,
    B: PartialEq<B>,
    C: PartialEq<C>,
    D: PartialEq<D>,
    E: PartialEq<E>,
    F: PartialEq<F>,
    G: PartialEq<G> + ?Sized, 

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

fn ne(&self, other: &(A, B, C, D, E, F, G)) -> 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

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

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

fn eq(&self, other: &extern "C" fn(A) -> 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

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

impl PartialEq<isize> for isize

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

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

impl PartialEq<u128> for u128

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

fn ne(&self, other: &u128) -> 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
    A: PartialEq<A>,
    B: PartialEq<B>,
    C: PartialEq<C>,
    D: PartialEq<D>,
    E: PartialEq<E>,
    F: PartialEq<F>,
    G: PartialEq<G>,
    H: PartialEq<H> + ?Sized, 

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

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

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

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

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

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

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

impl PartialEq<f64> for f64

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

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

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

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

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

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

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

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

fn ne(&self, other: &&'b mut [B]) -> 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

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

impl PartialEq<u16> for u16

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

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

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

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

impl PartialEq<String> for String

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<K, V> PartialEq<BTreeMap<K, V>> for BTreeMap<K, V> where
    K: PartialEq<K>,
    V: PartialEq<V>, 

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

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

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

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

impl PartialEq<FromUtf8Error> for FromUtf8Error

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl PartialEq<TryReserveError> for TryReserveError

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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<A, B> PartialEq<Vec<B>> for Vec<A> where
    A: PartialEq<B>, 

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

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

impl PartialEq<_Unwind_Action> for _Unwind_Action

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

impl PartialEq<_Unwind_Reason_Code> for _Unwind_Reason_Code

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

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

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

impl PartialEq<TryReserveError> for TryReserveError

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

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

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

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

impl PartialEq<DwAt> for DwAt

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

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

impl PartialEq<DwMacro> for DwMacro

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

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

impl<R> PartialEq<RegisterRule<R>> for RegisterRule<R> where
    R: Reader + PartialEq<R>, 

fn eq(&self, other: &RegisterRule<R>) -> bool

fn ne(&self, other: &RegisterRule<R>) -> bool

impl PartialEq<DwVis> for DwVis

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

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

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

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

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

impl<R> PartialEq<EhFrameHdr<R>> for EhFrameHdr<R> where
    R: Reader + PartialEq<R>, 

fn eq(&self, other: &EhFrameHdr<R>) -> bool

fn ne(&self, other: &EhFrameHdr<R>) -> bool

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

fn eq(&self, other: &Piece<R, Offset>) -> bool

fn ne(&self, other: &Piece<R, Offset>) -> bool

impl PartialEq<BigEndian> for BigEndian

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

impl PartialEq<Encoding> for Encoding

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

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

impl PartialEq<LineEncoding> for LineEncoding

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

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

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

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

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

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

fn eq(&self, other: &FrameDescriptionEntry<R, Offset>) -> bool

fn ne(&self, other: &FrameDescriptionEntry<R, Offset>) -> bool

impl<R> PartialEq<CallFrameInstruction<R>> for CallFrameInstruction<R> where
    R: Reader + PartialEq<R>, 

fn eq(&self, other: &CallFrameInstruction<R>) -> bool

fn ne(&self, other: &CallFrameInstruction<R>) -> bool

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

fn eq(&self, other: &CieOrFde<'bases, Section, R>) -> bool

fn ne(&self, other: &CieOrFde<'bases, Section, R>) -> bool

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

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

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

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

fn eq(&self, other: &FileEntry<R, Offset>) -> bool

fn ne(&self, other: &FileEntry<R, Offset>) -> bool

impl PartialEq<Range> for Range

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

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

impl PartialEq<DwUt> for DwUt

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

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

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

fn eq(&self, other: &UnitHeader<R, Offset>) -> bool

fn ne(&self, other: &UnitHeader<R, Offset>) -> bool

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

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

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

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

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

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

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

fn eq(&self, other: &AttributeValue<R, Offset>) -> bool

fn ne(&self, other: &AttributeValue<R, Offset>) -> bool

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

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

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

impl PartialEq<AttributeSpecification> for AttributeSpecification

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

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

impl<R> PartialEq<LocationListEntry<R>> for LocationListEntry<R> where
    R: Reader + PartialEq<R>, 

fn eq(&self, other: &LocationListEntry<R>) -> bool

fn ne(&self, other: &LocationListEntry<R>) -> bool

impl PartialEq<DwEhPe> for DwEhPe

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

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

impl<R> PartialEq<DebugFrame<R>> for DebugFrame<R> where
    R: Reader + PartialEq<R>, 

fn eq(&self, other: &DebugFrame<R>) -> bool

fn ne(&self, other: &DebugFrame<R>) -> bool

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

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

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

impl PartialEq<DwCfa> for DwCfa

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

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

impl PartialEq<DwAccess> for DwAccess

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

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

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

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

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

impl PartialEq<Value> for Value

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

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

impl PartialEq<DwAte> for DwAte

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

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

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

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

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

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

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

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

impl PartialEq<DwLang> for DwLang

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

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

impl PartialEq<Error> for Error

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

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

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

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

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

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

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

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

impl PartialEq<DwLne> for DwLne

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

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

impl PartialEq<DwLns> for DwLns

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

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

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

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

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

impl PartialEq<SectionBaseAddresses> for SectionBaseAddresses

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

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

impl PartialEq<DebugTypeSignature> for DebugTypeSignature

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

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

impl PartialEq<DwDs> for DwDs

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

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

impl PartialEq<DwCc> for DwCc

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

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

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

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

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

impl PartialEq<DwIdx> for DwIdx

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

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

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

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

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

impl PartialEq<Pointer> for Pointer

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

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

impl PartialEq<DwForm> for DwForm

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

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

impl<R> PartialEq<Expression<R>> for Expression<R> where
    R: Reader + PartialEq<R>, 

fn eq(&self, other: &Expression<R>) -> bool

fn ne(&self, other: &Expression<R>) -> bool

impl PartialEq<DwVirtuality> for DwVirtuality

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

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

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

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

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

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

fn eq(&self, other: &IncompleteLineProgram<R, Offset>) -> bool

fn ne(&self, other: &IncompleteLineProgram<R, Offset>) -> bool

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

fn eq(&self, other: &CompleteLineProgram<R, Offset>) -> bool

fn ne(&self, other: &CompleteLineProgram<R, Offset>) -> bool

impl PartialEq<DwEnd> for DwEnd

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

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

impl PartialEq<ReaderOffsetId> for ReaderOffsetId

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

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

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

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

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

impl PartialEq<LineRow> for LineRow

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

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

impl PartialEq<Abbreviation> for Abbreviation

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

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

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

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

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

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

fn eq(&self, other: &LineInstruction<R, Offset>) -> bool

fn ne(&self, other: &LineInstruction<R, Offset>) -> bool

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

fn eq(&self, other: &PartialFrameDescriptionEntry<'bases, Section, R>) -> bool

fn ne(&self, other: &PartialFrameDescriptionEntry<'bases, Section, R>) -> bool

impl PartialEq<DwDsc> for DwDsc

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

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

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

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

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

impl<R> PartialEq<Attribute<R>> for Attribute<R> where
    R: Reader + PartialEq<R>, 

fn eq(&self, other: &Attribute<R>) -> bool

fn ne(&self, other: &Attribute<R>) -> bool

impl PartialEq<DwOrd> for DwOrd

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

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

impl PartialEq<Format> for Format

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

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

fn eq(&self, other: &EhFrame<R>) -> bool

fn ne(&self, other: &EhFrame<R>) -> bool

impl PartialEq<LittleEndian> for LittleEndian

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

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

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

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

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

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

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

impl PartialEq<ValueType> for ValueType

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

impl PartialEq<FileEntryFormat> for FileEntryFormat

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

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

impl PartialEq<DwId> for DwId

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

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

impl PartialEq<DwAddr> for DwAddr

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

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

impl PartialEq<DwInl> for DwInl

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

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

impl PartialEq<RunTimeEndian> for RunTimeEndian

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

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

fn eq(&self, other: &UnwindContext<R>) -> bool

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

fn eq(&self, other: &EvaluationResult<R>) -> bool

fn ne(&self, other: &EvaluationResult<R>) -> bool

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

fn eq(&self, other: &TypeUnitHeader<R, Offset>) -> bool

fn ne(&self, other: &TypeUnitHeader<R, Offset>) -> bool

impl PartialEq<DwDefaulted> for DwDefaulted

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

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

impl PartialEq<DwRle> for DwRle

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

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

impl PartialEq<DwLle> for DwLle

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

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

impl PartialEq<DwTag> for DwTag

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

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

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

fn eq(&self, other: &EndianSlice<'input, Endian>) -> bool

fn ne(&self, other: &EndianSlice<'input, Endian>) -> bool

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

fn eq(&self, other: &Location<R, Offset>) -> bool

fn ne(&self, other: &Location<R, Offset>) -> bool

impl PartialEq<DwChildren> for DwChildren

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

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

impl PartialEq<BaseAddresses> for BaseAddresses

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

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

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

fn eq(&self, other: &CfaRule<R>) -> bool

fn ne(&self, other: &CfaRule<R>) -> bool

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

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

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

impl PartialEq<Register> for Register

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

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

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

fn eq(&self, other: &CommonInformationEntry<R, Offset>) -> bool

fn ne(&self, other: &CommonInformationEntry<R, Offset>) -> bool

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

fn eq(&self, other: &LineProgramHeader<R, Offset>) -> bool

fn ne(&self, other: &LineProgramHeader<R, Offset>) -> bool

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

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

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

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

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

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

impl PartialEq<Augmentation> for Augmentation

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

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

impl<R> PartialEq<UnwindTableRow<R>> for UnwindTableRow<R> where
    R: Reader + PartialEq<R>, 

fn eq(&self, other: &UnwindTableRow<R>) -> bool

fn ne(&self, other: &UnwindTableRow<R>) -> bool

impl PartialEq<ColumnType> for ColumnType

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

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

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

fn eq(&self, other: &Operation<R, Offset>) -> bool

fn ne(&self, other: &Operation<R, Offset>) -> bool

impl PartialEq<DwOp> for DwOp

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

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

impl PartialEq<SectionId> for SectionId

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

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

fn eq(&self, other: &CompilationUnitHeader<R, Offset>) -> bool

fn ne(&self, other: &CompilationUnitHeader<R, Offset>) -> bool

impl PartialEq<DwLnct> for DwLnct

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

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

impl PartialEq<Error> for Error

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

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

impl PartialEq<RelocationEncoding> for RelocationEncoding

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

impl PartialEq<SectionFlags> for SectionFlags

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

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

impl PartialEq<LittleEndian> for LittleEndian

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

impl PartialEq<RelocationTarget> for RelocationTarget

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

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

impl PartialEq<BigEndian> for BigEndian

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

impl<E> PartialEq<I32<E>> for I32<E> where
    E: Endian + PartialEq<E>, 

fn eq(&self, other: &I32<E>) -> bool

fn ne(&self, other: &I32<E>) -> bool

impl PartialEq<SymbolKind> for SymbolKind

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

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

fn eq(&self, other: &I32Bytes<E>) -> bool

fn ne(&self, other: &I32Bytes<E>) -> bool

impl PartialEq<SymbolScope> for SymbolScope

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

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

fn eq(&self, other: &U64Bytes<E>) -> bool

fn ne(&self, other: &U64Bytes<E>) -> bool

impl<E> PartialEq<U16<E>> for U16<E> where
    E: Endian + PartialEq<E>, 

fn eq(&self, other: &U16<E>) -> bool

fn ne(&self, other: &U16<E>) -> bool

impl PartialEq<Architecture> for Architecture

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

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

fn eq(&self, other: &U32Bytes<E>) -> bool

fn ne(&self, other: &U32Bytes<E>) -> bool

impl PartialEq<AddressSize> for AddressSize

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

impl PartialEq<BinaryFormat> for BinaryFormat

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

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

fn eq(&self, other: &U16Bytes<E>) -> bool

fn ne(&self, other: &U16Bytes<E>) -> bool

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

fn eq(&self, other: &CompressedData<'data>) -> bool

fn ne(&self, other: &CompressedData<'data>) -> bool

impl PartialEq<FileFlags> for FileFlags

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

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

impl PartialEq<CompressionFormat> for CompressionFormat

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

impl PartialEq<SymbolIndex> for SymbolIndex

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

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

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

fn eq(&self, other: &I64Bytes<E>) -> bool

fn ne(&self, other: &I64Bytes<E>) -> bool

impl PartialEq<RelocationKind> for RelocationKind

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

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

impl PartialEq<SectionIndex> for SectionIndex

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

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

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

fn eq(&self, other: &I16Bytes<E>) -> bool

fn ne(&self, other: &I16Bytes<E>) -> bool

impl PartialEq<Endianness> for Endianness

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

impl PartialEq<SectionKind> for SectionKind

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

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

fn eq(&self, other: &SymbolFlags<Section>) -> bool

fn ne(&self, other: &SymbolFlags<Section>) -> bool

impl<E> PartialEq<I64<E>> for I64<E> where
    E: Endian + PartialEq<E>, 

fn eq(&self, other: &I64<E>) -> bool

fn ne(&self, other: &I64<E>) -> bool

impl<E> PartialEq<U32<E>> for U32<E> where
    E: Endian + PartialEq<E>, 

fn eq(&self, other: &U32<E>) -> bool

fn ne(&self, other: &U32<E>) -> bool

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

fn eq(&self, other: &Bytes<'data>) -> bool

fn ne(&self, other: &Bytes<'data>) -> bool

impl<E> PartialEq<I16<E>> for I16<E> where
    E: Endian + PartialEq<E>, 

fn eq(&self, other: &I16<E>) -> bool

fn ne(&self, other: &I16<E>) -> bool

impl<E> PartialEq<U64<E>> for U64<E> where
    E: Endian + PartialEq<E>, 

fn eq(&self, other: &U64<E>) -> bool

fn ne(&self, other: &U64<E>) -> bool

impl PartialEq<SymbolSection> for SymbolSection

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

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

impl PartialEq<MZError> for MZError

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

impl PartialEq<MZFlush> for MZFlush

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

impl PartialEq<TDEFLStatus> for TDEFLStatus

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

impl PartialEq<MZStatus> for MZStatus

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

impl PartialEq<TDEFLFlush> for TDEFLFlush

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

impl PartialEq<CompressionStrategy> for CompressionStrategy

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

impl PartialEq<CompressionLevel> for CompressionLevel

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

impl PartialEq<StreamResult> for StreamResult

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

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

impl PartialEq<TINFLStatus> for TINFLStatus

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

impl PartialEq<DataFormat> for DataFormat

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

impl PartialEq<Error> for Error

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

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

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

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

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

Loading content...

Implementors

impl PartialEq<Ordering> for wasmer_types::entity::__core::cmp::Ordering

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

impl PartialEq<Infallible> for Infallible

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

impl PartialEq<FpCategory> for FpCategory

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

impl PartialEq<IntErrorKind> for IntErrorKind

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

impl PartialEq<SearchStep> for SearchStep

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

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

impl PartialEq<Ordering> for wasmer_types::entity::__core::sync::atomic::Ordering

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

impl PartialEq<ExportIndex> for ExportIndex

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

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

impl PartialEq<ExternRef> for ExternRef

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

impl PartialEq<ExternType> for ExternType

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

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

impl PartialEq<ImportIndex> for ImportIndex

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

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

impl PartialEq<Mutability> for Mutability

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

impl PartialEq<Type> for Type

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

impl PartialEq<AllocErr> for AllocErr

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

impl PartialEq<Layout> for Layout

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

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

impl PartialEq<LayoutErr> for LayoutErr

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

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

impl PartialEq<TypeId> for TypeId

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

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

impl PartialEq<CpuidResult> for CpuidResult

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

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

impl PartialEq<CharTryFromError> for CharTryFromError

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

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

impl PartialEq<DecodeUtf16Error> for DecodeUtf16Error

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

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

impl PartialEq<ParseCharError> for ParseCharError

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

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

impl PartialEq<Error> for wasmer_types::entity::__core::fmt::Error

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

impl PartialEq<PhantomPinned> for PhantomPinned

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

impl PartialEq<NonZeroI8> for NonZeroI8

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

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

impl PartialEq<NonZeroI16> for NonZeroI16

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

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

impl PartialEq<NonZeroI32> for NonZeroI32

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

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

impl PartialEq<NonZeroI64> for NonZeroI64

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

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

impl PartialEq<NonZeroI128> for NonZeroI128

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

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

impl PartialEq<NonZeroIsize> for NonZeroIsize

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

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

impl PartialEq<NonZeroU8> for NonZeroU8

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

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

impl PartialEq<NonZeroU16> for NonZeroU16

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

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

impl PartialEq<NonZeroU32> for NonZeroU32

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

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

impl PartialEq<NonZeroU64> for NonZeroU64

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

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

impl PartialEq<NonZeroU128> for NonZeroU128

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

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

impl PartialEq<NonZeroUsize> for NonZeroUsize

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

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

impl PartialEq<ParseFloatError> for ParseFloatError

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

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

impl PartialEq<ParseIntError> for ParseIntError

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

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

impl PartialEq<TryFromIntError> for TryFromIntError

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

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

impl PartialEq<RangeFull> for RangeFull

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

impl PartialEq<NoneError> for NoneError

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

impl PartialEq<ParseBoolError> for ParseBoolError

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

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

impl PartialEq<Utf8Error> for Utf8Error

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

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

impl PartialEq<RawWaker> for RawWaker

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

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

impl PartialEq<RawWakerVTable> for RawWakerVTable

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

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

impl PartialEq<Duration> for Duration

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

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

impl PartialEq<Bytes> for wasmer_types::Bytes

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

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

impl PartialEq<CustomSectionIndex> for CustomSectionIndex

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

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

impl PartialEq<DataIndex> for DataIndex

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

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

impl PartialEq<ElemIndex> for ElemIndex

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

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

impl PartialEq<Features> for Features

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

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

impl PartialEq<FunctionIndex> for FunctionIndex

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

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

impl PartialEq<FunctionType> for FunctionType

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

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

impl PartialEq<GlobalIndex> for GlobalIndex

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

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

impl PartialEq<GlobalType> for GlobalType

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

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

impl PartialEq<LocalFunctionIndex> for LocalFunctionIndex

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

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

impl PartialEq<LocalGlobalIndex> for LocalGlobalIndex

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

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

impl PartialEq<LocalMemoryIndex> for LocalMemoryIndex

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

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

impl PartialEq<LocalTableIndex> for LocalTableIndex

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

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

impl PartialEq<MemoryIndex> for MemoryIndex

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

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

impl PartialEq<MemoryType> for MemoryType

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

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

impl PartialEq<Pages> for Pages

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

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

impl PartialEq<SignatureIndex> for SignatureIndex

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

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

impl PartialEq<TableIndex> for TableIndex

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

fn ne(&self, other: &TableIndex) -> bool

impl PartialEq<TableType> for TableType

fn eq(&self, other: &TableType) -> bool

fn ne(&self, other: &TableType) -> bool

impl PartialEq<V128> for V128

fn eq(&self, other: &V128) -> bool

fn ne(&self, other: &V128) -> bool

impl<'a> PartialEq<Location<'a>> for wasmer_types::entity::__core::panic::Location<'a>

fn eq(&self, other: &Location<'a>) -> bool

fn ne(&self, other: &Location<'a>) -> bool

impl<'a> PartialEq<Utf8LossyChunk<'a>> for Utf8LossyChunk<'a>

fn eq(&self, other: &Utf8LossyChunk<'a>) -> bool

fn ne(&self, other: &Utf8LossyChunk<'a>) -> bool

impl<C, B> PartialEq<ControlFlow<C, B>> for ControlFlow<C, B> where
    B: PartialEq<B>,
    C: PartialEq<C>, 

fn eq(&self, other: &ControlFlow<C, B>) -> bool

fn ne(&self, other: &ControlFlow<C, B>) -> bool

impl<H> PartialEq<BuildHasherDefault<H>> for BuildHasherDefault<H>

fn eq(&self, _other: &BuildHasherDefault<H>) -> bool

impl<Idx> PartialEq<Range<Idx>> for wasmer_types::entity::__core::ops::Range<Idx> where
    Idx: PartialEq<Idx>, 

fn eq(&self, other: &Range<Idx>) -> bool

fn ne(&self, other: &Range<Idx>) -> bool

impl<Idx> PartialEq<RangeFrom<Idx>> for RangeFrom<Idx> where
    Idx: PartialEq<Idx>, 

fn eq(&self, other: &RangeFrom<Idx>) -> bool

fn ne(&self, other: &RangeFrom<Idx>) -> bool

impl<Idx> PartialEq<RangeInclusive<Idx>> for RangeInclusive<Idx> where
    Idx: PartialEq<Idx>, 

fn eq(&self, other: &RangeInclusive<Idx>) -> bool

fn ne(&self, other: &RangeInclusive<Idx>) -> bool

impl<Idx> PartialEq<RangeTo<Idx>> for RangeTo<Idx> where
    Idx: PartialEq<Idx>, 

fn eq(&self, other: &RangeTo<Idx>) -> bool

fn ne(&self, other: &RangeTo<Idx>) -> bool

impl<Idx> PartialEq<RangeToInclusive<Idx>> for RangeToInclusive<Idx> where
    Idx: PartialEq<Idx>, 

fn eq(&self, other: &RangeToInclusive<Idx>) -> bool

fn ne(&self, other: &RangeToInclusive<Idx>) -> bool

impl<K, V> PartialEq<PrimaryMap<K, V>> for PrimaryMap<K, V> where
    K: PartialEq<K> + EntityRef,
    V: PartialEq<V>, 

fn eq(&self, other: &PrimaryMap<K, V>) -> bool

fn ne(&self, other: &PrimaryMap<K, V>) -> bool

impl<K, V> PartialEq<SecondaryMap<K, V>> for SecondaryMap<K, V> where
    K: EntityRef,
    V: Clone + PartialEq<V>, 

fn eq(&self, other: &SecondaryMap<K, V>) -> bool

impl<P, Q> PartialEq<Pin<Q>> for Pin<P> where
    P: Deref,
    Q: Deref,
    <P as Deref>::Target: PartialEq<<Q as Deref>::Target>, 

fn eq(&self, other: &Pin<Q>) -> bool

fn ne(&self, other: &Pin<Q>) -> bool

impl<T> PartialEq<Bound<T>> for Bound<T> where
    T: PartialEq<T>, 

fn eq(&self, other: &Bound<T>) -> bool

fn ne(&self, other: &Bound<T>) -> bool

impl<T> PartialEq<Option<T>> for Option<T> where
    T: PartialEq<T>, 

fn eq(&self, other: &Option<T>) -> bool

fn ne(&self, other: &Option<T>) -> bool

impl<T> PartialEq<Poll<T>> for Poll<T> where
    T: PartialEq<T>, 

fn eq(&self, other: &Poll<T>) -> bool

fn ne(&self, other: &Poll<T>) -> bool

impl<T> PartialEq<Cell<T>> for Cell<T> where
    T: PartialEq<T> + Copy, 

fn eq(&self, other: &Cell<T>) -> bool

impl<T> PartialEq<RefCell<T>> for RefCell<T> where
    T: PartialEq<T> + ?Sized, 

fn eq(&self, other: &RefCell<T>) -> bool

Panics

Panics if the value in either RefCell is currently borrowed.

impl<T> PartialEq<Reverse<T>> for Reverse<T> where
    T: PartialEq<T>, 

fn eq(&self, other: &Reverse<T>) -> bool

fn ne(&self, other: &Reverse<T>) -> bool

impl<T> PartialEq<OnceCell<T>> for OnceCell<T> where
    T: PartialEq<T>, 

fn eq(&self, other: &OnceCell<T>) -> bool

impl<T> PartialEq<PhantomData<T>> for PhantomData<T> where
    T: ?Sized, 

fn eq(&self, _other: &PhantomData<T>) -> bool

impl<T> PartialEq<Discriminant<T>> for Discriminant<T>

fn eq(&self, rhs: &Discriminant<T>) -> bool

impl<T> PartialEq<ManuallyDrop<T>> for ManuallyDrop<T> where
    T: PartialEq<T> + ?Sized, 

fn eq(&self, other: &ManuallyDrop<T>) -> bool

fn ne(&self, other: &ManuallyDrop<T>) -> bool

impl<T> PartialEq<Wrapping<T>> for Wrapping<T> where
    T: PartialEq<T>, 

fn eq(&self, other: &Wrapping<T>) -> bool

fn ne(&self, other: &Wrapping<T>) -> bool

impl<T> PartialEq<NonNull<T>> for NonNull<T> where
    T: ?Sized, 

fn eq(&self, other: &NonNull<T>) -> bool

impl<T> PartialEq<PackedOption<T>> for PackedOption<T> where
    T: ReservedValue + PartialEq<T>, 

fn eq(&self, other: &PackedOption<T>) -> bool

fn ne(&self, other: &PackedOption<T>) -> bool

impl<T, E> PartialEq<Result<T, E>> for Result<T, E> where
    E: PartialEq<E>,
    T: PartialEq<T>, 

fn eq(&self, other: &Result<T, E>) -> bool

fn ne(&self, other: &Result<T, E>) -> bool

impl<T: PartialEq> PartialEq<Value<T>> for wasmer_types::Value<T>

fn eq(&self, other: &Value<T>) -> bool

fn ne(&self, other: &Value<T>) -> bool

impl<T: PartialEq> PartialEq<ExportType<T>> for ExportType<T>

fn eq(&self, other: &ExportType<T>) -> bool

fn ne(&self, other: &ExportType<T>) -> bool

impl<T: PartialEq> PartialEq<ImportType<T>> for ImportType<T>

fn eq(&self, other: &ImportType<T>) -> bool

fn ne(&self, other: &ImportType<T>) -> bool

impl<Y, R> PartialEq<GeneratorState<Y, R>> for GeneratorState<Y, R> where
    R: PartialEq<R>,
    Y: PartialEq<Y>, 

fn eq(&self, other: &GeneratorState<Y, R>) -> bool

fn ne(&self, other: &GeneratorState<Y, R>) -> bool

Loading content...