Trait wasmer_types::lib::std::cmp::PartialEq1.0.0[−][src]

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

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

Expand description

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 and B: PartialEq<A>, then a == b implies b == a; and
Transitive: if A: PartialEq 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`[src]

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`[src]

This method tests for !=.

Implementations on Foreign Types

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

`pub fn eq(&self, other: &OsString) -> bool`[src]

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

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

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

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

`pub fn eq(&self, other: &Path) -> bool`[src]

`impl PartialEq<ErrorKind> for ErrorKind`[src]

`pub fn eq(&self, other: &ErrorKind) -> bool`[src]

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

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

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

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

`impl PartialEq<Instant> for Instant`[src]

`pub fn eq(&self, other: &Instant) -> bool`[src]

`pub fn ne(&self, other: &Instant) -> bool`[src]

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

`pub fn eq(&self, other: &OsString) -> bool`[src]

`impl PartialEq<Output> for Output`[src]

`pub fn eq(&self, other: &Output) -> bool`[src]

`pub fn ne(&self, other: &Output) -> bool`[src]

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

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

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

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

`impl PartialEq<str> for OsStr`[src]

`pub fn eq(&self, other: &str) -> bool`[src]

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

`pub fn eq(&self, other: &PathBuf) -> bool`[src]

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

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

`impl PartialEq<ExitStatusError> for ExitStatusError`[src]

`pub fn eq(&self, other: &ExitStatusError) -> bool`[src]

`pub fn ne(&self, other: &ExitStatusError) -> bool`[src]

`impl PartialEq<OsStr> for str`[src]

`pub fn eq(&self, other: &OsStr) -> bool`[src]

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

`pub fn eq(&self, other: &Path) -> bool`[src]

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

`pub fn eq(&self, other: &OsStr) -> bool`[src]

`impl PartialEq<AccessError> for AccessError`[src]

`pub fn eq(&self, other: &AccessError) -> bool`[src]

`pub fn ne(&self, other: &AccessError) -> bool`[src]

`impl PartialEq<SocketAddrV4> for SocketAddrV4`[src]

`pub fn eq(&self, other: &SocketAddrV4) -> bool`[src]

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

`pub fn eq(&self, other: &&str) -> bool`[src]

`impl PartialEq<FileType> for FileType`[src]

`pub fn eq(&self, other: &FileType) -> bool`[src]

`pub fn ne(&self, other: &FileType) -> bool`[src]

`impl PartialEq<SystemTime> for SystemTime`[src]

`pub fn eq(&self, other: &SystemTime) -> bool`[src]

`pub fn ne(&self, other: &SystemTime) -> bool`[src]

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

`pub fn eq(&self, other: &PathBuf) -> bool`[src]

`impl PartialEq<UCred> for UCred`[src]

`pub fn eq(&self, other: &UCred) -> bool`[src]

`pub fn ne(&self, other: &UCred) -> bool`[src]

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

`pub fn eq(&self, other: &OsStr) -> bool`[src]

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

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

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

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

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

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

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

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

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

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

`impl PartialEq<IpAddr> for Ipv6Addr`[src]

`pub fn eq(&self, other: &IpAddr) -> bool`[src]

`impl PartialEq<IpAddr> for IpAddr`[src]

`pub fn eq(&self, other: &IpAddr) -> bool`[src]

`pub fn ne(&self, other: &IpAddr) -> bool`[src]

`impl PartialEq<SeekFrom> for SeekFrom`[src]

`pub fn eq(&self, other: &SeekFrom) -> bool`[src]

`pub fn ne(&self, other: &SeekFrom) -> bool`[src]

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

`pub fn eq(&self, other: &OsString) -> bool`[src]

`impl PartialEq<CString> for CString`[src]

`pub fn eq(&self, other: &CString) -> bool`[src]

`pub fn ne(&self, other: &CString) -> bool`[src]

`impl PartialEq<SocketAddrV6> for SocketAddrV6`[src]

`pub fn eq(&self, other: &SocketAddrV6) -> bool`[src]

`impl PartialEq<Shutdown> for Shutdown`[src]

`pub fn eq(&self, other: &Shutdown) -> bool`[src]

`impl PartialEq<OsString> for str`[src]

`pub fn eq(&self, other: &OsString) -> bool`[src]

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

`pub fn eq(&self, other: &PathBuf) -> bool`[src]

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

`pub fn eq(&self, other: &OsString) -> bool`[src]

`impl PartialEq<PathBuf> for PathBuf`[src]

`pub fn eq(&self, other: &PathBuf) -> bool`[src]

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

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

`impl PartialEq<CStr> for CStr`[src]

`pub fn eq(&self, other: &CStr) -> bool`[src]

`impl PartialEq<AddrParseError> for AddrParseError`[src]

`pub fn eq(&self, other: &AddrParseError) -> bool`[src]

`pub fn ne(&self, other: &AddrParseError) -> bool`[src]

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

`pub fn eq(&self, other: &PathBuf) -> bool`[src]

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

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

`impl PartialEq<OsString> for OsString`[src]

`pub fn eq(&self, other: &OsString) -> bool`[src]

`impl PartialEq<IntoStringError> for IntoStringError`[src]

`pub fn eq(&self, other: &IntoStringError) -> bool`[src]

`pub fn ne(&self, other: &IntoStringError) -> bool`[src]

`impl PartialEq<VarError> for VarError`[src]

`pub fn eq(&self, other: &VarError) -> bool`[src]

`pub fn ne(&self, other: &VarError) -> bool`[src]

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

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

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

`pub fn eq(&self, other: &OsString) -> bool`[src]

`impl PartialEq<Ipv6Addr> for IpAddr`[src]

`pub fn eq(&self, other: &Ipv6Addr) -> bool`[src]

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

`pub fn eq(&self, other: &OsStr) -> bool`[src]

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

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

`impl PartialEq<Path> for Path`[src]

`pub fn eq(&self, other: &Path) -> bool`[src]

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

`pub fn eq(&self, other: &Path) -> bool`[src]

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

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

`impl PartialEq<OsStr> for OsStr`[src]

`pub fn eq(&self, other: &OsStr) -> bool`[src]

`impl PartialEq<Ipv6MulticastScope> for Ipv6MulticastScope`[src]

