Trait wasmtime_wiggle::bitflags::_core::cmp::PartialEq

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, c of type A, B, C):

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

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

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

Derivable

This trait can be used with #[derive]. When derived on structs, two instances are equal if all fields are equal, and not equal if any fields are not equal. When derived on enums, each variant is equal to itself and not equal to the other variants.

How can I implement PartialEq?

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

Provided methods

#[must_use]

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

This method tests for !=.

Implementations on Foreign Types

impl PartialEq<str> for OsStr

pub fn eq(&self, other: &str) -> 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 Cow<'a, OsStr>

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

impl PartialEq<OsString> for str

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

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

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

impl PartialEq<FileType> for FileType

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

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

impl PartialEq<Ipv4Addr> for Ipv4Addr

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

impl PartialEq<FromVecWithNulError> for FromVecWithNulError

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

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

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

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

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

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

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

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

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

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

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

pub fn eq(&self, other: &Cow<'a, OsStr>) -> 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<&'a Path> for OsStr

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

impl PartialEq<BacktraceStatus> for BacktraceStatus

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

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

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

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

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

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

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

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

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

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

impl PartialEq<Output> for Output

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

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

impl PartialEq<SocketAddrV4> for SocketAddrV4

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

impl PartialEq<AddrParseError> for AddrParseError

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

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

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

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

impl PartialEq<ErrorKind> for ErrorKind

pub fn eq(&self, other: &ErrorKind) -> 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<PathBuf> for OsString

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

impl PartialEq<SocketAddr> for SocketAddr

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

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

impl PartialEq<str> for OsString

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

impl PartialEq<Path> for Path

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

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

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

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

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

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

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

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

pub fn eq(&self, other: &SyncOnceCell<T>) -> 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 PartialEq<RecvError> for RecvError

pub fn eq(&self, other: &RecvError) -> 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<Cow<'a, Path>> for &'b Path

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

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

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

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

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

impl PartialEq<Instant> for Instant

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

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

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

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

impl PartialEq<ThreadId> for ThreadId

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

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

impl PartialEq<AccessError> for AccessError

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

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

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

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

impl PartialEq<Shutdown> for Shutdown

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

impl PartialEq<UCred> for UCred

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

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

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

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

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

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

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

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

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

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

impl PartialEq<Ipv6Addr> for Ipv6Addr

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

impl PartialEq<SystemTime> for SystemTime

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

pub fn ne(&self, other: &SystemTime) -> 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<PathBuf> for PathBuf

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

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

pub fn eq(&self, other: &OsStr) -> 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<'a, 'b> PartialEq<Cow<'a, OsStr>> for OsStr

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

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

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

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

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

impl PartialEq<SocketAddrV6> for SocketAddrV6

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

impl PartialEq<IpAddr> for Ipv4Addr

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

impl PartialEq<CString> for CString

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

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

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

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

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

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

impl PartialEq<IpAddr> for Ipv6Addr

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

impl PartialEq<IpAddr> for IpAddr

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

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

impl PartialEq<NulError> for NulError

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

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

impl PartialEq<ExitStatus> for ExitStatus

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

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

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

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

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

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

impl PartialEq<OsStr> for str

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

impl PartialEq<Ipv6Addr> for IpAddr

pub fn eq(&self, other: &Ipv6Addr) -> 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, 'b> PartialEq<Cow<'a, OsStr>> for &'b OsStr

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

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

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

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

pub fn eq(&self, other: &PathBuf) -> 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<'a, 'b> PartialEq<&'b OsStr> for Cow<'a, Path>

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

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

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

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

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

impl PartialEq<ExitStatusError> for ExitStatusError

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

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

impl PartialEq<Ipv6MulticastScope> for Ipv6MulticastScope

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

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

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

impl PartialEq<TryRecvError> for TryRecvError

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

impl PartialEq<OsStr> for OsStr

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

impl PartialEq<SeekFrom> for SeekFrom

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

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

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

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

impl PartialEq<Ipv4Addr> for IpAddr

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

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

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

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

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

impl PartialEq<IntoStringError> for IntoStringError

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

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

impl PartialEq<Permissions> for Permissions

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

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

impl PartialEq<VarError> for VarError

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

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

impl PartialEq<RecvTimeoutError> for RecvTimeoutError

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

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

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 OsString

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

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

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

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

pub fn eq(&self, other: &&'a OsStr) -> 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<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<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<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<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, 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<Ret, A, B> PartialEq<fn(A, B) -> Ret> for fn(A, B) -> Ret

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

impl PartialEq<i32> for i32

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

pub fn ne(&self, other: &i32) -> 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 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, 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<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<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, 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, 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<Ret, A> PartialEq<unsafe fn(A) -> Ret> for unsafe fn(A) -> Ret

pub fn eq(&self, other: &unsafe fn(A) -> Ret) -> 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<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> PartialEq<unsafe fn() -> Ret> for unsafe fn() -> Ret

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

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

pub fn eq(&self, other: &fn(A) -> 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 PartialEq<i16> for i16

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

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

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

pub fn ne(&self, _other: &()) -> 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> 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, 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 PartialEq<!> for !

pub fn eq(&self, &!) -> 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> PartialEq<extern "C" fn(A, ...) -> Ret> for extern "C" fn(A, ...) -> Ret

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

impl PartialEq<i128> for i128

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

pub fn ne(&self, other: &i128) -> 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<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> 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<T> PartialEq<*const T> for *const T where
    T: ?Sized, 

pub fn eq(&self, other: &*const T) -> 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, 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, 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<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> PartialEq<unsafe extern "C" fn() -> Ret> for unsafe extern "C" fn() -> Ret

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

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

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

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<'_, '_, 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<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, 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<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 PartialEq<f64> for f64

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

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

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> 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<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, 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<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<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> 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<'_, 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<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<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, C, D, E, F> PartialEq<(A, B, C, D, E, F)> for (A, B, C, D, E, F) where
    C: PartialEq<C>,
    E: PartialEq<E>,
    A: PartialEq<A>,
    B: PartialEq<B>,
    F: PartialEq<F> + ?Sized,
    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<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<'_, '_, 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<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>,
    E: PartialEq<E>,
    A: PartialEq<A>,
    B: PartialEq<B>,
    F: PartialEq<F>,
    G: PartialEq<G> + ?Sized,
    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> 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<char> for char

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

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

impl PartialEq<isize> for isize

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

pub fn ne(&self, other: &isize) -> 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> 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> PartialEq<fn() -> Ret> for fn() -> Ret

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

impl<A, B, C, D, E> PartialEq<(A, B, C, D, E)> for (A, B, C, D, E) where
    C: PartialEq<C>,
    E: PartialEq<E> + ?Sized,
    A: PartialEq<A>,
    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<u32> for u32

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

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

impl PartialEq<u128> for u128

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

pub fn ne(&self, other: &u128) -> 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> PartialEq<extern "C" fn() -> Ret> for extern "C" fn() -> Ret

pub fn eq(&self, other: &extern "C" fn() -> 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<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<'_, 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<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 PartialEq<usize> for usize

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

pub fn ne(&self, other: &usize) -> 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<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> 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<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<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, 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, 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> 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<T> PartialEq<*mut T> for *mut T where
    T: ?Sized, 

pub fn eq(&self, other: &*mut T) -> 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, 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 PartialEq<f32> for f32

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

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

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

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

impl PartialEq<u64> for u64

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

pub fn ne(&self, other: &u64) -> 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<'_, 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<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<str> for str

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

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

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

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

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, 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, 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<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 PartialEq<TryReserveError> for TryReserveError

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

pub fn ne(&self, other: &TryReserveError) -> 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<'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<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, 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<[U]> for Vec<T, A> where
    T: PartialEq<U>,
    A: Allocator, 

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

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

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

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

impl PartialEq<FromUtf8Error> for FromUtf8Error

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

pub fn ne(&self, other: &FromUtf8Error) -> 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<&'_ mut [B]> for VecDeque<A> where
    A: PartialEq<B>, 

pub fn eq(&self, other: &&mut [B]) -> 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 PartialEq<String> for String

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

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

impl<T, U, A, const N: usize> PartialEq<[U; N]> for Vec<T, A> where
    T: PartialEq<U>,
    A: Allocator, 

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

pub fn ne(&self, other: &[U; N]) -> 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<'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<String> for Cow<'a, str>

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

pub fn ne(&self, other: &String) -> 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<'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<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, 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<'_, 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<'_, 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<'_, T, U, A> PartialEq<&'_ mut [U]> for Vec<T, A> where
    T: PartialEq<U>,
    A: Allocator, 

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

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

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

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

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

impl<T, U, A> PartialEq<Vec<U, A>> for Vec<T, A> 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<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<'_, T, U, A> PartialEq<&'_ [U]> for Vec<T, A> where
    T: PartialEq<U>,
    A: Allocator, 

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

pub fn ne(&self, other: &&[U]) -> 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<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<'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, 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<'_, '_, 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<A, B, const N: usize> PartialEq<[B; N]> for VecDeque<A> where
    A: PartialEq<B>, 

pub fn eq(&self, other: &[B; N]) -> 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, const N: usize> PartialEq<&'_ [U; N]> for Vec<T, A> where
    T: PartialEq<U>,
    A: Allocator, 

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

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

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

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

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

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<Id> for &'_ str

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

impl<'_> PartialEq<Index<'_>> for Index<'_>

pub fn eq(&self, other: &Index<'_>) -> bool

impl<'a> PartialEq<NameAnnotation<'a>> for NameAnnotation<'a>

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

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

impl<'a> PartialEq<FloatVal<'a>> for FloatVal<'a>

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

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

impl<'a> PartialEq<Token<'a>> for Token<'a>

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

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

impl PartialEq<LexError> for LexError

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

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

impl<'a> PartialEq<Float<'a>> for Float<'a>

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

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

impl PartialEq<Span> for Span

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

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

impl<'a> PartialEq<WasmString<'a>> for WasmString<'a>

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

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

impl PartialEq<SignToken> for SignToken

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

impl<'a> PartialEq<Id<'a>> for Id<'a>

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

impl<'a> PartialEq<Integer<'a>> for Integer<'a>

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

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

impl PartialEq<LevelFilter> for Level

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

impl PartialEq<ParseLevelError> for ParseLevelError

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

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

impl PartialEq<LevelFilter> for LevelFilter

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

impl PartialEq<Level> for Level

pub fn eq(&self, other: &Level) -> 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<ValType> for ValType

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

impl PartialEq<OptLevel> for OptLevel

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

impl PartialEq<Mutability> for Mutability

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

impl PartialEq<Limits> for Limits

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

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

impl PartialEq<PoolingAllocationStrategy> for PoolingAllocationStrategy

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

impl PartialEq<GlobalType> for GlobalType

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

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

impl PartialEq<FuncType> for FuncType

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

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

impl PartialEq<TableType> for TableType

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

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

impl PartialEq<MemoryType> for MemoryType

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

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

impl PartialEq<TrapCode> for TrapCode

pub fn eq(&self, other: &TrapCode) -> 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<FunctionAddressMap> for FunctionAddressMap

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

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

impl PartialEq<CompiledFunction> for CompiledFunction

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

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

impl PartialEq<RelocationTarget> for RelocationTarget

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

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

impl PartialEq<TrapInformation> for TrapInformation

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

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

impl PartialEq<StackMapInformation> for StackMapInformation

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

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

impl PartialEq<Relocation> for Relocation

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

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

impl PartialEq<InstructionAddressMap> for InstructionAddressMap

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

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

impl PartialEq<UnwindInfo> for UnwindInfo

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

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

impl PartialEq<LabelValueLoc> for LabelValueLoc

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

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

impl PartialEq<Heap> for Heap

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

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

impl PartialEq<BlockPredecessor> for BlockPredecessor

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

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

impl PartialEq<ExpandedProgramPoint> for ExpandedProgramPoint

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

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

impl PartialEq<RelocDistance> for RelocDistance

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

impl PartialEq<ProgramPoint> for ProgramPoint

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

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

impl PartialEq<RegClassIndex> for RegClassIndex

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

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

impl PartialEq<AbiParam> for AbiParam

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

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

impl PartialEq<ExternalName> for ExternalName

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

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

impl PartialEq<ConstantData> for ConstantData

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

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

impl PartialEq<Constant> for Constant

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

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

impl PartialEq<StackBaseMask> for StackBaseMask

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

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

impl PartialEq<AnyEntity> for AnyEntity

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

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

impl PartialEq<UnwindInst> for UnwindInst

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

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

impl PartialEq<InstIsSafepoint> for InstIsSafepoint

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

impl PartialEq<DataValue> for DataValue

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

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

impl PartialEq<SetError> for SetError

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

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

impl PartialEq<VCodeConstant> for VCodeConstant

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

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

impl PartialEq<Loop> for Loop

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

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

impl PartialEq<LibcallCallConv> for LibcallCallConv

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

impl PartialEq<CodegenError> for CodegenError

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

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

impl PartialEq<CodeInfo> for CodeInfo

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

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

impl PartialEq<FuncRef> for FuncRef

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

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

impl PartialEq<ValueTypeSet> for ValueTypeSet

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

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

impl PartialEq<Offset32> for Offset32

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

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

impl PartialEq<Opcode> for Opcode

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

impl PartialEq<Immediate> for Immediate

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

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

impl PartialEq<Regalloc> for Regalloc

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

impl PartialEq<CursorPosition> for CursorPosition

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

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

impl PartialEq<StackSlots> for StackSlots

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

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

impl PartialEq<AtomicRmwOp> for AtomicRmwOp

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

impl PartialEq<V128Imm> for V128Imm

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

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

impl PartialEq<MemFlags> for MemFlags

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

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

impl PartialEq<StackSlot> for StackSlot

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

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

impl PartialEq<Uimm32> for Uimm32

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

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

impl PartialEq<UnwindInfo> for UnwindInfo

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

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

impl PartialEq<Ieee64> for Ieee64

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

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

impl PartialEq<JumpTable> for JumpTable

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

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

impl PartialEq<Table> for Table

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

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

impl PartialEq<Reloc> for Reloc

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

impl PartialEq<CallConv> for CallConv

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

impl PartialEq<VerifierErrors> for VerifierErrors

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

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

impl PartialEq<DataValueCastFailure> for DataValueCastFailure

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

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

impl PartialEq<StackLayoutInfo> for StackLayoutInfo

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

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

impl PartialEq<ArgumentExtension> for ArgumentExtension

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

impl PartialEq<StackSlotKind> for StackSlotKind

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

impl PartialEq<ValueLocRange> for ValueLocRange

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

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

impl PartialEq<ValueLabel> for ValueLabel

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

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

impl PartialEq<AtomicRmwOp> for AtomicRmwOp

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

impl PartialEq<InstructionFormat> for InstructionFormat

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

impl<Reg> PartialEq<UnwindCode<Reg>> for UnwindCode<Reg> where
    Reg: PartialEq<Reg>, 

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

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

impl PartialEq<Type> for Type

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

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

impl PartialEq<Block> for Block

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

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

impl PartialEq<LoweredBlock> for LoweredBlock

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

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

impl PartialEq<StackMap> for StackMap

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

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

impl PartialEq<Inst> for Inst

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

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

impl PartialEq<ArgumentPurpose> for ArgumentPurpose

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

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

impl PartialEq<ConstraintKind> for ConstraintKind

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

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

impl<'a> PartialEq<MachTerminator<'a>> for MachTerminator<'a>

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

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

impl PartialEq<UnwindInfoKind> for UnwindInfoKind

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

impl PartialEq<MachLabel> for MachLabel

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

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

impl PartialEq<UnwindInfo> for UnwindInfo

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

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

impl PartialEq<VerifierError> for VerifierError

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

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

impl PartialEq<LookupError> for LookupError

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

impl PartialEq<StackBase> for StackBase

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

impl PartialEq<OperandConstraint> for OperandConstraint

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

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

impl<Reg> PartialEq<UnwindInfo<Reg>> for UnwindInfo<Reg> where
    Reg: PartialEq<Reg>, 

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

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

impl PartialEq<Imm64> for Imm64

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

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

impl PartialEq<Endianness> for Endianness

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

impl PartialEq<Encoding> for Encoding

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

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

impl PartialEq<StackSlotData> for StackSlotData

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

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

impl<R> PartialEq<ValueRegs<R>> for ValueRegs<R> where
    R: PartialEq<R> + Clone + Copy + Debug + Eq + InvalidSentinel, 

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

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

impl PartialEq<ABIArgSlot> for ABIArgSlot

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

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

impl PartialEq<RecipeConstraints> for RecipeConstraints

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

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

impl PartialEq<LibCall> for LibCall

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

impl PartialEq<SigRef> for SigRef

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

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

impl PartialEq<RegisterMappingError> for RegisterMappingError

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

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

impl PartialEq<Ieee32> for Ieee32

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

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

impl PartialEq<SettingKind> for SettingKind

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

impl PartialEq<Value> for Value

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

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

impl PartialEq<TlsModel> for TlsModel

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

impl PartialEq<ValueDef> for ValueDef

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

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

impl PartialEq<ArgumentLoc> for ArgumentLoc

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

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

impl PartialEq<ResolvedConstraint> for ResolvedConstraint

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

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

impl PartialEq<ArgsOrRets> for ArgsOrRets

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

impl PartialEq<RegClassData> for RegClassData

Within an ISA, register classes are uniquely identified by their index.

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

impl PartialEq<OptLevel> for OptLevel

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

impl PartialEq<TrapCode> for TrapCode

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

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

impl PartialEq<Signature> for Signature

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

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

impl PartialEq<GlobalValue> for GlobalValue

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

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

impl PartialEq<SourceLoc> for SourceLoc

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

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

impl PartialEq<ValueLoc> for ValueLoc

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

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

impl PartialEq<Uimm64> for Uimm64

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

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

impl<T> PartialEq<EntityList<T>> for EntityList<T> where
    T: PartialEq<T> + EntityRef + ReservedValue, 

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

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

impl<K, V> PartialEq<PrimaryMap<K, V>> for PrimaryMap<K, V> where
    K: PartialEq<K> + EntityRef,
    V: PartialEq<V>, 

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

pub fn ne(&self, other: &PrimaryMap<K, V>) -> bool

impl<T> PartialEq<PackedOption<T>> for PackedOption<T> where
    T: PartialEq<T> + ReservedValue, 

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

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

impl<K, V> PartialEq<SecondaryMap<K, V>> for SecondaryMap<K, V> where
    K: EntityRef,
    V: Clone + PartialEq<V>, 

pub fn eq(&self, other: &SecondaryMap<K, V>) -> 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<OpcodePrefix> for OpcodePrefix

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

impl PartialEq<EncodingBits> for EncodingBits

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

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

impl PartialEq<IntCC> for IntCC

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

impl PartialEq<FloatCC> for FloatCC

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

impl PartialEq<Mips64Architecture> for Mips64Architecture

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

impl PartialEq<PointerWidth> for PointerWidth

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

impl PartialEq<Architecture> for Architecture

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

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

impl PartialEq<CallingConvention> for CallingConvention

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

impl PartialEq<Riscv64Architecture> for Riscv64Architecture

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

impl PartialEq<Triple> for Triple

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

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

impl PartialEq<Riscv32Architecture> for Riscv32Architecture

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

impl PartialEq<OperatingSystem> for OperatingSystem

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

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

impl PartialEq<ArmArchitecture> for ArmArchitecture

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

impl PartialEq<Environment> for Environment

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

impl PartialEq<Mips32Architecture> for Mips32Architecture

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

impl PartialEq<Endianness> for Endianness

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

impl PartialEq<Size> for Size

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

impl PartialEq<CustomVendor> for CustomVendor

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

impl PartialEq<ParseError> for ParseError

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

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

impl PartialEq<CDataModel> for CDataModel

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

impl PartialEq<Aarch64Architecture> for Aarch64Architecture

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

impl PartialEq<BinaryFormat> for BinaryFormat

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

impl PartialEq<X86_32Architecture> for X86_32Architecture

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

impl PartialEq<Vendor> for Vendor

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

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

impl PartialEq<DwInl> for DwInl

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

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

impl PartialEq<DwLle> for DwLle

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

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

impl PartialEq<Range> for Range

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

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

impl PartialEq<DwTag> for DwTag

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

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

impl PartialEq<ColumnType> for ColumnType

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

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

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

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

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

impl PartialEq<RangeList> for RangeList

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

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

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

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

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

impl PartialEq<DwForm> for DwForm

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

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

impl PartialEq<DwAccess> for DwAccess

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

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

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

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

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

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

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

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

impl PartialEq<DwCfa> for DwCfa

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

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

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

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

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

impl PartialEq<CommonInformationEntry> for CommonInformationEntry

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

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

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

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

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

impl PartialEq<AttributeValue> for AttributeValue

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

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

impl PartialEq<DwEhPe> for DwEhPe

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

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

impl PartialEq<FileId> for FileId

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

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

impl PartialEq<StringId> for StringId

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

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

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

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

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

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

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

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

impl PartialEq<DwAddr> for DwAddr

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

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

impl PartialEq<BigEndian> for BigEndian

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

impl PartialEq<DwUt> for DwUt

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

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

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

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

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

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

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

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

impl PartialEq<FileEntryFormat> for FileEntryFormat

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl PartialEq<RangeListId> for RangeListId

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

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

impl PartialEq<ReaderOffsetId> for ReaderOffsetId

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

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

impl PartialEq<Error> for Error

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

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

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

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

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

impl PartialEq<DwVirtuality> for DwVirtuality

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

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

impl PartialEq<Error> for Error

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

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

impl PartialEq<DwLang> for DwLang

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

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

impl PartialEq<LineRow> for LineRow

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

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

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

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

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

impl PartialEq<DwCc> for DwCc

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

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

impl PartialEq<FileInfo> for FileInfo

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

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

impl PartialEq<DwOrd> for DwOrd

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

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

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

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

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

impl PartialEq<Register> for Register

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

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

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

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

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

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

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

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

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

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

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

impl PartialEq<DwDs> for DwDs

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

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

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

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

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

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

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

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

impl PartialEq<UnitEntryId> for UnitEntryId

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

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

impl PartialEq<ConvertError> for ConvertError

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

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

impl PartialEq<LineString> for LineString

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

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

impl PartialEq<SectionId> for SectionId

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

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

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

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

impl PartialEq<Value> for Value

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

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

impl PartialEq<Address> for Address

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

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

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

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

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

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

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

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

impl PartialEq<ValueType> for ValueType

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

impl PartialEq<Encoding> for Encoding

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

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

impl PartialEq<CieId> for CieId

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

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

impl PartialEq<AttributeSpecification> for AttributeSpecification

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

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

impl PartialEq<BaseAddresses> for BaseAddresses

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

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

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

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

impl PartialEq<Range> for Range

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

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

impl PartialEq<DwoId> for DwoId

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

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

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

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

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

impl PartialEq<DwLnct> for DwLnct

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

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

impl PartialEq<Location> for Location

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

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

impl PartialEq<LineStringId> for LineStringId

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

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

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

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

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

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

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

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

impl PartialEq<Format> for Format

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

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

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

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

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

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

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

impl PartialEq<DirectoryId> for DirectoryId

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

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

impl PartialEq<DwDsc> for DwDsc

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

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

impl PartialEq<DwVis> for DwVis

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

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

impl PartialEq<CallFrameInstruction> for CallFrameInstruction

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

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

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

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

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

impl PartialEq<ArangeEntry> for ArangeEntry

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

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

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

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

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

impl PartialEq<DwAte> for DwAte

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

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

impl PartialEq<Augmentation> for Augmentation

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

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

impl PartialEq<DwDefaulted> for DwDefaulted

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

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

impl PartialEq<LittleEndian> for LittleEndian

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

impl PartialEq<DwMacro> for DwMacro

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

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

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

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

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

impl PartialEq<LineEncoding> for LineEncoding

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

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

impl PartialEq<DwRle> for DwRle

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

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

impl PartialEq<DwOp> for DwOp

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

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

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

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

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

impl PartialEq<DwLne> for DwLne

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

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

impl<Endian, T1, T2> PartialEq<EndianReader<Endian, T2>> for EndianReader<Endian, T1> where
    Endian: Endianity,
    T2: CloneStableDeref<Target = [u8]> + Debug,
    T1: CloneStableDeref<Target = [u8]> + Debug, 

pub fn eq(&self, rhs: &EndianReader<Endian, T2>) -> bool

impl PartialEq<DwAt> for DwAt

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

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

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

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

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

impl PartialEq<DwEnd> for DwEnd

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

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

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

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

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

impl PartialEq<Expression> for Expression

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

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

impl PartialEq<DwId> for DwId

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

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

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

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

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

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

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

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

impl PartialEq<DebugTypeSignature> for DebugTypeSignature

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

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

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

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

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

impl PartialEq<DwChildren> for DwChildren

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

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

impl PartialEq<Abbreviation> for Abbreviation

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

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

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

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

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

impl PartialEq<SectionBaseAddresses> for SectionBaseAddresses

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

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

impl PartialEq<LocationList> for LocationList

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

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

impl PartialEq<DwLns> for DwLns

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

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

impl PartialEq<FrameDescriptionEntry> for FrameDescriptionEntry

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl PartialEq<LocationListId> for LocationListId

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

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

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

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

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

impl PartialEq<DwIdx> for DwIdx

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

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

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

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

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

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

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

impl PartialEq<DwarfFileType> for DwarfFileType

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

impl PartialEq<RunTimeEndian> for RunTimeEndian

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

impl PartialEq<Attribute> for Attribute

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

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

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

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

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

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

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

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

impl PartialEq<Reference> for Reference

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

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

impl PartialEq<UnitId> for UnitId

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

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

impl PartialEq<Pointer> for Pointer

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

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

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

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

pub fn ne(&self, other: &ArangeHeader<R, Offset>) -> 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>, 

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

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

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

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

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

impl<T, S1, S2> PartialEq<IndexSet<T, S2>> for IndexSet<T, S1> where
    T: Hash + Eq,
    S1: BuildHasher,
    S2: BuildHasher, 

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

impl<K, V1, S1, V2, S2> PartialEq<IndexMap<K, V2, S2>> for IndexMap<K, V1, S1> where
    K: Hash + Eq,
    S1: BuildHasher,
    S2: BuildHasher,
    V1: PartialEq<V2>, 

pub fn eq(&self, other: &IndexMap<K, V2, S2>) -> bool

impl PartialEq<TryReserveError> for TryReserveError

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

pub fn ne(&self, other: &TryReserveError) -> 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<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<AlgorithmWithDefaults> for AlgorithmWithDefaults

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

impl PartialEq<SpillSlot> for SpillSlot

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

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

impl PartialEq<RealReg> for RealReg

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

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

impl<R> PartialEq<Writable<R>> for Writable<R> where
    R: PartialEq<R> + WritableBase, 

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

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

impl PartialEq<Reg> for Reg

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

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

impl PartialEq<InstIx> for InstIx

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

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

impl PartialEq<VirtualReg> for VirtualReg

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

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

impl PartialEq<BlockIx> for BlockIx

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

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

impl PartialEq<RegClass> for RegClass

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

impl PartialEq<ElemIndex> for ElemIndex

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

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

impl PartialEq<TypeIndex> for TypeIndex

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

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

impl PartialEq<DefinedMemoryIndex> for DefinedMemoryIndex

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

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

impl PartialEq<DefinedFuncIndex> for DefinedFuncIndex

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

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

impl PartialEq<ReturnMode> for ReturnMode

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

impl PartialEq<GlobalInit> for GlobalInit

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

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

impl PartialEq<GlobalIndex> for GlobalIndex

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

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

impl PartialEq<ModuleIndex> for ModuleIndex

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

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

impl PartialEq<SignatureIndex> for SignatureIndex

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

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

impl PartialEq<DefinedTableIndex> for DefinedTableIndex

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

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

impl PartialEq<TableIndex> for TableIndex

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

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

impl PartialEq<InstanceTypeIndex> for InstanceTypeIndex

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

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

impl PartialEq<WasmType> for WasmType

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

impl PartialEq<Global> for Global

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

pub fn ne(&self, other: &Global) -> bool

impl PartialEq<ModuleTypeIndex> for ModuleTypeIndex

pub fn eq(&self, other: &ModuleTypeIndex) -> bool

pub fn ne(&self, other: &ModuleTypeIndex) -> bool

impl PartialEq<DataIndex> for DataIndex

pub fn eq(&self, other: &DataIndex) -> bool

pub fn ne(&self, other: &DataIndex) -> bool

impl PartialEq<FuncIndex> for FuncIndex

pub fn eq(&self, other: &FuncIndex) -> bool

pub fn ne(&self, other: &FuncIndex) -> bool

impl PartialEq<MemoryIndex> for MemoryIndex

pub fn eq(&self, other: &MemoryIndex) -> bool

pub fn ne(&self, other: &MemoryIndex) -> bool

impl PartialEq<DefinedGlobalIndex> for DefinedGlobalIndex

pub fn eq(&self, other: &DefinedGlobalIndex) -> bool

pub fn ne(&self, other: &DefinedGlobalIndex) -> bool

impl PartialEq<WasmFuncType> for WasmFuncType

pub fn eq(&self, other: &WasmFuncType) -> bool

pub fn ne(&self, other: &WasmFuncType) -> bool

impl PartialEq<Memory> for Memory

pub fn eq(&self, other: &Memory) -> bool

pub fn ne(&self, other: &Memory) -> bool

impl PartialEq<InstanceIndex> for InstanceIndex

pub fn eq(&self, other: &InstanceIndex) -> bool

pub fn ne(&self, other: &InstanceIndex) -> bool

impl PartialEq<EventIndex> for EventIndex

pub fn eq(&self, other: &EventIndex) -> bool

pub fn ne(&self, other: &EventIndex) -> bool

impl PartialEq<EntityIndex> for EntityIndex

pub fn eq(&self, other: &EntityIndex) -> bool

pub fn ne(&self, other: &EntityIndex) -> bool

impl PartialEq<Event> for Event

pub fn eq(&self, other: &Event) -> bool

pub fn ne(&self, other: &Event) -> bool

impl PartialEq<TableElementType> for TableElementType

pub fn eq(&self, other: &TableElementType) -> bool

pub fn ne(&self, other: &TableElementType) -> bool

impl PartialEq<Table> for Table

pub fn eq(&self, other: &Table) -> bool

pub fn ne(&self, other: &Table) -> bool

impl PartialEq<Variable> for Variable

pub fn eq(&self, other: &Variable) -> bool

pub fn ne(&self, other: &Variable) -> bool

impl PartialEq<ResizableLimits> for ResizableLimits

pub fn eq(&self, other: &ResizableLimits) -> bool

pub fn ne(&self, other: &ResizableLimits) -> bool

impl PartialEq<Ieee64> for Ieee64

pub fn eq(&self, other: &Ieee64) -> bool

pub fn ne(&self, other: &Ieee64) -> bool

impl PartialEq<MemoryType> for MemoryType

pub fn eq(&self, other: &MemoryType) -> bool

pub fn ne(&self, other: &MemoryType) -> bool

impl PartialEq<V128> for V128

pub fn eq(&self, other: &V128) -> bool

pub fn ne(&self, other: &V128) -> bool

impl PartialEq<Type> for Type

pub fn eq(&self, other: &Type) -> bool

impl PartialEq<EventType> for EventType

pub fn eq(&self, other: &EventType) -> bool

pub fn ne(&self, other: &EventType) -> bool

impl PartialEq<ResizableLimits64> for ResizableLimits64

pub fn eq(&self, other: &ResizableLimits64) -> bool

pub fn ne(&self, other: &ResizableLimits64) -> bool

impl<'a> PartialEq<SectionCode<'a>> for SectionCode<'a>

pub fn eq(&self, other: &SectionCode<'a>) -> bool

pub fn ne(&self, other: &SectionCode<'a>) -> bool

impl PartialEq<TableType> for TableType

pub fn eq(&self, other: &TableType) -> bool

pub fn ne(&self, other: &TableType) -> bool

impl PartialEq<Range> for Range

pub fn eq(&self, other: &Range) -> bool

pub fn ne(&self, other: &Range) -> bool

impl PartialEq<CustomSectionKind> for CustomSectionKind

pub fn eq(&self, other: &CustomSectionKind) -> bool

impl PartialEq<TypeOrFuncType> for TypeOrFuncType

pub fn eq(&self, other: &TypeOrFuncType) -> bool

pub fn ne(&self, other: &TypeOrFuncType) -> bool

impl PartialEq<Ieee32> for Ieee32

pub fn eq(&self, other: &Ieee32) -> bool

pub fn ne(&self, other: &Ieee32) -> bool

impl PartialEq<GlobalType> for GlobalType

pub fn eq(&self, other: &GlobalType) -> bool

pub fn ne(&self, other: &GlobalType) -> bool

impl PartialEq<FuncType> for FuncType

pub fn eq(&self, other: &FuncType) -> bool

pub fn ne(&self, other: &FuncType) -> bool

impl<T> PartialEq<MinMaxResult<T>> for MinMaxResult<T> where
    T: PartialEq<T>, 

pub fn eq(&self, other: &MinMaxResult<T>) -> bool

pub fn ne(&self, other: &MinMaxResult<T>) -> bool

impl<T> PartialEq<Position<T>> for Position<T> where
    T: PartialEq<T>, 

pub fn eq(&self, other: &Position<T>) -> bool

pub fn ne(&self, other: &Position<T>) -> bool

impl<T> PartialEq<FoldWhile<T>> for FoldWhile<T> where
    T: PartialEq<T>, 

pub fn eq(&self, other: &FoldWhile<T>) -> bool

pub fn ne(&self, other: &FoldWhile<T>) -> bool

impl<A, B> PartialEq<EitherOrBoth<A, B>> for EitherOrBoth<A, B> where
    A: PartialEq<A>,
    B: PartialEq<B>, 

pub fn eq(&self, other: &EitherOrBoth<A, B>) -> bool

pub fn ne(&self, other: &EitherOrBoth<A, B>) -> bool

impl<L, R> PartialEq<Either<L, R>> for Either<L, R> where
    R: PartialEq<R>,
    L: PartialEq<L>, 

pub fn eq(&self, other: &Either<L, R>) -> bool

pub fn ne(&self, other: &Either<L, R>) -> bool

impl PartialEq<VMSharedSignatureIndex> for VMSharedSignatureIndex

pub fn eq(&self, other: &VMSharedSignatureIndex) -> bool

pub fn ne(&self, other: &VMSharedSignatureIndex) -> bool

impl PartialEq<PoolingAllocationStrategy> for PoolingAllocationStrategy

pub fn eq(&self, other: &PoolingAllocationStrategy) -> bool

impl PartialEq<InstanceHandle> for InstanceHandle

pub fn eq(&self, other: &InstanceHandle) -> bool

pub fn ne(&self, other: &InstanceHandle) -> bool

impl PartialEq<IndexVec> for IndexVec

pub fn eq(&self, other: &IndexVec) -> bool

impl PartialEq<StepRng> for StepRng

pub fn eq(&self, other: &StepRng) -> bool

pub fn ne(&self, other: &StepRng) -> bool

impl PartialEq<StdRng> for StdRng

pub fn eq(&self, other: &StdRng) -> bool

pub fn ne(&self, other: &StdRng) -> bool

impl PartialEq<BernoulliError> for BernoulliError

pub fn eq(&self, other: &BernoulliError) -> bool

impl PartialEq<WeightedError> for WeightedError

pub fn eq(&self, other: &WeightedError) -> bool

impl PartialEq<Error> for Error

pub fn eq(&self, other: &Error) -> bool

pub fn ne(&self, other: &Error) -> bool

impl PartialEq<ChaCha20Core> for ChaCha20Core

pub fn eq(&self, other: &ChaCha20Core) -> bool

pub fn ne(&self, other: &ChaCha20Core) -> bool

impl PartialEq<ChaCha8Rng> for ChaCha8Rng

pub fn eq(&self, rhs: &ChaCha8Rng) -> bool

impl PartialEq<ChaCha8Core> for ChaCha8Core

pub fn eq(&self, other: &ChaCha8Core) -> bool

pub fn ne(&self, other: &ChaCha8Core) -> bool

impl PartialEq<ChaCha12Core> for ChaCha12Core

pub fn eq(&self, other: &ChaCha12Core) -> bool

pub fn ne(&self, other: &ChaCha12Core) -> bool

impl PartialEq<ChaCha12Rng> for ChaCha12Rng

pub fn eq(&self, rhs: &ChaCha12Rng) -> bool

impl PartialEq<ChaCha20Rng> for ChaCha20Rng

pub fn eq(&self, rhs: &ChaCha20Rng) -> bool

impl PartialEq<vec256_storage> for vec256_storage

pub fn eq(&self, rhs: &vec256_storage) -> bool

impl PartialEq<vec128_storage> for vec128_storage

pub fn eq(&self, rhs: &vec128_storage) -> bool

impl PartialEq<vec512_storage> for vec512_storage

pub fn eq(&self, rhs: &vec512_storage) -> bool

impl PartialEq<PrintFmt> for PrintFmt

pub fn eq(&self, other: &PrintFmt) -> bool

impl PartialEq<LittleEndian> for LittleEndian

pub fn eq(&self, other: &LittleEndian) -> bool

impl PartialEq<ComdatId> for ComdatId

pub fn eq(&self, other: &ComdatId) -> bool

pub fn ne(&self, other: &ComdatId) -> bool

impl PartialEq<SectionKind> for SectionKind

pub fn eq(&self, other: &SectionKind) -> bool

pub fn ne(&self, other: &SectionKind) -> bool

impl PartialEq<SectionFlags> for SectionFlags

pub fn eq(&self, other: &SectionFlags) -> bool

pub fn ne(&self, other: &SectionFlags) -> bool

impl PartialEq<Architecture> for Architecture

pub fn eq(&self, other: &Architecture) -> bool

impl<E> PartialEq<U32Bytes<E>> for U32Bytes<E> where
    E: PartialEq<E> + Endian, 

pub fn eq(&self, other: &U32Bytes<E>) -> bool

pub fn ne(&self, other: &U32Bytes<E>) -> bool

impl PartialEq<SectionIndex> for SectionIndex

pub fn eq(&self, other: &SectionIndex) -> bool

pub fn ne(&self, other: &SectionIndex) -> bool

impl<'data> PartialEq<Import<'data>> for Import<'data>

pub fn eq(&self, other: &Import<'data>) -> bool

pub fn ne(&self, other: &Import<'data>) -> bool

impl PartialEq<BigEndian> for BigEndian

pub fn eq(&self, other: &BigEndian) -> bool

impl PartialEq<ComdatKind> for ComdatKind

pub fn eq(&self, other: &ComdatKind) -> bool

impl<'data> PartialEq<ObjectMapEntry<'data>> for ObjectMapEntry<'data>

pub fn eq(&self, other: &ObjectMapEntry<'data>) -> bool

pub fn ne(&self, other: &ObjectMapEntry<'data>) -> bool

impl PartialEq<SymbolIndex> for SymbolIndex

pub fn eq(&self, other: &SymbolIndex) -> bool

pub fn ne(&self, other: &SymbolIndex) -> bool

impl PartialEq<StandardSection> for StandardSection

pub fn eq(&self, other: &StandardSection) -> bool

impl PartialEq<Endianness> for Endianness

pub fn eq(&self, other: &Endianness) -> bool

impl<E> PartialEq<I64Bytes<E>> for I64Bytes<E> where
    E: PartialEq<E> + Endian, 

pub fn eq(&self, other: &I64Bytes<E>) -> bool

pub fn ne(&self, other: &I64Bytes<E>) -> bool

impl PartialEq<RelocationKind> for RelocationKind

pub fn eq(&self, other: &RelocationKind) -> bool

pub fn ne(&self, other: &RelocationKind) -> bool

impl PartialEq<RelocationEncoding> for RelocationEncoding

pub fn eq(&self, other: &RelocationEncoding) -> bool

impl<E> PartialEq<I16Bytes<E>> for I16Bytes<E> where
    E: PartialEq<E> + Endian, 

pub fn eq(&self, other: &I16Bytes<E>) -> bool

pub fn ne(&self, other: &I16Bytes<E>) -> bool

impl PartialEq<SectionId> for SectionId

pub fn eq(&self, other: &SectionId) -> bool

pub fn ne(&self, other: &SectionId) -> bool

impl<E> PartialEq<U16Bytes<E>> for U16Bytes<E> where
    E: PartialEq<E> + Endian, 

pub fn eq(&self, other: &U16Bytes<E>) -> bool

pub fn ne(&self, other: &U16Bytes<E>) -> bool

impl PartialEq<Error> for Error

pub fn eq(&self, other: &Error) -> bool

pub fn ne(&self, other: &Error) -> bool

impl PartialEq<BinaryFormat> for BinaryFormat

pub fn eq(&self, other: &BinaryFormat) -> bool

impl PartialEq<RelocationTarget> for RelocationTarget

pub fn eq(&self, other: &RelocationTarget) -> bool

pub fn ne(&self, other: &RelocationTarget) -> bool

impl PartialEq<Mangling> for Mangling

pub fn eq(&self, other: &Mangling) -> bool

impl PartialEq<SymbolId> for SymbolId

pub fn eq(&self, other: &SymbolId) -> bool

pub fn ne(&self, other: &SymbolId) -> bool

impl<E> PartialEq<U64Bytes<E>> for U64Bytes<E> where
    E: PartialEq<E> + Endian, 

pub fn eq(&self, other: &U64Bytes<E>) -> bool

pub fn ne(&self, other: &U64Bytes<E>) -> bool

impl<'data> PartialEq<CompressedData<'data>> for CompressedData<'data>

pub fn eq(&self, other: &CompressedData<'data>) -> bool

pub fn ne(&self, other: &CompressedData<'data>) -> bool

impl PartialEq<Error> for Error

pub fn eq(&self, other: &Error) -> bool

pub fn ne(&self, other: &Error) -> bool

impl PartialEq<StandardSegment> for StandardSegment

pub fn eq(&self, other: &StandardSegment) -> bool

impl PartialEq<CompressedFileRange> for CompressedFileRange

pub fn eq(&self, other: &CompressedFileRange) -> bool

pub fn ne(&self, other: &CompressedFileRange) -> bool

impl<E> PartialEq<I32Bytes<E>> for I32Bytes<E> where
    E: PartialEq<E> + Endian, 

pub fn eq(&self, other: &I32Bytes<E>) -> bool

pub fn ne(&self, other: &I32Bytes<E>) -> bool

impl PartialEq<CompressionFormat> for CompressionFormat

pub fn eq(&self, other: &CompressionFormat) -> bool

impl<Section> PartialEq<SymbolFlags<Section>> for SymbolFlags<Section> where
    Section: PartialEq<Section>, 

pub fn eq(&self, other: &SymbolFlags<Section>) -> bool

pub fn ne(&self, other: &SymbolFlags<Section>) -> bool

impl PartialEq<SymbolSection> for SymbolSection

pub fn eq(&self, other: &SymbolSection) -> bool

pub fn ne(&self, other: &SymbolSection) -> bool

impl PartialEq<SymbolKind> for SymbolKind

pub fn eq(&self, other: &SymbolKind) -> bool

impl<'data> PartialEq<SymbolMapName<'data>> for SymbolMapName<'data>

pub fn eq(&self, other: &SymbolMapName<'data>) -> bool

pub fn ne(&self, other: &SymbolMapName<'data>) -> bool

impl PartialEq<ArchiveKind> for ArchiveKind

pub fn eq(&self, other: &ArchiveKind) -> bool

impl<'data> PartialEq<Bytes<'data>> for Bytes<'data>

pub fn eq(&self, other: &Bytes<'data>) -> bool

pub fn ne(&self, other: &Bytes<'data>) -> bool

impl PartialEq<AddressSize> for AddressSize

pub fn eq(&self, other: &AddressSize) -> bool

impl PartialEq<SymbolSection> for SymbolSection

pub fn eq(&self, other: &SymbolSection) -> bool

pub fn ne(&self, other: &SymbolSection) -> bool

impl<'data> PartialEq<Export<'data>> for Export<'data>

pub fn eq(&self, other: &Export<'data>) -> bool

pub fn ne(&self, other: &Export<'data>) -> bool

impl PartialEq<FileFlags> for FileFlags

pub fn eq(&self, other: &FileFlags) -> bool

pub fn ne(&self, other: &FileFlags) -> bool

impl PartialEq<SymbolScope> for SymbolScope

pub fn eq(&self, other: &SymbolScope) -> bool

impl PartialEq<TINFLStatus> for TINFLStatus

pub fn eq(&self, other: &TINFLStatus) -> bool

impl PartialEq<StreamResult> for StreamResult

pub fn eq(&self, other: &StreamResult) -> bool

pub fn ne(&self, other: &StreamResult) -> bool

impl PartialEq<DataFormat> for DataFormat

pub fn eq(&self, other: &DataFormat) -> bool

impl PartialEq<CompressionLevel> for CompressionLevel

pub fn eq(&self, other: &CompressionLevel) -> bool

impl PartialEq<TDEFLFlush> for TDEFLFlush

pub fn eq(&self, other: &TDEFLFlush) -> bool

impl PartialEq<TDEFLStatus> for TDEFLStatus

pub fn eq(&self, other: &TDEFLStatus) -> bool

impl PartialEq<MZFlush> for MZFlush

pub fn eq(&self, other: &MZFlush) -> bool

impl PartialEq<MZError> for MZError

pub fn eq(&self, other: &MZError) -> bool

impl PartialEq<CompressionStrategy> for CompressionStrategy

pub fn eq(&self, other: &CompressionStrategy) -> bool

impl PartialEq<MZStatus> for MZStatus

pub fn eq(&self, other: &MZStatus) -> bool

impl PartialEq<Protection> for Protection

pub fn eq(&self, other: &Protection) -> bool

pub fn ne(&self, other: &Protection) -> bool

impl PartialEq<CompilationStrategy> for CompilationStrategy

pub fn eq(&self, other: &CompilationStrategy) -> bool

impl PartialEq<StackDirection> for StackDirection

pub fn eq(&self, other: &StackDirection) -> bool

impl PartialEq<SimpleId> for SimpleId

pub fn eq(&self, other: &SimpleId) -> bool

pub fn ne(&self, other: &SimpleId) -> bool

impl PartialEq<QualifiedBuiltin> for QualifiedBuiltin

pub fn eq(&self, other: &QualifiedBuiltin) -> bool

pub fn ne(&self, other: &QualifiedBuiltin) -> bool

impl PartialEq<Type> for Type

pub fn eq(&self, other: &Type) -> bool

pub fn ne(&self, other: &Type) -> bool

impl PartialEq<LambdaSig> for LambdaSig

pub fn eq(&self, other: &LambdaSig) -> bool

pub fn ne(&self, other: &LambdaSig) -> bool

impl PartialEq<FunctionParam> for FunctionParam

pub fn eq(&self, other: &FunctionParam) -> bool

pub fn ne(&self, other: &FunctionParam) -> bool

impl PartialEq<TemplateTemplateParam> for TemplateTemplateParam

pub fn eq(&self, other: &TemplateTemplateParam) -> bool

pub fn ne(&self, other: &TemplateTemplateParam) -> bool

impl PartialEq<OperatorName> for OperatorName

pub fn eq(&self, other: &OperatorName) -> bool

pub fn ne(&self, other: &OperatorName) -> bool

impl PartialEq<UnresolvedQualifierLevel> for UnresolvedQualifierLevel

pub fn eq(&self, other: &UnresolvedQualifierLevel) -> bool

pub fn ne(&self, other: &UnresolvedQualifierLevel) -> bool

impl PartialEq<UnresolvedType> for UnresolvedType

pub fn eq(&self, other: &UnresolvedType) -> bool

pub fn ne(&self, other: &UnresolvedType) -> bool

impl PartialEq<TemplateParam> for TemplateParam

pub fn eq(&self, other: &TemplateParam) -> bool

pub fn ne(&self, other: &TemplateParam) -> bool

impl PartialEq<BaseUnresolvedName> for BaseUnresolvedName

pub fn eq(&self, other: &BaseUnresolvedName) -> bool

pub fn ne(&self, other: &BaseUnresolvedName) -> bool

impl PartialEq<BareFunctionType> for BareFunctionType

pub fn eq(&self, other: &BareFunctionType) -> bool

pub fn ne(&self, other: &BareFunctionType) -> bool

impl PartialEq<Discriminator> for Discriminator

pub fn eq(&self, other: &Discriminator) -> bool

pub fn ne(&self, other: &Discriminator) -> bool

impl PartialEq<Identifier> for Identifier

pub fn eq(&self, other: &Identifier) -> bool

pub fn ne(&self, other: &Identifier) -> bool

impl PartialEq<MangledName> for MangledName

pub fn eq(&self, other: &MangledName) -> bool

pub fn ne(&self, other: &MangledName) -> bool

impl PartialEq<CallOffset> for CallOffset

pub fn eq(&self, other: &CallOffset) -> bool

pub fn ne(&self, other: &CallOffset) -> bool

impl PartialEq<TemplateArgs> for TemplateArgs

pub fn eq(&self, other: &TemplateArgs) -> bool

pub fn ne(&self, other: &TemplateArgs) -> bool

impl PartialEq<CvQualifiers> for CvQualifiers

pub fn eq(&self, other: &CvQualifiers) -> bool

pub fn ne(&self, other: &CvQualifiers) -> bool

impl PartialEq<UnresolvedName> for UnresolvedName

pub fn eq(&self, other: &UnresolvedName) -> bool

pub fn ne(&self, other: &UnresolvedName) -> bool

impl PartialEq<DestructorName> for DestructorName

pub fn eq(&self, other: &DestructorName) -> bool

pub fn ne(&self, other: &DestructorName) -> bool

impl PartialEq<DataMemberPrefix> for DataMemberPrefix

pub fn eq(&self, other: &DataMemberPrefix) -> bool

pub fn ne(&self, other: &DataMemberPrefix) -> bool

impl PartialEq<ArrayType> for ArrayType

pub fn eq(&self, other: &ArrayType) -> bool

pub fn ne(&self, other: &ArrayType) -> bool

impl PartialEq<ClosureTypeName> for ClosureTypeName

pub fn eq(&self, other: &ClosureTypeName) -> bool

pub fn ne(&self, other: &ClosureTypeName) -> bool

impl PartialEq<RefQualifier> for RefQualifier

pub fn eq(&self, other: &RefQualifier) -> bool

impl PartialEq<VectorType> for VectorType

pub fn eq(&self, other: &VectorType) -> bool

pub fn ne(&self, other: &VectorType) -> bool

impl PartialEq<StandardBuiltinType> for StandardBuiltinType

pub fn eq(&self, other: &StandardBuiltinType) -> bool

impl PartialEq<TaggedName> for TaggedName

pub fn eq(&self, other: &TaggedName) -> bool

pub fn ne(&self, other: &TaggedName) -> bool

impl PartialEq<Error> for Error

pub fn eq(&self, other: &Error) -> bool

impl PartialEq<CloneSuffix> for CloneSuffix

pub fn eq(&self, other: &CloneSuffix) -> bool

pub fn ne(&self, other: &CloneSuffix) -> bool

impl PartialEq<CloneTypeIdentifier> for CloneTypeIdentifier

pub fn eq(&self, other: &CloneTypeIdentifier) -> bool

pub fn ne(&self, other: &CloneTypeIdentifier) -> bool

impl PartialEq<SourceName> for SourceName

pub fn eq(&self, other: &SourceName) -> bool

pub fn ne(&self, other: &SourceName) -> bool

impl PartialEq<GlobalCtorDtor> for GlobalCtorDtor

pub fn eq(&self, other: &GlobalCtorDtor) -> bool

pub fn ne(&self, other: &GlobalCtorDtor) -> bool

impl PartialEq<ExprPrimary> for ExprPrimary

pub fn eq(&self, other: &ExprPrimary) -> bool

pub fn ne(&self, other: &ExprPrimary) -> bool

impl PartialEq<NonSubstitution> for NonSubstitution

pub fn eq(&self, other: &NonSubstitution) -> bool

pub fn ne(&self, other: &NonSubstitution) -> bool

impl PartialEq<WellKnownComponent> for WellKnownComponent

pub fn eq(&self, other: &WellKnownComponent) -> bool

impl PartialEq<UnnamedTypeName> for UnnamedTypeName

pub fn eq(&self, other: &UnnamedTypeName) -> bool

pub fn ne(&self, other: &UnnamedTypeName) -> bool

impl PartialEq<CtorDtorName> for CtorDtorName

pub fn eq(&self, other: &CtorDtorName) -> bool

pub fn ne(&self, other: &CtorDtorName) -> bool

impl PartialEq<BuiltinType> for BuiltinType

pub fn eq(&self, other: &BuiltinType) -> bool

pub fn ne(&self, other: &BuiltinType) -> bool

impl PartialEq<UnscopedTemplateNameHandle> for UnscopedTemplateNameHandle

pub fn eq(&self, other: &UnscopedTemplateNameHandle) -> bool

pub fn ne(&self, other: &UnscopedTemplateNameHandle) -> bool

impl PartialEq<Encoding> for Encoding

pub fn eq(&self, other: &Encoding) -> bool

pub fn ne(&self, other: &Encoding) -> bool

impl PartialEq<Initializer> for Initializer

pub fn eq(&self, other: &Initializer) -> bool

pub fn ne(&self, other: &Initializer) -> bool

impl PartialEq<UnqualifiedName> for UnqualifiedName

pub fn eq(&self, other: &UnqualifiedName) -> bool

pub fn ne(&self, other: &UnqualifiedName) -> bool

impl PartialEq<UnscopedName> for UnscopedName

pub fn eq(&self, other: &UnscopedName) -> bool

pub fn ne(&self, other: &UnscopedName) -> bool

impl PartialEq<NestedName> for NestedName

pub fn eq(&self, other: &NestedName) -> bool

pub fn ne(&self, other: &NestedName) -> bool

impl PartialEq<ResourceName> for ResourceName

pub fn eq(&self, other: &ResourceName) -> bool

pub fn ne(&self, other: &ResourceName) -> bool

impl PartialEq<Name> for Name

pub fn eq(&self, other: &Name) -> bool

pub fn ne(&self, other: &Name) -> bool

impl PartialEq<SimpleOperatorName> for SimpleOperatorName

pub fn eq(&self, other: &SimpleOperatorName) -> bool

impl PartialEq<SpecialName> for SpecialName

pub fn eq(&self, other: &SpecialName) -> bool

pub fn ne(&self, other: &SpecialName) -> bool

impl PartialEq<FunctionType> for FunctionType

pub fn eq(&self, other: &FunctionType) -> bool

pub fn ne(&self, other: &FunctionType) -> bool

impl PartialEq<Expression> for Expression

pub fn eq(&self, other: &Expression) -> bool

pub fn ne(&self, other: &Expression) -> bool

impl PartialEq<NvOffset> for NvOffset

pub fn eq(&self, other: &NvOffset) -> bool

pub fn ne(&self, other: &NvOffset) -> bool

impl PartialEq<TemplateTemplateParamHandle> for TemplateTemplateParamHandle

pub fn eq(&self, other: &TemplateTemplateParamHandle) -> bool

pub fn ne(&self, other: &TemplateTemplateParamHandle) -> bool

impl PartialEq<Prefix> for Prefix

pub fn eq(&self, other: &Prefix) -> bool

pub fn ne(&self, other: &Prefix) -> bool

impl PartialEq<SeqId> for SeqId

pub fn eq(&self, other: &SeqId) -> bool

pub fn ne(&self, other: &SeqId) -> bool

impl PartialEq<VOffset> for VOffset

pub fn eq(&self, other: &VOffset) -> bool

pub fn ne(&self, other: &VOffset) -> bool

impl PartialEq<MemberName> for MemberName

pub fn eq(&self, other: &MemberName) -> bool

pub fn ne(&self, other: &MemberName) -> bool

impl PartialEq<Substitution> for Substitution

pub fn eq(&self, other: &Substitution) -> bool

pub fn ne(&self, other: &Substitution) -> bool

impl PartialEq<Decltype> for Decltype

pub fn eq(&self, other: &Decltype) -> bool

pub fn ne(&self, other: &Decltype) -> bool

impl PartialEq<UnresolvedTypeHandle> for UnresolvedTypeHandle

pub fn eq(&self, other: &UnresolvedTypeHandle) -> bool

pub fn ne(&self, other: &UnresolvedTypeHandle) -> bool

impl PartialEq<TemplateArg> for TemplateArg

pub fn eq(&self, other: &TemplateArg) -> bool

pub fn ne(&self, other: &TemplateArg) -> bool

impl PartialEq<TypeHandle> for TypeHandle

pub fn eq(&self, other: &TypeHandle) -> bool

pub fn ne(&self, other: &TypeHandle) -> bool

impl<T> PartialEq<Symbol<T>> for Symbol<T> where
    T: PartialEq<T>, 

pub fn eq(&self, other: &Symbol<T>) -> bool

pub fn ne(&self, other: &Symbol<T>) -> bool

impl PartialEq<DemangleNodeType> for DemangleNodeType

pub fn eq(&self, other: &DemangleNodeType) -> bool

impl PartialEq<ClassEnumType> for ClassEnumType

pub fn eq(&self, other: &ClassEnumType) -> bool

pub fn ne(&self, other: &ClassEnumType) -> bool

impl PartialEq<PointerToMemberType> for PointerToMemberType

pub fn eq(&self, other: &PointerToMemberType) -> bool

pub fn ne(&self, other: &PointerToMemberType) -> bool

impl PartialEq<LocalName> for LocalName

pub fn eq(&self, other: &LocalName) -> bool

pub fn ne(&self, other: &LocalName) -> bool

impl PartialEq<UnscopedTemplateName> for UnscopedTemplateName

pub fn eq(&self, other: &UnscopedTemplateName) -> bool

pub fn ne(&self, other: &UnscopedTemplateName) -> bool

impl PartialEq<PrefixHandle> for PrefixHandle

pub fn eq(&self, other: &PrefixHandle) -> bool

pub fn ne(&self, other: &PrefixHandle) -> bool

Implementors

impl PartialEq<GuestError> for GuestError

pub fn eq(&self, other: &GuestError) -> bool

pub fn ne(&self, other: &GuestError) -> bool

impl PartialEq<Trap> for Trap

pub fn eq(&self, other: &Trap) -> bool

pub fn ne(&self, other: &Trap) -> bool

impl PartialEq<Abi> for Abi

pub fn eq(&self, other: &Abi) -> bool

impl PartialEq<BuiltinType> for wasmtime_wiggle::witx::BuiltinType

pub fn eq(&self, other: &BuiltinType) -> bool

pub fn ne(&self, other: &BuiltinType) -> bool

impl PartialEq<Definition> for Definition

pub fn eq(&self, other: &Definition) -> bool

pub fn ne(&self, other: &Definition) -> bool

impl PartialEq<Entry> for Entry

pub fn eq(&self, rhs: &Entry) -> bool

impl PartialEq<IntRepr> for IntRepr

pub fn eq(&self, other: &IntRepr) -> bool

impl PartialEq<ModuleDefinition> for ModuleDefinition

pub fn eq(&self, other: &ModuleDefinition) -> bool

pub fn ne(&self, other: &ModuleDefinition) -> bool

impl PartialEq<ModuleEntry> for ModuleEntry

pub fn eq(&self, rhs: &ModuleEntry) -> bool

impl PartialEq<ModuleImportVariant> for ModuleImportVariant

pub fn eq(&self, other: &ModuleImportVariant) -> bool

impl PartialEq<RecordKind> for RecordKind

pub fn eq(&self, other: &RecordKind) -> bool

pub fn ne(&self, other: &RecordKind) -> bool

impl PartialEq<RepEquality> for RepEquality

pub fn eq(&self, other: &RepEquality) -> bool

impl PartialEq<SExpr> for SExpr

pub fn eq(&self, other: &SExpr) -> bool

pub fn ne(&self, other: &SExpr) -> bool

impl PartialEq<Type> for wasmtime_wiggle::witx::Type

pub fn eq(&self, other: &Type) -> bool

pub fn ne(&self, other: &Type) -> bool

impl PartialEq<TypeRef> for TypeRef

pub fn eq(&self, other: &TypeRef) -> bool

pub fn ne(&self, other: &TypeRef) -> bool

impl PartialEq<WasmType> for wasmtime_wiggle::witx::WasmType

pub fn eq(&self, other: &WasmType) -> bool

impl PartialEq<ImportTypeSyntax> for ImportTypeSyntax

pub fn eq(&self, other: &ImportTypeSyntax) -> bool

impl PartialEq<ParamUnknown> for ParamUnknown

pub fn eq(&self, other: &ParamUnknown) -> bool

pub fn ne(&self, other: &ParamUnknown) -> bool

impl PartialEq<TypePolyfill> for TypePolyfill

pub fn eq(&self, other: &TypePolyfill) -> bool

pub fn ne(&self, other: &TypePolyfill) -> bool

impl PartialEq<Infallible> for Infallible

pub fn eq(&self, &Infallible) -> bool

impl PartialEq<FpCategory> for FpCategory

pub fn eq(&self, other: &FpCategory) -> bool

impl PartialEq<IntErrorKind> for IntErrorKind

pub fn eq(&self, other: &IntErrorKind) -> bool

impl PartialEq<SearchStep> for SearchStep

pub fn eq(&self, other: &SearchStep) -> bool

pub fn ne(&self, other: &SearchStep) -> bool

impl PartialEq<Ordering> for wasmtime_wiggle::bitflags::_core::sync::atomic::Ordering

pub fn eq(&self, other: &Ordering) -> bool

impl PartialEq<Ordering> for wasmtime_wiggle::bitflags::_core::cmp::Ordering

pub fn eq(&self, other: &Ordering) -> bool

impl PartialEq<BorrowHandle> for BorrowHandle

pub fn eq(&self, other: &BorrowHandle) -> bool

pub fn ne(&self, other: &BorrowHandle) -> bool

impl PartialEq<Region> for Region

pub fn eq(&self, other: &Region) -> bool

pub fn ne(&self, other: &Region) -> bool

impl PartialEq<Identifier> for wasmtime_wiggle::tracing::callsite::Identifier

pub fn eq(&self, other: &Identifier) -> bool

impl PartialEq<Empty> for Empty

pub fn eq(&self, other: &Empty) -> bool

impl PartialEq<Field> for Field

pub fn eq(&self, other: &Field) -> bool

impl PartialEq<Kind> for Kind

pub fn eq(&self, other: &Kind) -> bool

pub fn ne(&self, other: &Kind) -> bool

impl PartialEq<LevelFilter> for wasmtime_wiggle::tracing::metadata::LevelFilter

pub fn eq(&self, other: &LevelFilter) -> bool

pub fn ne(&self, other: &LevelFilter) -> bool

impl PartialEq<LevelFilter> for wasmtime_wiggle::tracing::Level

pub fn eq(&self, other: &LevelFilter) -> bool

impl PartialEq<Id> for wasmtime_wiggle::tracing::Id

pub fn eq(&self, other: &Id) -> bool

pub fn ne(&self, other: &Id) -> bool

impl PartialEq<Level> for wasmtime_wiggle::tracing::metadata::LevelFilter

pub fn eq(&self, other: &Level) -> bool

impl PartialEq<Level> for wasmtime_wiggle::tracing::Level

pub fn eq(&self, other: &Level) -> bool

pub fn ne(&self, other: &Level) -> bool

impl PartialEq<Span> for wasmtime_wiggle::tracing::Span

pub fn eq(&self, other: &Span) -> bool

impl PartialEq<HandleSyntax> for HandleSyntax

pub fn eq(&self, other: &HandleSyntax) -> bool

impl PartialEq<FuncPolyfill> for FuncPolyfill

pub fn eq(&self, other: &FuncPolyfill) -> bool

pub fn ne(&self, other: &FuncPolyfill) -> bool

impl PartialEq<ModulePolyfill> for ModulePolyfill

pub fn eq(&self, other: &ModulePolyfill) -> bool

pub fn ne(&self, other: &ModulePolyfill) -> bool

impl PartialEq<ParamPolyfill> for ParamPolyfill

pub fn eq(&self, other: &ParamPolyfill) -> bool

pub fn ne(&self, other: &ParamPolyfill) -> bool

impl PartialEq<Polyfill> for Polyfill

pub fn eq(&self, other: &Polyfill) -> bool

pub fn ne(&self, other: &Polyfill) -> bool

impl PartialEq<Case> for Case

pub fn eq(&self, other: &Case) -> bool

pub fn ne(&self, other: &Case) -> bool

impl PartialEq<Constant> for wasmtime_wiggle::witx::Constant

pub fn eq(&self, other: &Constant) -> bool

pub fn ne(&self, other: &Constant) -> bool

impl PartialEq<Document> for Document

pub fn eq(&self, rhs: &Document) -> bool

impl PartialEq<HandleDatatype> for HandleDatatype

pub fn eq(&self, other: &HandleDatatype) -> bool

impl PartialEq<Id> for wasmtime_wiggle::witx::Id

pub fn eq(&self, other: &Id) -> bool

pub fn ne(&self, other: &Id) -> bool

impl PartialEq<InterfaceFunc> for InterfaceFunc

pub fn eq(&self, other: &InterfaceFunc) -> bool

pub fn ne(&self, other: &InterfaceFunc) -> bool

impl PartialEq<InterfaceFuncParam> for InterfaceFuncParam

pub fn eq(&self, other: &InterfaceFuncParam) -> bool

pub fn ne(&self, other: &InterfaceFuncParam) -> bool

impl PartialEq<Location> for wasmtime_wiggle::witx::Location

pub fn eq(&self, other: &Location) -> bool

pub fn ne(&self, other: &Location) -> bool

impl PartialEq<Module> for Module

pub fn eq(&self, rhs: &Module) -> bool

impl PartialEq<ModuleImport> for ModuleImport

pub fn eq(&self, other: &ModuleImport) -> bool

pub fn ne(&self, other: &ModuleImport) -> bool

impl PartialEq<NamedType> for NamedType

pub fn eq(&self, other: &NamedType) -> bool

pub fn ne(&self, other: &NamedType) -> bool

impl PartialEq<RecordDatatype> for RecordDatatype

pub fn eq(&self, other: &RecordDatatype) -> bool

pub fn ne(&self, other: &RecordDatatype) -> bool

impl PartialEq<RecordMember> for RecordMember

pub fn eq(&self, other: &RecordMember) -> bool

pub fn ne(&self, other: &RecordMember) -> bool

impl PartialEq<SizeAlign> for SizeAlign

pub fn eq(&self, other: &SizeAlign) -> bool

pub fn ne(&self, other: &SizeAlign) -> bool

impl PartialEq<Variant> for Variant

pub fn eq(&self, other: &Variant) -> bool

pub fn ne(&self, other: &Variant) -> bool

impl PartialEq<AllocError> for AllocError

pub fn eq(&self, other: &AllocError) -> bool

impl PartialEq<Layout> for Layout

pub fn eq(&self, other: &Layout) -> bool

pub fn ne(&self, other: &Layout) -> bool

impl PartialEq<LayoutError> for LayoutError

pub fn eq(&self, other: &LayoutError) -> bool

pub fn ne(&self, other: &LayoutError) -> bool

impl PartialEq<TypeId> for TypeId

pub fn eq(&self, other: &TypeId) -> bool

pub fn ne(&self, other: &TypeId) -> bool

impl PartialEq<CpuidResult> for CpuidResult

pub fn eq(&self, other: &CpuidResult) -> bool

pub fn ne(&self, other: &CpuidResult) -> bool

impl PartialEq<CharTryFromError> for CharTryFromError

pub fn eq(&self, other: &CharTryFromError) -> bool

pub fn ne(&self, other: &CharTryFromError) -> bool

impl PartialEq<DecodeUtf16Error> for DecodeUtf16Error

pub fn eq(&self, other: &DecodeUtf16Error) -> bool

pub fn ne(&self, other: &DecodeUtf16Error) -> bool

impl PartialEq<ParseCharError> for ParseCharError

pub fn eq(&self, other: &ParseCharError) -> bool

pub fn ne(&self, other: &ParseCharError) -> bool

impl PartialEq<Error> for wasmtime_wiggle::bitflags::_core::fmt::Error

pub fn eq(&self, other: &Error) -> bool

impl PartialEq<PhantomPinned> for PhantomPinned

pub fn eq(&self, other: &PhantomPinned) -> bool

impl PartialEq<NonZeroI8> for NonZeroI8

pub fn eq(&self, other: &NonZeroI8) -> bool

pub fn ne(&self, other: &NonZeroI8) -> bool

impl PartialEq<NonZeroI16> for NonZeroI16

pub fn eq(&self, other: &NonZeroI16) -> bool

pub fn ne(&self, other: &NonZeroI16) -> bool

impl PartialEq<NonZeroI32> for NonZeroI32

pub fn eq(&self, other: &NonZeroI32) -> bool

pub fn ne(&self, other: &NonZeroI32) -> bool

impl PartialEq<NonZeroI64> for NonZeroI64

pub fn eq(&self, other: &NonZeroI64) -> bool

pub fn ne(&self, other: &NonZeroI64) -> bool

impl PartialEq<NonZeroI128> for NonZeroI128

pub fn eq(&self, other: &NonZeroI128) -> bool

pub fn ne(&self, other: &NonZeroI128) -> bool

impl PartialEq<NonZeroIsize> for NonZeroIsize

pub fn eq(&self, other: &NonZeroIsize) -> bool

pub fn ne(&self, other: &NonZeroIsize) -> bool

impl PartialEq<NonZeroU8> for NonZeroU8

pub fn eq(&self, other: &NonZeroU8) -> bool

pub fn ne(&self, other: &NonZeroU8) -> bool

impl PartialEq<NonZeroU16> for NonZeroU16

pub fn eq(&self, other: &NonZeroU16) -> bool

pub fn ne(&self, other: &NonZeroU16) -> bool

impl PartialEq<NonZeroU32> for NonZeroU32

pub fn eq(&self, other: &NonZeroU32) -> bool

pub fn ne(&self, other: &NonZeroU32) -> bool

impl PartialEq<NonZeroU64> for NonZeroU64

pub fn eq(&self, other: &NonZeroU64) -> bool

pub fn ne(&self, other: &NonZeroU64) -> bool

impl PartialEq<NonZeroU128> for NonZeroU128

pub fn eq(&self, other: &NonZeroU128) -> bool

pub fn ne(&self, other: &NonZeroU128) -> bool

impl PartialEq<NonZeroUsize> for NonZeroUsize

pub fn eq(&self, other: &NonZeroUsize) -> bool

pub fn ne(&self, other: &NonZeroUsize) -> bool

impl PartialEq<ParseFloatError> for ParseFloatError

pub fn eq(&self, other: &ParseFloatError) -> bool

pub fn ne(&self, other: &ParseFloatError) -> bool

impl PartialEq<ParseIntError> for ParseIntError

pub fn eq(&self, other: &ParseIntError) -> bool

pub fn ne(&self, other: &ParseIntError) -> bool

impl PartialEq<TryFromIntError> for TryFromIntError

pub fn eq(&self, other: &TryFromIntError) -> bool

pub fn ne(&self, other: &TryFromIntError) -> bool

impl PartialEq<RangeFull> for RangeFull

pub fn eq(&self, other: &RangeFull) -> bool

impl PartialEq<NoneError> for NoneError

pub fn eq(&self, other: &NoneError) -> bool

impl PartialEq<ParseBoolError> for ParseBoolError

pub fn eq(&self, other: &ParseBoolError) -> bool

pub fn ne(&self, other: &ParseBoolError) -> bool

impl PartialEq<Utf8Error> for Utf8Error

pub fn eq(&self, other: &Utf8Error) -> bool

pub fn ne(&self, other: &Utf8Error) -> bool

impl PartialEq<RawWaker> for RawWaker

pub fn eq(&self, other: &RawWaker) -> bool

pub fn ne(&self, other: &RawWaker) -> bool

impl PartialEq<RawWakerVTable> for RawWakerVTable

pub fn eq(&self, other: &RawWakerVTable) -> bool

pub fn ne(&self, other: &RawWakerVTable) -> bool

impl PartialEq<Duration> for Duration

pub fn eq(&self, other: &Duration) -> bool

pub fn ne(&self, other: &Duration) -> bool

impl<'_> PartialEq<&'_ str> for wasmtime_wiggle::witx::Id

pub fn eq(&self, rhs: &&str) -> bool

impl<'_> PartialEq<InterfaceFuncSyntax<'_>> for InterfaceFuncSyntax<'_>

pub fn eq(&self, other: &InterfaceFuncSyntax<'_>) -> bool

impl<'_> PartialEq<ModuleImportSyntax<'_>> for ModuleImportSyntax<'_>

pub fn eq(&self, other: &ModuleImportSyntax<'_>) -> bool

impl<'a> PartialEq<DeclSyntax<'a>> for DeclSyntax<'a>

pub fn eq(&self, other: &DeclSyntax<'a>) -> bool

pub fn ne(&self, other: &DeclSyntax<'a>) -> bool

impl<'a> PartialEq<ModuleDeclSyntax<'a>> for ModuleDeclSyntax<'a>

pub fn eq(&self, other: &ModuleDeclSyntax<'a>) -> bool

pub fn ne(&self, other: &ModuleDeclSyntax<'a>) -> bool

impl<'a> PartialEq<TopLevelSyntax<'a>> for TopLevelSyntax<'a>

pub fn eq(&self, other: &TopLevelSyntax<'a>) -> bool

pub fn ne(&self, other: &TopLevelSyntax<'a>) -> bool

impl<'a> PartialEq<TypedefSyntax<'a>> for TypedefSyntax<'a>

pub fn eq(&self, other: &TypedefSyntax<'a>) -> bool

pub fn ne(&self, other: &TypedefSyntax<'a>) -> bool

impl<'a> PartialEq<CaseSyntax<'a>> for CaseSyntax<'a>

pub fn eq(&self, other: &CaseSyntax<'a>) -> bool

pub fn ne(&self, other: &CaseSyntax<'a>) -> bool

impl<'a> PartialEq<CommentSyntax<'a>> for CommentSyntax<'a>

pub fn eq(&self, other: &CommentSyntax<'a>) -> bool

pub fn ne(&self, other: &CommentSyntax<'a>) -> bool

impl<'a> PartialEq<ConstSyntax<'a>> for ConstSyntax<'a>

pub fn eq(&self, other: &ConstSyntax<'a>) -> bool

pub fn ne(&self, other: &ConstSyntax<'a>) -> bool

impl<'a> PartialEq<EnumSyntax<'a>> for EnumSyntax<'a>

pub fn eq(&self, other: &EnumSyntax<'a>) -> bool

pub fn ne(&self, other: &EnumSyntax<'a>) -> bool

impl<'a> PartialEq<ExpectedSyntax<'a>> for ExpectedSyntax<'a>

pub fn eq(&self, other: &ExpectedSyntax<'a>) -> bool

pub fn ne(&self, other: &ExpectedSyntax<'a>) -> bool

impl<'a> PartialEq<FieldSyntax<'a>> for FieldSyntax<'a>

pub fn eq(&self, other: &FieldSyntax<'a>) -> bool

pub fn ne(&self, other: &FieldSyntax<'a>) -> bool

impl<'a> PartialEq<FlagsSyntax<'a>> for FlagsSyntax<'a>

pub fn eq(&self, other: &FlagsSyntax<'a>) -> bool

pub fn ne(&self, other: &FlagsSyntax<'a>) -> bool

impl<'a> PartialEq<ModuleSyntax<'a>> for ModuleSyntax<'a>

pub fn eq(&self, other: &ModuleSyntax<'a>) -> bool

pub fn ne(&self, other: &ModuleSyntax<'a>) -> bool

impl<'a> PartialEq<RecordSyntax<'a>> for RecordSyntax<'a>

pub fn eq(&self, other: &RecordSyntax<'a>) -> bool

pub fn ne(&self, other: &RecordSyntax<'a>) -> bool

impl<'a> PartialEq<TopLevelDocument<'a>> for TopLevelDocument<'a>

pub fn eq(&self, other: &TopLevelDocument<'a>) -> bool

pub fn ne(&self, other: &TopLevelDocument<'a>) -> bool

impl<'a> PartialEq<TupleSyntax<'a>> for TupleSyntax<'a>

pub fn eq(&self, other: &TupleSyntax<'a>) -> bool

pub fn ne(&self, other: &TupleSyntax<'a>) -> bool

impl<'a> PartialEq<TypenameSyntax<'a>> for TypenameSyntax<'a>

pub fn eq(&self, other: &TypenameSyntax<'a>) -> bool

pub fn ne(&self, other: &TypenameSyntax<'a>) -> bool

impl<'a> PartialEq<UnionSyntax<'a>> for UnionSyntax<'a>

pub fn eq(&self, other: &UnionSyntax<'a>) -> bool

pub fn ne(&self, other: &UnionSyntax<'a>) -> bool

impl<'a> PartialEq<VariantSyntax<'a>> for VariantSyntax<'a>

pub fn eq(&self, other: &VariantSyntax<'a>) -> bool

pub fn ne(&self, other: &VariantSyntax<'a>) -> bool

impl<'a> PartialEq<Location<'a>> for wasmtime_wiggle::bitflags::_core::panic::Location<'a>

pub fn eq(&self, other: &Location<'a>) -> bool

pub fn ne(&self, other: &Location<'a>) -> 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<'a, T> PartialEq<Documented<'a, T>> for Documented<'a, T> where
    T: PartialEq<T>, 

pub fn eq(&self, other: &Documented<'a, T>) -> bool

pub fn ne(&self, other: &Documented<'a, T>) -> 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<Dyn> PartialEq<DynMetadata<Dyn>> for DynMetadata<Dyn> where
    Dyn: ?Sized, 

pub fn eq(&self, other: &DynMetadata<Dyn>) -> bool

impl<H> PartialEq<BuildHasherDefault<H>> for BuildHasherDefault<H>

pub fn eq(&self, _other: &BuildHasherDefault<H>) -> bool

impl<Idx> PartialEq<Range<Idx>> for wasmtime_wiggle::bitflags::_core::ops::Range<Idx> where
    Idx: PartialEq<Idx>, 

pub fn eq(&self, other: &Range<Idx>) -> bool

pub fn ne(&self, other: &Range<Idx>) -> 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<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<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<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<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<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<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<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<T> PartialEq<Cell<T>> for Cell<T> where
    T: PartialEq<T> + Copy, 

pub fn eq(&self, other: &Cell<T>) -> 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<T> PartialEq<OnceCell<T>> for OnceCell<T> where
    T: PartialEq<T>, 

pub fn eq(&self, other: &OnceCell<T>) -> bool

impl<T> PartialEq<PhantomData<T>> for PhantomData<T> where
    T: ?Sized, 

pub fn eq(&self, _other: &PhantomData<T>) -> bool

impl<T> PartialEq<Discriminant<T>> for Discriminant<T>

pub fn eq(&self, rhs: &Discriminant<T>) -> 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<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<T> PartialEq<NonNull<T>> for NonNull<T> where
    T: ?Sized, 

pub fn eq(&self, other: &NonNull<T>) -> 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<T, E> PartialEq<Result<T, E>> for Result<T, E> where
    T: PartialEq<T>,
    E: PartialEq<E>, 

pub fn eq(&self, other: &Result<T, E>) -> bool

pub fn ne(&self, other: &Result<T, E>) -> 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