Trait nom::lib::std::cmp::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<NulError> for NulError`[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`impl PartialEq<OsString> for 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 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<&'a OsStr> for PathBuf`[src]

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

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

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

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

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

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

`impl<'a, 'b> PartialEq<PathBuf> for &'a OsStr`[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 PartialEq<IntoStringError> for IntoStringError`[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`impl<'_, O1, O2, T1, T2> PartialEq<BitBox<O2, T2>> for &'_ BitSlice<O1, T1> where O2: BitOrder, O1: BitOrder, T1: BitStore, T2: BitStore,` [src]

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

`impl<O1, O2, T1, T2> PartialEq<BitVec<O2, T2>> for BitSlice<O1, T1> where O2: BitOrder, O1: BitOrder, T1: BitStore, T2: BitStore,` [src]

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

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

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

`impl<O, V, T> PartialEq<BitArray<O, V>> for BitSlice<O, T> where O: BitOrder, T: BitStore, V: BitView,` [src]

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

`impl<'_, O1, O2, T1, T2> PartialEq<BitSlice<O2, T2>> for &'_ BitSlice<O1, T1> where O2: BitOrder, O1: BitOrder, T1: BitStore, T2: BitStore,` [src]

`pub fn eq(&self, rhs: &BitSlice<O2, T2>) -> bool`[src]

`impl<R> PartialEq<BitTail<R>> for BitTail<R> where R: PartialEq<R> + BitRegister,` [src]

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

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

`impl<R> PartialEq<BitMask<R>> for BitMask<R> where R: PartialEq<R> + BitRegister,` [src]

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

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

`impl<'_, O1, O2, T1, T2> PartialEq<&'_ BitSlice<O2, T2>> for BitSlice<O1, T1> where O2: BitOrder, O1: BitOrder, T1: BitStore, T2: BitStore,` [src]

`pub fn eq(&self, rhs: &&BitSlice<O2, T2>) -> bool`[src]

`impl<'_, O1, O2, T1, T2> PartialEq<&'_ mut BitSlice<O2, T2>> for BitSlice<O1, T1> where O2: BitOrder, O1: BitOrder, T1: BitStore, T2: BitStore,` [src]

`pub fn eq(&self, rhs: &&mut BitSlice<O2, T2>) -> bool`[src]

`impl<O, T, Rhs> PartialEq<Rhs> for BitVec<O, T> where O: BitOrder, T: BitStore, Rhs: PartialEq<BitSlice<O, T>> + ?Sized,` [src]

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

`impl<O1, O2, T1, T2> PartialEq<BitSlice<O2, T2>> for BitSlice<O1, T1> where O2: BitOrder, O1: BitOrder, T1: BitStore, T2: BitStore,` [src]

Tests if two BitSlices are semantically — not bitwise — equal.

It is valid to compare slices of different ordering or memory types.

The equality condition requires that they have the same length and that at each index, the two slices have the same bit value.

`pub fn eq(&self, rhs: &BitSlice<O2, T2>) -> bool`[src]

`impl<O, V, Rhs> PartialEq<Rhs> for BitArray<O, V> where O: BitOrder, Rhs: ?Sized, V: BitView, BitSlice<O, <V as BitView>::Store>: PartialEq<Rhs>,` [src]

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

`impl<O, T, Rhs> PartialEq<Rhs> for BitBox<O, T> where O: BitOrder, T: BitStore, Rhs: PartialEq<BitSlice<O, T>> + ?Sized,` [src]

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

`impl<R> PartialEq<BitIdx<R>> for BitIdx<R> where R: PartialEq<R> + BitRegister,` [src]

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

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

`impl<'_, O1, O2, T1, T2> PartialEq<BitVec<O2, T2>> for &'_ mut BitSlice<O1, T1> where O2: BitOrder, O1: BitOrder, T1: BitStore, T2: BitStore,` [src]

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

`impl<R> PartialEq<BitSel<R>> for BitSel<R> where R: PartialEq<R> + BitRegister,` [src]

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

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

`impl<'_, O1, O2, T1, T2> PartialEq<BitSlice<O2, T2>> for &'_ mut BitSlice<O1, T1> where O2: BitOrder, O1: BitOrder, T1: BitStore, T2: BitStore,` [src]

`pub fn eq(&self, rhs: &BitSlice<O2, T2>) -> bool`[src]

`impl<'_, O1, O2, T1, T2> PartialEq<BitBox<O2, T2>> for &'_ mut BitSlice<O1, T1> where O2: BitOrder, O1: BitOrder, T1: BitStore, T2: BitStore,` [src]

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

`impl<R> PartialEq<BitPos<R>> for BitPos<R> where R: PartialEq<R> + BitRegister,` [src]

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

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

`impl<'_, O1, O2, T1, T2> PartialEq<BitVec<O2, T2>> for &'_ BitSlice<O1, T1> where O2: BitOrder, O1: BitOrder, T1: BitStore, T2: BitStore,` [src]

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

`impl<O1, O2, T1, T2> PartialEq<BitBox<O2, T2>> for BitSlice<O1, T1> where O2: BitOrder, O1: BitOrder, T1: BitStore, T2: BitStore,` [src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`pub fn eq(&self, rhs: &ArrayString<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> PartialEq<Match<'t>> for Match<'t>`[src]

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

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

`impl<'t> PartialEq<Match<'t>> for Match<'t>`[src]

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

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

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

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

`impl PartialEq<Match> for Match`

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

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

`impl PartialEq<MatchKind> for MatchKind`

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

`impl PartialEq<MatchKind> for MatchKind`

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

`impl PartialEq<ClassSet> for ClassSet`

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

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

`impl PartialEq<Repetition> for Repetition`

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

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

`impl PartialEq<AssertionKind> for AssertionKind`

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

`impl PartialEq<HexLiteralKind> for HexLiteralKind`

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

`impl PartialEq<ClassAsciiKind> for ClassAsciiKind`

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

`impl PartialEq<LiteralKind> for LiteralKind`

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

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

`impl PartialEq<RepetitionKind> for RepetitionKind`

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

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

`impl PartialEq<ClassSetItem> for ClassSetItem`

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

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

`impl PartialEq<FlagsItem> for FlagsItem`

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

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

`impl PartialEq<RepetitionRange> for RepetitionRange`

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

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

`impl PartialEq<ClassBytes> for ClassBytes`

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

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

`impl PartialEq<SetFlags> for SetFlags`

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

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

`impl PartialEq<SpecialLiteralKind> for SpecialLiteralKind`

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

`impl PartialEq<GroupKind> for GroupKind`

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

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

`impl PartialEq<ClassBracketed> for ClassBracketed`

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

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

`impl PartialEq<Class> for Class`

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

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

`impl PartialEq<ClassAscii> for ClassAscii`

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

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

`impl PartialEq<ClassUnicodeRange> for ClassUnicodeRange`

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

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

`impl PartialEq<FlagsItemKind> for FlagsItemKind`

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

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

`impl PartialEq<Flag> for Flag`

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

`impl PartialEq<Literals> for Literals`

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

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

`impl PartialEq<ClassPerl> for ClassPerl`

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

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

`impl PartialEq<RepetitionRange> for RepetitionRange`

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

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

`impl PartialEq<Literal> for Literal`

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

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

`impl PartialEq<Error> for Error`

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

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

`impl PartialEq<Comment> for Comment`

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

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

`impl PartialEq<Assertion> for Assertion`

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

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

`impl PartialEq<Alternation> for Alternation`

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

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

`impl PartialEq<Literal> for Literal`

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

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

`impl PartialEq<Utf8Sequence> for Utf8Sequence`

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

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

`impl PartialEq<Literal> for Literal`

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

`impl PartialEq<ClassUnicode> for ClassUnicode`

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

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

`impl PartialEq<ClassUnicodeKind> for ClassUnicodeKind`

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

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

`impl PartialEq<ClassSetUnion> for ClassSetUnion`

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

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

`impl PartialEq<ErrorKind> for ErrorKind`

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

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

`impl PartialEq<ErrorKind> for ErrorKind`

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

`impl PartialEq<ClassSetRange> for ClassSetRange`

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

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

`impl PartialEq<Group> for Group`

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

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

`impl PartialEq<WithComments> for WithComments`

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

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

`impl PartialEq<ClassBytesRange> for ClassBytesRange`

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

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

`impl PartialEq<RepetitionOp> for RepetitionOp`

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

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

`impl PartialEq<ClassPerlKind> for ClassPerlKind`

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

`impl PartialEq for Span`

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

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

`impl PartialEq<WordBoundary> for WordBoundary`

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

`impl PartialEq<Repetition> for Repetition`

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

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

`impl PartialEq<ClassUnicodeOpKind> for ClassUnicodeOpKind`

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

`impl PartialEq<Anchor> for Anchor`

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

`impl PartialEq<Group> for Group`

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

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

`impl PartialEq<CaptureName> for CaptureName`

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

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

`impl PartialEq<ClassSetBinaryOpKind> for ClassSetBinaryOpKind`

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

`impl PartialEq<Class> for Class`

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

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

`impl PartialEq<Error> for Error`

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

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

`impl PartialEq<Position> for Position`

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

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

`impl PartialEq<GroupKind> for GroupKind`

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

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

`impl PartialEq<Ast> for Ast`

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

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

`impl PartialEq<ClassSetBinaryOp> for ClassSetBinaryOp`

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

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

`impl PartialEq<Flags> for Flags`

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

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

`impl PartialEq<ClassUnicode> for ClassUnicode`

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

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

`impl PartialEq<RepetitionKind> for RepetitionKind`

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

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

`impl PartialEq<Concat> for Concat`

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

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

`impl PartialEq<Utf8Range> for Utf8Range`

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

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

`impl PartialEq<Hir> for Hir`

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

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

`impl PartialEq<Error> for Error`

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

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

`impl PartialEq<HirKind> for HirKind`

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

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

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

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

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

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

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 nom::lib::std::fmt::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<Error> for nom::error::Error`[src]

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

`fn ne(&self, other: &Error) -> 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::cmp::PartialEq1.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<NulError> for NulError[src]

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

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

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

impl PartialEq<OsString> for OsString[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

impl PartialEq<SocketAddrV6> for SocketAddrV6[src]

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

impl PartialEq<TryRecvError> for TryRecvError[src]

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

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

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

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

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

impl PartialEq<OsString> for 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 PartialEq<ThreadId> for ThreadId[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`impl PartialEq<OsString> for 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 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<&'a OsStr> for PathBuf`[src]

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

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

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