`pub fn eq(&self, other: &Ipv6MulticastScope) -> bool`[src]

`impl PartialEq<Permissions> for Permissions`[src]

`pub fn eq(&self, other: &Permissions) -> bool`[src]

`pub fn ne(&self, other: &Permissions) -> bool`[src]

`impl PartialEq<Ipv4Addr> for Ipv4Addr`[src]

`pub fn eq(&self, other: &Ipv4Addr) -> bool`[src]

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

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

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

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

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

`impl PartialEq<ThreadId> for ThreadId`[src]

`pub fn eq(&self, other: &ThreadId) -> bool`[src]

`pub fn ne(&self, other: &ThreadId) -> bool`[src]

`impl PartialEq<Ipv4Addr> for IpAddr`[src]

`pub fn eq(&self, other: &Ipv4Addr) -> bool`[src]

`impl PartialEq<Ipv6Addr> for Ipv6Addr`[src]

`pub fn eq(&self, other: &Ipv6Addr) -> bool`[src]

`impl PartialEq<SocketAddr> for SocketAddr`[src]

`pub fn eq(&self, other: &SocketAddr) -> bool`[src]

`pub fn ne(&self, other: &SocketAddr) -> bool`[src]

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

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

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

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

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

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

`pub fn eq(&self, other: &Path) -> bool`[src]

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

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

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

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

`impl PartialEq<BacktraceStatus> for BacktraceStatus`[src]

`pub fn eq(&self, other: &BacktraceStatus) -> bool`[src]

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

`pub fn eq(&self, other: &PathBuf) -> bool`[src]

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

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

`impl PartialEq<FromBytesWithNulError> for FromBytesWithNulError`[src]

`pub fn eq(&self, other: &FromBytesWithNulError) -> bool`[src]

`pub fn ne(&self, other: &FromBytesWithNulError) -> bool`[src]

`impl PartialEq<ExitStatus> for ExitStatus`[src]

`pub fn eq(&self, other: &ExitStatus) -> bool`[src]

`pub fn ne(&self, other: &ExitStatus) -> bool`[src]

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

`pub fn eq(&self, other: &OsStr) -> bool`[src]

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

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

`impl PartialEq<StripPrefixError> for StripPrefixError`[src]

`pub fn eq(&self, other: &StripPrefixError) -> bool`[src]

`pub fn ne(&self, other: &StripPrefixError) -> bool`[src]

`impl PartialEq<str> for OsString`[src]

`pub fn eq(&self, other: &str) -> bool`[src]

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

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

`impl PartialEq<NulError> for NulError`[src]

`pub fn eq(&self, other: &NulError) -> bool`[src]

`pub fn ne(&self, other: &NulError) -> bool`[src]

`impl PartialEq<IpAddr> for Ipv4Addr`[src]

`pub fn eq(&self, other: &IpAddr) -> bool`[src]

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

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

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

`pub fn eq(&self, other: &OsString) -> bool`[src]

`impl PartialEq<FromVecWithNulError> for FromVecWithNulError`[src]

`pub fn eq(&self, other: &FromVecWithNulError) -> bool`[src]

`pub fn ne(&self, other: &FromVecWithNulError) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret`[src]

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

`impl PartialEq<IntErrorKind> for IntErrorKind`[src]

`pub fn eq(&self, other: &IntErrorKind) -> bool`[src]

`impl PartialEq<()> for ()`[src]

`pub fn eq(&self, _other: &()) -> bool`[src]

`pub fn ne(&self, _other: &()) -> bool`[src]

`impl PartialEq<NonZeroI128> for NonZeroI128`[src]

`pub fn eq(&self, other: &NonZeroI128) -> bool`[src]

`pub fn ne(&self, other: &NonZeroI128) -> bool`[src]

`impl PartialEq<NonZeroU128> for NonZeroU128`[src]

`pub fn eq(&self, other: &NonZeroU128) -> bool`[src]

`pub fn ne(&self, other: &NonZeroU128) -> bool`[src]

`impl PartialEq<AllocError> for AllocError`[src]

`pub fn eq(&self, other: &AllocError) -> bool`[src]

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

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

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

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

`impl PartialEq<NonZeroIsize> for NonZeroIsize`[src]

`pub fn eq(&self, other: &NonZeroIsize) -> bool`[src]

`pub fn ne(&self, other: &NonZeroIsize) -> bool`[src]

`impl<P, Q> PartialEq<Pin<Q>> for Pin where P: Deref, Q: Deref, ::Target: PartialEq<<Q as Deref>::Target>,` [src]

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

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

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

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

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

`impl PartialEq<FpCategory> for FpCategory`[src]

`pub fn eq(&self, other: &FpCategory) -> bool`[src]

`impl PartialEq<RawWakerVTable> for RawWakerVTable`[src]

`pub fn eq(&self, other: &RawWakerVTable) -> bool`[src]

`pub fn ne(&self, other: &RawWakerVTable) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H) -> Ret`[src]

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

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

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

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

`impl PartialEq<ParseCharError> for ParseCharError`[src]

`pub fn eq(&self, other: &ParseCharError) -> bool`[src]

`pub fn ne(&self, other: &ParseCharError) -> bool`[src]

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

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

`impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret`[src]

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

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret`[src]

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

`impl PartialEq<u32> for u32`[src]

`pub fn eq(&self, other: &u32) -> bool`[src]

`pub fn ne(&self, other: &u32) -> bool`[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret`[src]

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

`impl<Ret, A, B, C, D, E, F, G, H> PartialEq<fn(A, B, C, D, E, F, G, H) -> Ret> for fn(A, B, C, D, E, F, G, H) -> Ret`[src]

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

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

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

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

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

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

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

`impl PartialEq<ParseIntError> for ParseIntError`[src]

`pub fn eq(&self, other: &ParseIntError) -> bool`[src]

`pub fn ne(&self, other: &ParseIntError) -> bool`[src]

`impl<A, B, C, D, E, F, G, H, I, J, K> PartialEq<(A, B, C, D, E, F, G, H, I, J, K)> for (A, B, C, D, E, F, G, H, I, J, K) where C: PartialEq<C>, K: PartialEq<K> + ?Sized, A: PartialEq<A>, F: PartialEq<F>, E: PartialEq<E>, D: PartialEq<D>, I: PartialEq, B: PartialEq, G: PartialEq<G>, H: PartialEq<H>, J: PartialEq<J>,` [src]

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

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

