Trait nom::lib::std::prelude::v1::rust_2021::PartialEq1.0.0[−][src]

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

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

Trait for equality comparisons which are partial equivalence relations.

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

Formally, the equality must be (for all a, b, 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]pub fn eq(&self, other: &Rhs) -> bool`[src]

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

Loading content...

Provided methods

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

This method tests for !=.

Loading content...

Implementations on Foreign Types

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

`pub fn eq(&self, other: &Ipv6Addr) -> 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<&'a Path> for PathBuf`[src]

`pub fn eq(&self, other: &&'a Path) -> 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 PartialEq<OsStr> for str`[src]

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

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

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

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

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

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

`pub fn eq(&self, other: &TryRecvError) -> 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<'a, 'b> PartialEq<PathBuf> for OsString`[src]

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

`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<SyncOnceCell<T>> for SyncOnceCell<T> where T: PartialEq<T>,` [src]

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

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

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

`pub fn eq(&self, other: &Shutdown) -> 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<'a, 'b> PartialEq<OsStr> for &'a Path`[src]

`pub fn eq(&self, other: &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<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<'b, OsStr>> for &'a Path`[src]

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

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

`pub fn eq(&self, other: &RecvTimeoutError) -> 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<'a, 'b> PartialEq<OsStr> for PathBuf`[src]

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