`impl<Ret, A, B, C, D, E, F, G, H, I> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret`[src]

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

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

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

`impl<A, B, C, D, E, F, G, H, I, J, K, L> PartialEq<(A, B, C, D, E, F, G, H, I, J, K, L)> for (A, B, C, D, E, F, G, H, I, J, K, L) where C: PartialEq<C>, K: PartialEq<K>, A: PartialEq<A>, F: PartialEq<F>, E: PartialEq<E>, D: PartialEq<D>, I: PartialEq, B: PartialEq, G: PartialEq<G>, H: PartialEq<H>, J: PartialEq<J>, L: PartialEq<L> + ?Sized,` [src]

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

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

`impl<Ret, A, B, C, D, E, F, G, H, I> PartialEq<unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret`[src]

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

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

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

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

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

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

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

`pub fn eq(&self, other: &fn() -> Ret) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret`[src]

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

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

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

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

`impl<Ret, A, B, C, D, E, F, G, H> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret`[src]

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

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

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

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

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

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

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

`impl PartialEq<RawWaker> for RawWaker`[src]

`pub fn eq(&self, other: &RawWaker) -> bool`[src]

`pub fn ne(&self, other: &RawWaker) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret`[src]

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

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

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

`impl<T> PartialEq<mut T> for mut T where T: ?Sized,` [src]

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

`impl PartialEq<NonZeroI8> for NonZeroI8`[src]

`pub fn eq(&self, other: &NonZeroI8) -> bool`[src]

`pub fn ne(&self, other: &NonZeroI8) -> bool`[src]

`impl PartialEq<NonZeroI32> for NonZeroI32`[src]

`pub fn eq(&self, other: &NonZeroI32) -> bool`[src]

`pub fn ne(&self, other: &NonZeroI32) -> bool`[src]

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

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

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

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

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

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

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

`impl PartialEq<ParseBoolError> for ParseBoolError`[src]

`pub fn eq(&self, other: &ParseBoolError) -> bool`[src]

`pub fn ne(&self, other: &ParseBoolError) -> bool`[src]

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

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

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

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

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

`impl PartialEq<i64> for i64`[src]

`pub fn eq(&self, other: &i64) -> bool`[src]

`pub fn ne(&self, other: &i64) -> bool`[src]

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

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

`impl PartialEq<NonZeroU32> for NonZeroU32`[src]

`pub fn eq(&self, other: &NonZeroU32) -> bool`[src]

`pub fn ne(&self, other: &NonZeroU32) -> bool`[src]

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

`pub fn eq(&self, other: &fn(A) -> Ret) -> bool`[src]

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

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

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

`impl<Ret, A, B, C, D, E, F, G, H> PartialEq<unsafe fn(A, B, C, D, E, F, G, H) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H) -> Ret`[src]

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

`impl PartialEq<Duration> for Duration`[src]

`pub fn eq(&self, other: &Duration) -> bool`[src]

`pub fn ne(&self, other: &Duration) -> bool`[src]

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

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

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

`impl PartialEq<CharTryFromError> for CharTryFromError`[src]

`pub fn eq(&self, other: &CharTryFromError) -> bool`[src]

`pub fn ne(&self, other: &CharTryFromError) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialEq<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret`[src]

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

`impl PartialEq<ParseFloatError> for ParseFloatError`[src]

`pub fn eq(&self, other: &ParseFloatError) -> bool`[src]

`pub fn ne(&self, other: &ParseFloatError) -> bool`[src]

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

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

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

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret`[src]

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

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

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

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

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

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

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialEq<unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret`[src]

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

`impl<Ret, A, B, C, D, E, F, G, H, I> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret`[src]

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

`impl PartialEq<u64> for u64`[src]

`pub fn eq(&self, other: &u64) -> bool`[src]

`pub fn ne(&self, other: &u64) -> bool`[src]

`impl PartialEq<char> for char`[src]

`pub fn eq(&self, other: &char) -> bool`[src]

`pub fn ne(&self, other: &char) -> bool`[src]

`impl PartialEq<i8> for i8`[src]

`pub fn eq(&self, other: &i8) -> bool`[src]

`pub fn ne(&self, other: &i8) -> bool`[src]

`impl PartialEq<NonZeroU8> for NonZeroU8`[src]

`pub fn eq(&self, other: &NonZeroU8) -> bool`[src]

`pub fn ne(&self, other: &NonZeroU8) -> bool`[src]

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

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

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

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

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

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

`impl<Ret, A, B, C, D, E, F, G> PartialEq<extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret`[src]

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

`impl PartialEq<u128> for u128`[src]

`pub fn eq(&self, other: &u128) -> bool`[src]

`pub fn ne(&self, other: &u128) -> bool`[src]

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

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

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

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

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

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

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

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

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

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

`impl PartialEq<NonZeroU16> for NonZeroU16`[src]

`pub fn eq(&self, other: &NonZeroU16) -> bool`[src]

`pub fn ne(&self, other: &NonZeroU16) -> bool`[src]

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

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

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

`impl PartialEq<!> for !`[src]

`pub fn eq(&self, &!) -> bool`[src]

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

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

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialEq<fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret`[src]

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

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

`pub fn eq(&self, other: &unsafe fn() -> Ret) -> bool`[src]

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

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

`impl PartialEq<u8> for u8`[src]

`pub fn eq(&self, other: &u8) -> bool`[src]

`pub fn ne(&self, other: &u8) -> bool`[src]

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

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

`impl PartialEq<i32> for i32`[src]

`pub fn eq(&self, other: &i32) -> bool`[src]

`pub fn ne(&self, other: &i32) -> bool`[src]

`impl PartialEq<TryFromIntError> for TryFromIntError`[src]

`pub fn eq(&self, other: &TryFromIntError) -> bool`[src]

`pub fn ne(&self, other: &TryFromIntError) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialEq<fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for fn(A, B, C, D, E, F, G, H, I, J) -> Ret`[src]

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

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

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

`impl PartialEq<str> for str`[src]

`pub fn eq(&self, other: &str) -> bool`[src]

`pub fn ne(&self, other: &str) -> bool`[src]

`impl PartialEq<NonZeroI64> for NonZeroI64`[src]

`pub fn eq(&self, other: &NonZeroI64) -> bool`[src]

`pub fn ne(&self, other: &NonZeroI64) -> bool`[src]

`impl PartialEq<Utf8Error> for Utf8Error`[src]

`pub fn eq(&self, other: &Utf8Error) -> bool`[src]

`pub fn ne(&self, other: &Utf8Error) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret`[src]

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

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

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

`impl PartialEq<bool> for bool`[src]

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

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

`impl PartialEq<u16> for u16`[src]

`pub fn eq(&self, other: &u16) -> bool`[src]

`pub fn ne(&self, other: &u16) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret`[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret`[src]

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

`impl<Ret, A, B, C, D, E, F, G, H> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret`[src]

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

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

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

`impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret`[src]

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

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

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

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

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

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

`impl<Ret, A, B, C, D, E, F, G, H, I> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret`[src]

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

`impl PartialEq<NonZeroU64> for NonZeroU64`[src]

`pub fn eq(&self, other: &NonZeroU64) -> bool`[src]

`pub fn ne(&self, other: &NonZeroU64) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret`[src]

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

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

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

`impl PartialEq<CpuidResult> for CpuidResult`[src]

`pub fn eq(&self, other: &CpuidResult) -> bool`[src]

`pub fn ne(&self, other: &CpuidResult) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret`[src]

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

`impl<Ret, A, B, C, D, E, F, G> PartialEq<extern "C" fn(A, B, C, D, E, F, G) -> Ret> for extern "C" fn(A, B, C, D, E, F, G) -> Ret`[src]

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

`impl PartialEq<NonZeroI16> for NonZeroI16`[src]

`pub fn eq(&self, other: &NonZeroI16) -> bool`[src]

`pub fn ne(&self, other: &NonZeroI16) -> bool`[src]

`impl PartialEq<DecodeUtf16Error> for DecodeUtf16Error`[src]

`pub fn eq(&self, other: &DecodeUtf16Error) -> bool`[src]

`pub fn ne(&self, other: &DecodeUtf16Error) -> bool`[src]

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

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

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

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

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

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

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

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

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialEq<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret> for fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret`[src]

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

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

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

`impl PartialEq<f32> for f32`[src]

`pub fn eq(&self, other: &f32) -> bool`[src]

`pub fn ne(&self, other: &f32) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialEq<unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret`[src]

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

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

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

`impl PartialEq<i128> for i128`[src]

`pub fn eq(&self, other: &i128) -> bool`[src]

`pub fn ne(&self, other: &i128) -> bool`[src]

`impl<T, E> PartialEq<Result<T, E>> for Result<T, E> where T: PartialEq<T>, E: PartialEq<E>,` [src]

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

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

`impl PartialEq<i16> for i16`[src]

`pub fn eq(&self, other: &i16) -> bool`[src]

`pub fn ne(&self, other: &i16) -> bool`[src]

`impl PartialEq<f64> for f64`[src]

`pub fn eq(&self, other: &f64) -> bool`[src]

`pub fn ne(&self, other: &f64) -> bool`[src]

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

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

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

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

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

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

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

`impl PartialEq<SearchStep> for SearchStep`[src]

`pub fn eq(&self, other: &SearchStep) -> bool`[src]

`pub fn ne(&self, other: &SearchStep) -> bool`[src]

`impl PartialEq<LayoutError> for LayoutError`[src]

`pub fn eq(&self, other: &LayoutError) -> bool`[src]

`pub fn ne(&self, other: &LayoutError) -> bool`[src]

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

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

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret`[src]

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

`impl PartialEq<Layout> for Layout`[src]

`pub fn eq(&self, other: &Layout) -> bool`[src]

`pub fn ne(&self, other: &Layout) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I> PartialEq<fn(A, B, C, D, E, F, G, H, I) -> Ret> for fn(A, B, C, D, E, F, G, H, I) -> Ret`[src]

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

`impl PartialEq<isize> for isize`[src]

`pub fn eq(&self, other: &isize) -> bool`[src]

`pub fn ne(&self, other: &isize) -> bool`[src]

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

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

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

`impl PartialEq<NonZeroUsize> for NonZeroUsize`[src]

`pub fn eq(&self, other: &NonZeroUsize) -> bool`[src]

`pub fn ne(&self, other: &NonZeroUsize) -> bool`[src]

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

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

`impl PartialEq<usize> for usize`[src]

`pub fn eq(&self, other: &usize) -> bool`[src]

`pub fn ne(&self, other: &usize) -> bool`[src]

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

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

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

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

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

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

`impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret`[src]

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

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

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

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

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

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

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

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

`pub fn eq(&self, other: &String) -> bool`[src]