`impl<'a, 'b> PartialEq<Cow<'a, Path>> for OsString`[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<PathBuf> for PathBuf`[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<'a, 'b> PartialEq<Path> for PathBuf`[src]

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

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

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

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

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

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

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

`pub fn eq(&self, other: &OsString) -> 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<'a> PartialEq<Components<'a>> for Components<'a>`[src]

`pub fn eq(&self, other: &Components<'a>) -> 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 PartialEq<SocketAddrV6> for SocketAddrV6`[src]

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

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

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

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

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

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

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

`pub fn eq(&self, other: &IpAddr) -> 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 PartialEq<Ipv4Addr> for IpAddr`[src]

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

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

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

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

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

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

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

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

`pub fn eq(&self, other: &&str) -> 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<ThreadId> for ThreadId`[src]

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

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

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

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

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

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

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

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

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

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

`pub fn eq(&self, other: &Cow<'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<'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 PartialEq<Permissions> for Permissions`[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`pub fn eq(&self, other: &OsString) -> 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 PartialEq<IpAddr> for Ipv4Addr`[src]

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

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

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

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

`pub fn eq(&self, other: &PathBuf) -> 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<Cow<'a, Path>> for PathBuf`[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`pub fn ne(&self, other: &IpAddr) -> 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<Cow<'a, Path>> for OsStr`[src]

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

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

`pub fn eq(&self, other: &OsString) -> 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<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> 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> 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<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, 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, 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 PartialEq<i32> for i32`[src]

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

`pub fn ne(&self, other: &i32) -> 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 PartialEq<u8> for u8`[src]

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

`pub fn ne(&self, other: &u8) -> 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<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<A, B, C, D> PartialEq<(A, B, C, D)> for (A, B, C, D) where C: PartialEq<C>, A: PartialEq<A>, B: PartialEq, D: PartialEq<D> + ?Sized,` [src]

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

`pub fn ne(&self, other: &(A, B, C, D)) -> 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, 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> PartialEq<unsafe fn(A) -> Ret> for unsafe fn(A) -> Ret`[src]

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

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

`pub fn eq(&self, other: &DynMetadata<Dyn>) -> 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<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> PartialEq<unsafe fn() -> Ret> for unsafe fn() -> Ret`[src]

`pub fn eq(&self, other: &unsafe fn() -> Ret) -> 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<ParseFloatError> for ParseFloatError`[src]

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

`pub fn ne(&self, other: &ParseFloatError) -> 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, 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<Ret, A> PartialEq<fn(A) -> Ret> for fn(A) -> Ret`[src]

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

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

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

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

`pub fn eq(&self, other: &PhantomPinned) -> 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, 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, 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> 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> 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, 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<()> for ()`[src]

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

`pub fn ne(&self, _other: &()) -> 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> 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<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<NonZeroIsize> for NonZeroIsize`[src]

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

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

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

`pub fn eq(&self, &!) -> 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 PartialEq<RawWakerVTable> for RawWakerVTable`[src]

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

`pub fn ne(&self, other: &RawWakerVTable) -> 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<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<i128> for i128`[src]

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

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

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

`pub fn eq(&self, other: &FpCategory) -> 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<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<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<T> PartialEq<const T> for const T where T: ?Sized,` [src]

`pub fn eq(&self, other: &*const 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<T> PartialEq<NonNull<T>> for NonNull<T> where T: ?Sized,` [src]

`pub fn eq(&self, other: &NonNull<T>) -> 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, 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<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 PartialEq<DecodeUtf16Error> for DecodeUtf16Error`[src]

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

`pub fn ne(&self, other: &DecodeUtf16Error) -> 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<'_, 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<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> 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, 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 PartialEq<u16> for u16`[src]

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

`pub fn ne(&self, other: &u16) -> 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<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<NonZeroI128> for NonZeroI128`[src]

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

`pub fn ne(&self, other: &NonZeroI128) -> 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<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<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<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<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>, F: PartialEq<F>, E: PartialEq<E>, G: PartialEq<G>, H: PartialEq<H> + ?Sized, A: PartialEq<A>, B: PartialEq, D: PartialEq<D>,` [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<T> PartialEq<PhantomData<T>> for PhantomData<T> where T: ?Sized,` [src]

`pub fn eq(&self, _other: &PhantomData<T>) -> 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, 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, 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, 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<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 PartialEq<f64> for f64`[src]

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

`pub fn ne(&self, other: &f64) -> 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<'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<NonZeroI32> for NonZeroI32`[src]

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

`pub fn ne(&self, other: &NonZeroI32) -> 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>, F: PartialEq<F>, E: PartialEq<E>, I: PartialEq, G: PartialEq<G>, H: PartialEq<H>, A: PartialEq<A>, B: PartialEq, D: PartialEq<D>, J: PartialEq<J>, K: PartialEq<K>, 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<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<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, 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<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<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, 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<'_, 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<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<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<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 PartialEq<NonZeroU32> for NonZeroU32`[src]

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

`pub fn ne(&self, other: &NonZeroU32) -> 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, C, D, E, F> PartialEq<(A, B, C, D, E, F)> for (A, B, C, D, E, F) where C: PartialEq<C>, F: PartialEq<F> + ?Sized, E: PartialEq<E>, A: PartialEq<A>, B: PartialEq, D: PartialEq<D>,` [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<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<'_, '_, 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<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>, F: PartialEq<F>, E: PartialEq<E>, G: PartialEq<G> + ?Sized, A: PartialEq<A>, B: PartialEq, D: PartialEq<D>,` [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, 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<char> for char`[src]

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

`pub fn ne(&self, other: &char) -> 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<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> 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> 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 PartialEq<RawWaker> for RawWaker`[src]

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

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

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

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

`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, D: PartialEq<D>,` [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<u32> for u32`[src]

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

`pub fn ne(&self, other: &u32) -> 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<u128> for u128`[src]

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

`pub fn ne(&self, other: &u128) -> 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 PartialEq<IntErrorKind> for IntErrorKind`[src]

`pub fn eq(&self, other: &IntErrorKind) -> 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> PartialEq<extern "C" fn() -> Ret> for extern "C" fn() -> Ret`[src]

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

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

`pub fn ne(&self, other: &NonZeroI64) -> 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 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> 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, 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 PartialEq<NonZeroU8> for NonZeroU8`[src]

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

`pub fn ne(&self, other: &NonZeroU8) -> 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<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<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<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, 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<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<T> PartialEq<mut T> for mut T where T: ?Sized,` [src]

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

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

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

`pub fn eq(&self, other: &Ordering) -> 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 PartialEq<bool> for bool`[src]

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

`pub fn ne(&self, other: &bool) -> 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 PartialEq<ParseCharError> for ParseCharError`[src]

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

`pub fn ne(&self, other: &ParseCharError) -> 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<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> 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<str> for str`[src]

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

`pub fn ne(&self, other: &str) -> 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 PartialEq<NonZeroUsize> for NonZeroUsize`[src]

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

`pub fn ne(&self, other: &NonZeroUsize) -> 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<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> 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 PartialEq<i64> for i64`[src]

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

`pub fn ne(&self, other: &i64) -> 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>, F: PartialEq<F>, E: PartialEq<E>, I: PartialEq, G: PartialEq<G>, H: PartialEq<H>, A: PartialEq<A>, B: PartialEq, D: PartialEq<D>, 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 PartialEq<i8> for i8`[src]

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

`pub fn ne(&self, other: &i8) -> 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<Duration> for Duration`[src]

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

`pub fn ne(&self, other: &Duration) -> 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 PartialEq<CpuidResult> for CpuidResult`[src]

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

`pub fn ne(&self, other: &CpuidResult) -> 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>, F: PartialEq<F>, E: PartialEq<E>, I: PartialEq + ?Sized, G: PartialEq<G>, H: PartialEq<H>, A: PartialEq<A>, B: PartialEq, D: PartialEq<D>,` [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> 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<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<CharTryFromError> for CharTryFromError`[src]

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

`pub fn ne(&self, other: &CharTryFromError) -> 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<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<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, 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<'a, 'b> PartialEq<String> for str`[src]

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

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

Loading content...

Implementors

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

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

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

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

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

`impl PartialEq<ErrorKind> for nom::error::ErrorKind`[src]

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

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

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

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

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

`pub fn eq(&self, other: &Ordering) -> 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 PartialEq<Infallible> for Infallible`1.34.0[src]

`pub fn eq(&self, &Infallible) -> 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<Endianness> for Endianness`[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`pub fn eq(&self, other: &NoneError) -> 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 PartialEq<Utf8Error> for Utf8Error`[src]

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

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

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

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

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

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

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

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

`pub fn eq(&self, other: &&mut [B; N]) -> 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<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<Vec<B, Global>> for VecDeque<A> where A: PartialEq,` 1.17.0[src]

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

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

`pub fn eq(&self, other: &[B; N]) -> 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<E: PartialEq> PartialEq<Err<E>> for Err<E>`[src]

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

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

`impl<H> PartialEq<BuildHasherDefault<H>> for BuildHasherDefault<H>`1.29.0[src]

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

`impl<I: PartialEq> PartialEq<VerboseError> for VerboseError`[src]

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

`fn ne(&self, other: &VerboseError) -> 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<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<K, V, S> PartialEq<HashMap<K, V, S>> for HashMap<K, V, S> where K: Eq + Hash, S: BuildHasher, V: PartialEq<V>,` [src]

`pub fn eq(&self, other: &HashMap<K, V, S>) -> 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<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<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> 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<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<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, 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, E> PartialEq<Result<T, E>> for Result<T, E> where E: PartialEq<E>, T: PartialEq<T>,` [src]

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

`pub fn ne(&self, other: &Result<T, E>) -> 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<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<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]

Loading content...

Trait nom::lib::std::prelude::v1::rust_2021::PartialEq⎘1.0.0[−][src]

Derivable

How can I implement PartialEq?

How can I compare two different types?

Examples

Required methods

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

Provided methods

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

Implementations on Foreign Types

impl PartialEq<Ipv6Addr> for Ipv6Addr[src]

pub fn eq(&self, other: &Ipv6Addr) -> 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<&'a Path> for PathBuf[src]

pub fn eq(&self, other: &&'a Path) -> 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 PartialEq<OsStr> for str[src]

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

impl PartialEq<CStr> for CStr[src]

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

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

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

impl PartialEq<TryRecvError> for TryRecvError[src]

pub fn eq(&self, other: &TryRecvError) -> 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<'a, 'b> PartialEq<PathBuf> for OsString[src]

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

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

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

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

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

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

pub fn eq(&self, other: &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<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<'b, OsStr>> for &'a Path[src]

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

impl PartialEq<RecvTimeoutError> for RecvTimeoutError[src]

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

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

impl<'a, 'b> PartialEq<Cow<'a, Path>> for OsString[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<PathBuf> for PathBuf[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<'a, 'b> PartialEq<Path> for PathBuf[src]

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

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

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

impl PartialEq<Path> for Path[src]

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

impl PartialEq<AccessError> for AccessError[src]

Trait nom::lib::std::prelude::v1::rust_2021::PartialEq1.0.0[−][src]

How can I implement `PartialEq`?

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

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

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

`pub fn eq(&self, other: &Ipv6Addr) -> 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<&'a Path> for PathBuf`[src]

`pub fn eq(&self, other: &&'a Path) -> 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 PartialEq<OsStr> for str`[src]

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

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

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

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

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

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

`pub fn eq(&self, other: &TryRecvError) -> 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<'a, 'b> PartialEq<PathBuf> for OsString`[src]

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

`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<SyncOnceCell<T>> for SyncOnceCell<T> where T: PartialEq<T>,` [src]

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

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

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

`pub fn eq(&self, other: &Shutdown) -> 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<'a, 'b> PartialEq<OsStr> for &'a Path`[src]

`pub fn eq(&self, other: &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<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<'b, OsStr>> for &'a Path`[src]

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

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

`pub fn eq(&self, other: &RecvTimeoutError) -> 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<'a, 'b> PartialEq<OsStr> for PathBuf`[src]

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

`impl<'a, 'b> PartialEq<Cow<'a, Path>> for OsString`[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<PathBuf> for PathBuf`[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<'a, 'b> PartialEq<Path> for PathBuf`[src]

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

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

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

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

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

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

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

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