`pub fn ne(&self, other: &String) -> bool`[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`pub fn eq(&self, other: &String) -> bool`[src]

`pub fn ne(&self, other: &String) -> bool`[src]

`impl PartialEq<TryReserveError> for TryReserveError`[src]

`pub fn eq(&self, other: &TryReserveError) -> bool`[src]

`pub fn ne(&self, other: &TryReserveError) -> bool`[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`impl PartialEq<_Unwind_Action> for _Unwind_Action`

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

`impl PartialEq<_Unwind_Reason_Code> for _Unwind_Reason_Code`

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

`impl<T, S1, S2> PartialEq<IndexSet<T, S2>> for IndexSet<T, S1> where T: Hash + Eq, S1: BuildHasher, S2: BuildHasher,` [src]

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

`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>,` [src]

`pub fn eq(&self, other: &IndexMap<K, V2, S2>) -> bool`[src]

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

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

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

`impl PartialEq<Error> for Error`[src]

`pub fn eq(&self, other: &Error) -> bool`[src]

`pub fn ne(&self, other: &Error) -> bool`[src]

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

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

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

`impl PartialEq<ArchivedSocketAddrV4> for SocketAddrV4`[src]

`pub fn eq(&self, other: &ArchivedSocketAddrV4) -> bool`[src]

`impl PartialEq<ArchivedSocketAddrV6> for ArchivedSocketAddrV6`[src]

`pub fn eq(&self, other: &ArchivedSocketAddrV6) -> bool`[src]

`pub fn ne(&self, other: &ArchivedSocketAddrV6) -> bool`[src]

`impl<T, U> PartialEq<Vec<U, Global>> for ArchivedVec<T> where T: PartialEq,` [src]

`pub fn eq(&self, other: &Vec<U, Global>) -> bool`[src]

`impl PartialEq<ArchivedSocketAddrV6> for SocketAddrV6`[src]

`pub fn eq(&self, other: &ArchivedSocketAddrV6) -> bool`[src]

`impl<K, V, AK, AV, S> PartialEq<HashMap<K, V, S>> for ArchivedHashMap<AK, AV> where K: Hash + Eq + Borrow<AK>, S: BuildHasher, AK: Hash + Eq, AV: PartialEq<V>,` [src]

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

`impl PartialEq<SocketAddrV4> for ArchivedSocketAddrV4`[src]

`pub fn eq(&self, other: &SocketAddrV4) -> bool`[src]

`impl<T, U> PartialEq<RangeInclusive<T>> for ArchivedRangeInclusive where U: PartialEq<T>,` [src]

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

`impl PartialEq<ArchivedIpv4Addr> for Ipv4Addr`[src]

`pub fn eq(&self, other: &ArchivedIpv4Addr) -> bool`[src]

`impl PartialEq<ArchivedIpv6Addr> for Ipv6Addr`[src]

`pub fn eq(&self, other: &ArchivedIpv6Addr) -> bool`[src]

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

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

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

`impl PartialEq<Ipv4Addr> for ArchivedIpv4Addr`[src]

`pub fn eq(&self, other: &Ipv4Addr) -> bool`[src]

`impl<T, U> PartialEq<Option<T>> for ArchivedOption where U: PartialEq<T>,` [src]

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

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

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

`impl PartialEq<ArchivedSocketAddrV4> for ArchivedSocketAddrV4`[src]

`pub fn eq(&self, other: &ArchivedSocketAddrV4) -> bool`[src]

`pub fn ne(&self, other: &ArchivedSocketAddrV4) -> bool`[src]

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

`pub fn eq(&self, other: &ArchivedString) -> bool`[src]

`impl PartialEq<ArchivedSocketAddr> for SocketAddr`[src]

`pub fn eq(&self, other: &ArchivedSocketAddr) -> bool`[src]

`impl PartialEq<ArchivedIpv4Addr> for ArchivedIpv4Addr`[src]

`pub fn eq(&self, other: &ArchivedIpv4Addr) -> bool`[src]

`pub fn ne(&self, other: &ArchivedIpv4Addr) -> bool`[src]

`impl<K> PartialEq<ArchivedHashSet<K>> for ArchivedHashSet<K> where K: PartialEq<K> + Hash + Eq,` [src]

`pub fn eq(&self, other: &ArchivedHashSet<K>) -> bool`[src]

`pub fn ne(&self, other: &ArchivedHashSet<K>) -> bool`[src]

`impl PartialEq<ArchivedDuration> for ArchivedDuration`[src]

`pub fn eq(&self, other: &ArchivedDuration) -> bool`[src]

`pub fn ne(&self, other: &ArchivedDuration) -> bool`[src]

`impl<K, V, AK, AV> PartialEq<ArchivedHashMap<AK, AV>> for HashMap<K, V, RandomState> where K: Hash + Eq + Borrow<AK>, AK: Hash + Eq, AV: PartialEq<V>,` [src]

`pub fn eq(&self, other: &ArchivedHashMap<AK, AV>) -> bool`[src]

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

`pub fn eq(&self, other: &&str) -> bool`[src]

`impl PartialEq<ArchivedString> for ArchivedString`[src]

`pub fn eq(&self, other: &ArchivedString) -> bool`[src]

`impl PartialEq<ArchivedIpAddr> for IpAddr`[src]

`pub fn eq(&self, other: &ArchivedIpAddr) -> bool`[src]

`impl PartialEq<SocketAddrV6> for ArchivedSocketAddrV6`[src]

`pub fn eq(&self, other: &SocketAddrV6) -> bool`[src]

`impl PartialEq<IpAddr> for ArchivedIpAddr`[src]

`pub fn eq(&self, other: &IpAddr) -> bool`[src]

`impl PartialEq<ArchivedIpAddr> for ArchivedIpAddr`[src]

`pub fn eq(&self, other: &ArchivedIpAddr) -> bool`[src]

`pub fn ne(&self, other: &ArchivedIpAddr) -> bool`[src]

`impl<T, U> PartialEq<Rc> for ArchivedRc<T> where T: ArchivePointee + PartialEq + ?Sized, U: ?Sized,` [src]

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

`impl PartialEq<ArchivedIpv6Addr> for ArchivedIpv6Addr`[src]

`pub fn eq(&self, other: &ArchivedIpv6Addr) -> bool`[src]

`pub fn ne(&self, other: &ArchivedIpv6Addr) -> bool`[src]

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

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

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

`impl<T, U> PartialEq<Arc> for ArchivedArc<T> where T: ArchivePointee + PartialEq + ?Sized, U: ?Sized,` [src]

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

`impl<T, U> PartialEq<Range<T>> for ArchivedRange where U: PartialEq<T>,` [src]

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

`impl PartialEq<String> for ArchivedString`[src]

`pub fn eq(&self, other: &String) -> bool`[src]

`impl PartialEq<SocketAddr> for ArchivedSocketAddr`[src]

`pub fn eq(&self, other: &SocketAddr) -> bool`[src]

`impl PartialEq<Ipv6Addr> for ArchivedIpv6Addr`[src]

`pub fn eq(&self, other: &Ipv6Addr) -> bool`[src]

`impl<K, V> PartialEq<ArchivedHashMap<K, V>> for ArchivedHashMap<K, V> where K: Hash + Eq, V: PartialEq<V>,` [src]

`pub fn eq(&self, other: &ArchivedHashMap<K, V>) -> bool`[src]

`impl PartialEq<ArchivedSocketAddr> for ArchivedSocketAddr`[src]

`pub fn eq(&self, other: &ArchivedSocketAddr) -> bool`[src]

`pub fn ne(&self, other: &ArchivedSocketAddr) -> bool`[src]

`impl<T, U> PartialEq<ArchivedOption<T>> for Option where T: PartialEq,` [src]

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

`impl<T, U> PartialEq<Box<U, Global>> for ArchivedBox<T> where T: ArchivePointee + PartialEq + ?Sized, U: ?Sized,` [src]

`pub fn eq(&self, other: &Box<U, Global>) -> bool`[src]

`impl<Dyn> PartialEq<DynMetadata<Dyn>> for DynMetadata<Dyn> where Dyn: ?Sized,`

`pub fn eq(&self, other: &DynMetadata<Dyn>) -> bool`

Implementors

`impl PartialEq<ExportIndex> for ExportIndex`[src]

`fn eq(&self, other: &ExportIndex) -> bool`[src]

`fn ne(&self, other: &ExportIndex) -> bool`[src]

`impl PartialEq<ExternType> for ExternType`[src]

`fn eq(&self, other: &ExternType) -> bool`[src]

`fn ne(&self, other: &ExternType) -> bool`[src]

`impl PartialEq<GlobalInit> for GlobalInit`[src]

`fn eq(&self, other: &GlobalInit) -> bool`[src]

`fn ne(&self, other: &GlobalInit) -> bool`[src]

`impl PartialEq<ImportIndex> for ImportIndex`[src]

`fn eq(&self, other: &ImportIndex) -> bool`[src]

`fn ne(&self, other: &ImportIndex) -> bool`[src]

`impl PartialEq<Mutability> for Mutability`[src]

`fn eq(&self, other: &Mutability) -> bool`[src]

`impl PartialEq<Type> for Type`[src]

`fn eq(&self, other: &Type) -> bool`[src]

`impl PartialEq<Infallible> for Infallible`1.34.0[src]

`pub fn eq(&self, &Infallible) -> bool`[src]

`impl PartialEq<Ordering> for wasmer_types::lib::std::sync::atomic::Ordering`[src]

`pub fn eq(&self, other: &Ordering) -> bool`[src]

`impl PartialEq<RecvTimeoutError> for RecvTimeoutError`1.12.0[src]

`pub fn eq(&self, other: &RecvTimeoutError) -> bool`[src]

`impl PartialEq<TryRecvError> for TryRecvError`[src]

`pub fn eq(&self, other: &TryRecvError) -> bool`[src]

`impl PartialEq<Ordering> for wasmer_types::lib::std::cmp::Ordering`[src]

`pub fn eq(&self, other: &Ordering) -> bool`[src]

`impl PartialEq<Bytes> for Bytes`[src]

`fn eq(&self, other: &Bytes) -> bool`[src]

`fn ne(&self, other: &Bytes) -> bool`[src]

`impl PartialEq<CustomSectionIndex> for CustomSectionIndex`[src]

`fn eq(&self, other: &CustomSectionIndex) -> bool`[src]

`fn ne(&self, other: &CustomSectionIndex) -> bool`[src]

`impl PartialEq<DataIndex> for DataIndex`[src]

`fn eq(&self, other: &DataIndex) -> bool`[src]

`fn ne(&self, other: &DataIndex) -> bool`[src]

`impl PartialEq<DataInitializerLocation> for DataInitializerLocation`[src]

`fn eq(&self, other: &DataInitializerLocation) -> bool`[src]

`fn ne(&self, other: &DataInitializerLocation) -> bool`[src]

`impl PartialEq<ElemIndex> for ElemIndex`[src]

`fn eq(&self, other: &ElemIndex) -> bool`[src]

`fn ne(&self, other: &ElemIndex) -> bool`[src]

`impl PartialEq<ExternRef> for ExternRef`[src]

`fn eq(&self, other: &ExternRef) -> bool`[src]

`fn ne(&self, other: &ExternRef) -> bool`[src]

`impl PartialEq<Features> for Features`[src]

`fn eq(&self, other: &Features) -> bool`[src]

`fn ne(&self, other: &Features) -> bool`[src]

`impl PartialEq<FunctionIndex> for FunctionIndex`[src]

`fn eq(&self, other: &FunctionIndex) -> bool`[src]

`fn ne(&self, other: &FunctionIndex) -> bool`[src]

`impl PartialEq<FunctionType> for FunctionType`[src]

`fn eq(&self, other: &FunctionType) -> bool`[src]

`fn ne(&self, other: &FunctionType) -> bool`[src]

`impl PartialEq<GlobalIndex> for GlobalIndex`[src]

`fn eq(&self, other: &GlobalIndex) -> bool`[src]

`fn ne(&self, other: &GlobalIndex) -> bool`[src]

`impl PartialEq<GlobalType> for GlobalType`[src]

`fn eq(&self, other: &GlobalType) -> bool`[src]

`fn ne(&self, other: &GlobalType) -> bool`[src]

`impl PartialEq<LocalFunctionIndex> for LocalFunctionIndex`[src]

`fn eq(&self, other: &LocalFunctionIndex) -> bool`[src]

`fn ne(&self, other: &LocalFunctionIndex) -> bool`[src]

`impl PartialEq<LocalGlobalIndex> for LocalGlobalIndex`[src]

`fn eq(&self, other: &LocalGlobalIndex) -> bool`[src]

`fn ne(&self, other: &LocalGlobalIndex) -> bool`[src]

`impl PartialEq<LocalMemoryIndex> for LocalMemoryIndex`[src]

`fn eq(&self, other: &LocalMemoryIndex) -> bool`[src]

`fn ne(&self, other: &LocalMemoryIndex) -> bool`[src]

`impl PartialEq<LocalTableIndex> for LocalTableIndex`[src]

`fn eq(&self, other: &LocalTableIndex) -> bool`[src]

`fn ne(&self, other: &LocalTableIndex) -> bool`[src]

`impl PartialEq<MemoryIndex> for MemoryIndex`[src]

`fn eq(&self, other: &MemoryIndex) -> bool`[src]

`fn ne(&self, other: &MemoryIndex) -> bool`[src]

`impl PartialEq<MemoryType> for MemoryType`[src]

`fn eq(&self, other: &MemoryType) -> bool`[src]

`fn ne(&self, other: &MemoryType) -> bool`[src]

`impl PartialEq<OwnedDataInitializer> for OwnedDataInitializer`[src]

`fn eq(&self, other: &OwnedDataInitializer) -> bool`[src]

`fn ne(&self, other: &OwnedDataInitializer) -> bool`[src]

`impl PartialEq<PageCountOutOfRange> for PageCountOutOfRange`[src]

`fn eq(&self, other: &PageCountOutOfRange) -> bool`[src]

`impl PartialEq<Pages> for Pages`[src]

`fn eq(&self, other: &Pages) -> bool`[src]

`fn ne(&self, other: &Pages) -> bool`[src]

`impl PartialEq<SignatureIndex> for SignatureIndex`[src]

`fn eq(&self, other: &SignatureIndex) -> bool`[src]

`fn ne(&self, other: &SignatureIndex) -> bool`[src]

`impl PartialEq<TableIndex> for TableIndex`[src]

`fn eq(&self, other: &TableIndex) -> bool`[src]

`fn ne(&self, other: &TableIndex) -> bool`[src]

`impl PartialEq<TableInitializer> for TableInitializer`[src]

`fn eq(&self, other: &TableInitializer) -> bool`[src]

`fn ne(&self, other: &TableInitializer) -> bool`[src]

`impl PartialEq<TableType> for TableType`[src]

`fn eq(&self, other: &TableType) -> bool`[src]

`fn ne(&self, other: &TableType) -> bool`[src]

`impl PartialEq<V128> for V128`[src]

`fn eq(&self, other: &V128) -> bool`[src]

`fn ne(&self, other: &V128) -> bool`[src]

`impl PartialEq<VMExternRef> for VMExternRef`[src]

`fn eq(&self, other: &VMExternRef) -> bool`[src]

`fn ne(&self, other: &VMExternRef) -> bool`[src]

`impl PartialEq<TypeId> for TypeId`[src]

`pub fn eq(&self, other: &TypeId) -> bool`[src]

`pub fn ne(&self, other: &TypeId) -> bool`[src]

`impl PartialEq<Error> for wasmer_types::lib::std::fmt::Error`[src]

`pub fn eq(&self, other: &Error) -> bool`[src]

`impl PartialEq<PhantomPinned> for PhantomPinned`1.33.0[src]

`pub fn eq(&self, other: &PhantomPinned) -> bool`[src]

`impl PartialEq<RangeFull> for RangeFull`[src]

`pub fn eq(&self, other: &RangeFull) -> bool`[src]

`impl PartialEq<FromUtf8Error> for FromUtf8Error`[src]

`pub fn eq(&self, other: &FromUtf8Error) -> bool`[src]

`pub fn ne(&self, other: &FromUtf8Error) -> bool`[src]

`impl PartialEq<String> for String`[src]

`pub fn eq(&self, other: &String) -> bool`[src]

`pub fn ne(&self, other: &String) -> bool`[src]

`impl PartialEq<RecvError> for RecvError`[src]

`pub fn eq(&self, other: &RecvError) -> bool`[src]

`impl PartialEq<WaitTimeoutResult> for WaitTimeoutResult`1.5.0[src]

`pub fn eq(&self, other: &WaitTimeoutResult) -> bool`[src]

`pub fn ne(&self, other: &WaitTimeoutResult) -> bool`[src]

`impl PartialEq<ArchivedString> for String`[src]

`pub fn eq(&self, other: &ArchivedString) -> bool`[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`impl<'_, T, U, A, const N: usize> PartialEq<&'_ [U; N]> for Vec<T, A> where T: PartialEq, A: Allocator,` [src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`pub fn eq(&self, other: &str) -> bool`[src]

`pub fn ne(&self, other: &str) -> bool`[src]

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

`pub fn eq(&self, other: &str) -> bool`[src]

`pub fn ne(&self, other: &str) -> bool`[src]

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

`pub fn eq(&self, other: &String) -> bool`[src]

`pub fn ne(&self, other: &String) -> bool`[src]

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

`pub fn eq(&self, other: &OsStr) -> bool`[src]

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

`pub fn eq(&self, other: &OsStr) -> bool`[src]

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

`pub fn eq(&self, other: &OsString) -> bool`[src]

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

`pub fn eq(&self, other: &OsString) -> bool`[src]

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

`pub fn eq(&self, other: &Path) -> bool`[src]

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

`pub fn eq(&self, other: &Path) -> bool`[src]

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

`pub fn eq(&self, other: &PathBuf) -> bool`[src]

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

`pub fn eq(&self, other: &PathBuf) -> bool`[src]

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

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

`impl<B, C> PartialEq<ControlFlow<B, C>> for ControlFlow<B, C> where C: PartialEq<C>, B: PartialEq,` [src]

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

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

`impl<Dyn> PartialEq<DynMetadata<Dyn>> for wasmer_types::lib::std::ptr::DynMetadata<Dyn> where Dyn: ?Sized,` [src]

`pub fn eq(&self, other: &DynMetadata<Dyn>) -> bool`[src]

`impl<H> PartialEq<BuildHasherDefault<H>> for BuildHasherDefault<H>`1.29.0[src]

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

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

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

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

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

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

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

`impl<Idx> PartialEq<RangeInclusive<Idx>> for RangeInclusive<Idx> where Idx: PartialEq<Idx>,` 1.26.0[src]

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

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

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

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

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

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

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

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

`impl<K, V> PartialEq<SecondaryMap<K, V>> for SecondaryMap<K, V> where K: EntityRef, V: Clone + PartialEq,` [src]

`fn eq(&self, other: &Self) -> bool`[src]

`impl<K: PartialEq, V: PartialEq> PartialEq<PrimaryMap<K, V>> for PrimaryMap<K, V> where K: EntityRef,` [src]

`fn eq(&self, other: &PrimaryMap<K, V>) -> bool`[src]

`fn ne(&self, other: &PrimaryMap<K, V>) -> bool`[src]

`impl<T> PartialEq<Bound<T>> for Bound<T> where T: PartialEq<T>,` 1.17.0[src]

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

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

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

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

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

`impl<T> PartialEq<Cell<T>> for Cell<T> where T: PartialEq<T> + Copy,` [src]

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

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

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

Panics

Panics if the value in either RefCell is currently borrowed.

`impl<T> PartialEq<PhantomData<T>> for PhantomData<T> where T: ?Sized,` [src]

`pub fn eq(&self, _other: &PhantomData<T>) -> bool`[src]

`impl<T> PartialEq<Discriminant<T>> for Discriminant<T>`1.21.0[src]

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

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

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

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

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

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

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

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

Equality for two Rcs.

Two Rcs are equal if their inner values are equal, even if they are stored in different allocation.

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

Examples

use std::rc::Rc;

let five = Rc::new(5);

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

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

Inequality for two Rcs.

Two Rcs are unequal if their inner values are unequal.

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

Examples

use std::rc::Rc;

let five = Rc::new(5);

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

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

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

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

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

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

Equality for two Arcs.

Two Arcs are equal if their inner values are equal, even if they are stored in different allocation.

If T also implements Eq (implying reflexivity of equality), two Arcs that point to the same allocation are always equal.

Examples

use std::sync::Arc;

let five = Arc::new(5);

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

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

Inequality for two Arcs.

Two Arcs are unequal if their inner values are unequal.

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

Examples

use std::sync::Arc;

let five = Arc::new(5);

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

`impl<T> PartialEq<Reverse<T>> for Reverse<T> where T: PartialEq<T>,` 1.19.0[src]

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

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

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

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

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

`impl<T, U> PartialEq<ArchivedVec> for Vec<T, Global> where T: PartialEq,` [src]

`pub fn eq(&self, other: &ArchivedVec) -> bool`[src]

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

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

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

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

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

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

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

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

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

`impl<T: PartialEq + ReservedValue> PartialEq<PackedOption<T>> for PackedOption<T>`[src]

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

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

`impl<T: PartialEq> PartialEq<Value<T>> for Value<T>`[src]

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

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

`impl<T: PartialEq> PartialEq<ExportType<T>> for ExportType<T>`[src]

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

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

`impl<T: PartialEq> PartialEq<ImportType<T>> for ImportType<T>`[src]

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

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

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

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

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

Trait wasmer_types::lib::std::cmp::PartialEq1.0.0[−][src]

Derivable

How can I implement PartialEq?

How can I compare two different types?

Examples

Required methods

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

Provided methods

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

Implementations on Foreign Types

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

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

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

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

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

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

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

impl PartialEq<ErrorKind> for ErrorKind[src]

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

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

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

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

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

impl PartialEq<Instant> for Instant[src]

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

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

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

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

impl PartialEq<Output> for Output[src]

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

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

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

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

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

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

impl PartialEq<str> for OsStr[src]

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

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

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

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

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

impl PartialEq<ExitStatusError> for ExitStatusError[src]

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

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

impl PartialEq<OsStr> for str[src]

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

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

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

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

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

impl PartialEq<AccessError> for AccessError[src]

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

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

impl PartialEq<SocketAddrV4> for SocketAddrV4[src]

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

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

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

impl PartialEq<FileType> for FileType[src]

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

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

impl PartialEq<SystemTime> for SystemTime[src]

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

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

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

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

impl PartialEq<UCred> for UCred[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

How can I implement `PartialEq`?

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

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

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

`pub fn eq(&self, other: &OsString) -> bool`[src]

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

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

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

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

`pub fn eq(&self, other: &Path) -> bool`[src]

`impl PartialEq<ErrorKind> for ErrorKind`[src]

`pub fn eq(&self, other: &ErrorKind) -> bool`[src]

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

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

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

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

`impl PartialEq<Instant> for Instant`[src]

`pub fn eq(&self, other: &Instant) -> bool`[src]

`pub fn ne(&self, other: &Instant) -> bool`[src]

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

`pub fn eq(&self, other: &OsString) -> bool`[src]

`impl PartialEq<Output> for Output`[src]

`pub fn eq(&self, other: &Output) -> bool`[src]

`pub fn ne(&self, other: &Output) -> bool`[src]

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

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

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

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

`impl PartialEq<str> for OsStr`[src]

`pub fn eq(&self, other: &str) -> bool`[src]

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

`pub fn eq(&self, other: &PathBuf) -> bool`[src]

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

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

`impl PartialEq<ExitStatusError> for ExitStatusError`[src]

`pub fn eq(&self, other: &ExitStatusError) -> bool`[src]

`pub fn ne(&self, other: &ExitStatusError) -> bool`[src]

`impl PartialEq<OsStr> for str`[src]

`pub fn eq(&self, other: &OsStr) -> bool`[src]

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

`pub fn eq(&self, other: &Path) -> bool`[src]

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

`pub fn eq(&self, other: &OsStr) -> bool`[src]

`impl PartialEq<AccessError> for AccessError`[src]

`pub fn eq(&self, other: &AccessError) -> bool`[src]

`pub fn ne(&self, other: &AccessError) -> bool`[src]

`impl PartialEq<SocketAddrV4> for SocketAddrV4`[src]

`pub fn eq(&self, other: &SocketAddrV4) -> bool`[src]

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

`pub fn eq(&self, other: &&str) -> bool`[src]

`impl PartialEq<FileType> for FileType`[src]

`pub fn eq(&self, other: &FileType) -> bool`[src]

`pub fn ne(&self, other: &FileType) -> bool`[src]

`impl PartialEq<SystemTime> for SystemTime`[src]

`pub fn eq(&self, other: &SystemTime) -> bool`[src]

`pub fn ne(&self, other: &SystemTime) -> bool`[src]

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

`pub fn eq(&self, other: &PathBuf) -> bool`[src]

`impl PartialEq<UCred> for UCred`[src]

`pub fn eq(&self, other: &UCred) -> bool`[src]

`pub fn ne(&self, other: &UCred) -> bool`[src]

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

`pub fn eq(&self, other: &OsStr) -> bool`[src]

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

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

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

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

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

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

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

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

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

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

`impl PartialEq<IpAddr> for Ipv6Addr`[src]

`pub fn eq(&self, other: &IpAddr) -> bool`[src]

`impl PartialEq<IpAddr> for IpAddr`[src]

`pub fn eq(&self, other: &IpAddr) -> bool`[src]

`pub fn ne(&self, other: &IpAddr) -> bool`[src]

`impl PartialEq<SeekFrom> for SeekFrom`[src]

`pub fn eq(&self, other: &SeekFrom) -> bool`[src]