Trait nom::lib::std::prelude::v1::v1::PartialEq

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

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

Trait for equality comparisons which are partial equivalence relations.

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

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

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

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

Derivable

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

How can I implement PartialEq?

PartialEq only requires the eq method to be implemented; ne is defined in terms of it by default. Any manual implementation of ne must respect the rule that eq is a strict inverse of ne; that is, !(a == b) if and only if a != b.

Implementations of PartialEq, PartialOrd, and Ord must agree with each other. It's easy to accidentally make them disagree by deriving some of the traits and manually implementing others.

An example implementation for a domain in which two books are considered the same book if their ISBN matches, even if the formats differ:

enum BookFormat { Paperback, Hardback, Ebook }
struct Book {
    isbn: i32,
    format: BookFormat,
}

impl PartialEq for Book {
    fn eq(&self, other: &Book) -> 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);

Examples

let x: u32 = 0;
let y: u32 = 1;

assert_eq!(x == y, false);
assert_eq!(x.eq(&y), false);

Required Methods

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

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

Provided Methods

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

This method tests for !=.

Implementations on Foreign Types

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

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

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

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

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

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

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

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

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

impl PartialEq<FileType> for FileType

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

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

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

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

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

impl PartialEq<PathBuf> for PathBuf

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

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

impl PartialEq<NulError> for NulError

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

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

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

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

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

impl PartialEq<WaitTimeoutResult> for WaitTimeoutResult

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

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

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

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

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

impl PartialEq<Permissions> for Permissions

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

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

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

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

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

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

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

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

impl PartialEq<Shutdown> for Shutdown

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

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

impl PartialEq<FromBytesWithNulError> for FromBytesWithNulError

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

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

impl PartialEq<RecvTimeoutError> for RecvTimeoutError

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl PartialEq<IpAddr> for IpAddr

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl PartialEq<StripPrefixError> for StripPrefixError

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

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

impl PartialEq<TryRecvError> for TryRecvError

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl PartialEq<SystemTime> for SystemTime

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

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

impl PartialEq<CStr> for CStr

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

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

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

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

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

impl PartialEq<CString> for CString

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

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

impl PartialEq<ExitStatus> for ExitStatus

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

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

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

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

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

impl PartialEq<Ipv4Addr> for Ipv4Addr

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

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

impl PartialEq<SocketAddrV4> for SocketAddrV4

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

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

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

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

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

impl PartialEq<ErrorKind> for ErrorKind

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

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

impl PartialEq<AddrParseError> for AddrParseError

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

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

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

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

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

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

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

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

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

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

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

impl PartialEq<SeekFrom> for SeekFrom

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

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

impl PartialEq<RecvError> for RecvError

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl PartialEq<Ipv6Addr> for Ipv6Addr

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

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

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

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

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

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

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

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

impl PartialEq<str> for OsStr

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

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

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

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

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

impl PartialEq<SocketAddrV6> for SocketAddrV6

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl PartialEq<OsString> for OsString

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

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

impl PartialEq<str> for OsString

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

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

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

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

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

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

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

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

impl PartialEq<Ipv4Addr> for IpAddr

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

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

impl PartialEq<OsStr> for OsStr

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

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

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

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

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

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

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

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

impl PartialEq<Ipv6MulticastScope> for Ipv6MulticastScope

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

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

impl PartialEq<Path> for Path

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

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

impl PartialEq<OsStr> for str

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

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

impl PartialEq<IpAddr> for Ipv4Addr

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

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

impl PartialEq<VarError> for VarError

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

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

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

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

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

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

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

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

impl PartialEq<Output> for Output

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

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

impl PartialEq<SocketAddr> for SocketAddr

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

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

impl PartialEq<IntoStringError> for IntoStringError

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

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

impl PartialEq<ThreadId> for ThreadId

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

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

impl PartialEq<IpAddr> for Ipv6Addr

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

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

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

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

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

impl PartialEq<OsString> for str

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

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

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

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

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

impl PartialEq<Ipv6Addr> for IpAddr

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

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

impl PartialEq<Instant> for Instant

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

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

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

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

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

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

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

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

impl<'a, 'b, A, B> PartialEq<[A; 28]> for &'b mut [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 28]) -> bool

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 7] where     A: PartialEq<B>,

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

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

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 5] where     A: PartialEq<B>,

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

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

impl<'a, 'b, A, B> PartialEq<[A; 15]> for &'b [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 15]) -> bool

impl PartialEq<i64x8> for i64x8

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

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

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

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

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

impl<'a, 'b, A, B> PartialEq<[B; 13]> for [A; 13] where     A: PartialEq<B>,

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

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

impl<'a, 'b, A, B> PartialEq<[A; 16]> for &'b [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 16]) -> bool

impl<T> PartialEq<NonNull<T>> for NonNull<T> where     T: ?Sized,

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

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

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 16] where     A: PartialEq<B>,

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

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

impl PartialEq<m32x8> for m32x8

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

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

impl<'a, 'b, A, B> PartialEq<[A; 9]> for &'b [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 9]) -> bool

impl PartialEq<i16x16> for i16x16

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

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

impl PartialEq<i16x2> for i16x2

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

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

impl PartialEq<f32> for f32

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

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

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

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

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

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

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

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

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

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

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

impl<'a, 'b, A, B> PartialEq<[A; 13]> for &'b mut [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 13]) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 19]> for [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 19]) -> bool

impl PartialEq<ParseIntError> for ParseIntError

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

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

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 19] where     A: PartialEq<B>,

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

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

impl<'a, 'b, A, B> PartialEq<[A; 1]> for &'b mut [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 1]) -> bool

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 9] where     A: PartialEq<B>,

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

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

impl<'a, 'b, A, B> PartialEq<[B; 15]> for [A; 15] where     A: PartialEq<B>,

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

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

impl<'a, 'b, A, B> PartialEq<[A; 2]> for &'b mut [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 2]) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 19]> for &'b mut [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 19]) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 10]> for [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 10]) -> bool

impl PartialEq<UnicodeVersion> for UnicodeVersion

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

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

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

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

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

impl<'a, 'b, A, B> PartialEq<[A; 12]> for [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 12]) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 32]> for &'b [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 32]) -> bool

impl<'a, 'b, A, B> PartialEq<[B; 31]> for [A; 31] where     A: PartialEq<B>,

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

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

impl<'a, 'b, A, B> PartialEq<[A; 31]> for &'b [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 31]) -> bool

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

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

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

impl<'a, 'b, A, B> PartialEq<[A; 0]> for &'b [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 0]) -> bool

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

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

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

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

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

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

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

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

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

impl PartialEq<Duration> for Duration

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

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

impl<'a, 'b, A, B> PartialEq<[A; 25]> for [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 25]) -> bool

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

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

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

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

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

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

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 1] where     A: PartialEq<B>,

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

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

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 31] where     A: PartialEq<B>,

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

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

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 20] where     A: PartialEq<B>,

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

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

impl<'a, 'b, A, B> PartialEq<[A; 8]> for &'b mut [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 8]) -> bool

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

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

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

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 7] where     A: PartialEq<B>,

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

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

impl PartialEq<f32x16> for f32x16

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

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

impl PartialEq<NonZeroU64> for NonZeroU64

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

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

impl PartialEq<u32x8> for u32x8

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

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

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 24] where     A: PartialEq<B>,

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

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

impl PartialEq<u8x8> for u8x8

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

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

impl<'a, 'b, A, B> PartialEq<[A; 28]> for &'b [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 28]) -> bool

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 30] where     A: PartialEq<B>,

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

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

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

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

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

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 29] where     A: PartialEq<B>,

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

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

impl<'a, 'b, A, B> PartialEq<[A; 30]> for &'b mut [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 30]) -> bool

impl PartialEq<bool> for bool

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

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

impl PartialEq<u64> for u64

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

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

impl PartialEq<u128> for u128

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

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

impl PartialEq<i16x32> for i16x32

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

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

impl<'a, 'b, A, B> PartialEq<[A; 17]> for &'b mut [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 17]) -> bool

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

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

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

impl<'a, 'b, A, B> PartialEq<[A; 18]> for &'b mut [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 18]) -> bool

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

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

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

impl<'a, 'b, A, B> PartialEq<[A; 8]> for [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 8]) -> bool

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

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

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

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

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

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

impl<'a, 'b, A, B> PartialEq<[A; 4]> for &'b mut [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 4]) -> bool

impl PartialEq<AllocErr> for AllocErr

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

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

impl<'a, 'b, A, B> PartialEq<[A; 21]> for &'b mut [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 21]) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 24]> for &'b [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 24]) -> bool

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 17] where     A: PartialEq<B>,

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

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

impl<'a, 'b, A, B> PartialEq<[A; 17]> for [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 17]) -> bool

impl<'a, 'b, A, B> PartialEq<[B; 2]> for [A; 2] where     A: PartialEq<B>,

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

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

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 30] where     A: PartialEq<B>,

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

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

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

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

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

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

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

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

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 6] where     A: PartialEq<B>,

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

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

impl<'a, 'b, A, B> PartialEq<[A; 1]> for &'b [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 1]) -> bool

impl PartialEq<NonZeroU16> for NonZeroU16

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

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

impl<'a, 'b, A, B> PartialEq<[B; 8]> for [A; 8] where     A: PartialEq<B>,

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

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

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 8] where     A: PartialEq<B>,

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

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

impl PartialEq<i16> for i16

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'a, 'b, A, B> PartialEq<[B; 10]> for [A; 10] where     A: PartialEq<B>,

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

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

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 21] where     A: PartialEq<B>,

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

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

impl PartialEq<u64x8> for u64x8

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

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

impl PartialEq<i16x4> for i16x4

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

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

impl<'a, 'b, A, B> PartialEq<[A; 23]> for [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 23]) -> bool

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 13] where     A: PartialEq<B>,

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

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

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

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

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

impl PartialEq<u64x2> for u64x2

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

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

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

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

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

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 9] where     A: PartialEq<B>,

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

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

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

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

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

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 1] where     A: PartialEq<B>,

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

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

impl<T> PartialEq<PhantomData<T>> for PhantomData<T> where     T: ?Sized,

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

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

impl<'a, 'b, A, B> PartialEq<[A; 24]> for [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 24]) -> bool

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

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

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

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 25] where     A: PartialEq<B>,

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

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

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

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

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

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 13] where     A: PartialEq<B>,

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

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

impl<'a, 'b, A, B> PartialEq<[B; 30]> for [A; 30] where     A: PartialEq<B>,

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

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

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 6] where     A: PartialEq<B>,

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

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

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 14] where     A: PartialEq<B>,

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

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

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 5] where     A: PartialEq<B>,

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

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

impl<'a, 'b, A, B> PartialEq<[A; 14]> for [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 14]) -> bool

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 2] where     A: PartialEq<B>,

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

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

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

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

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

impl PartialEq<str> for str

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

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

impl<'a, 'b, A, B> PartialEq<[B; 1]> for [A; 1] where     A: PartialEq<B>,

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

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

impl PartialEq<f32x4> for f32x4

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

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

impl PartialEq<!> for !

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

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

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

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

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

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 18] where     A: PartialEq<B>,

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

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

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 28] where     A: PartialEq<B>,

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

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

impl PartialEq<i8x2> for i8x2

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

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

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

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

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

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 11] where     A: PartialEq<B>,

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

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

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 12] where     A: PartialEq<B>,

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

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

impl PartialEq<u16x32> for u16x32

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

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

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

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

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

impl PartialEq<m8x2> for m8x2

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

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

impl PartialEq<ParseCharError> for ParseCharError

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

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

impl<'a, 'b, A, B> PartialEq<[A; 1]> for [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 1]) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 13]> for &'b [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 13]) -> bool

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

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

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

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

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

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

impl PartialEq<LayoutErr> for LayoutErr

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

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

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 11] where     A: PartialEq<B>,

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

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

impl PartialEq<f64x4> for f64x4

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

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

impl<'a, 'b, A, B> PartialEq<[B; 16]> for [A; 16] where     A: PartialEq<B>,

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

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

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

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

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

impl<'a, 'b, A, B> PartialEq<[A; 6]> for &'b mut [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 6]) -> bool

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 29] where     A: PartialEq<B>,

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

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

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 4] where     A: PartialEq<B>,

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

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

impl PartialEq<i128> for i128

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

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

impl PartialEq<m8x4> for m8x4

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

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

impl<'a, 'b, A, B> PartialEq<[B; 22]> for [A; 22] where     A: PartialEq<B>,

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

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

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 13] where     A: PartialEq<B>,

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

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

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 17] where     A: PartialEq<B>,

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

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

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

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

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

impl PartialEq<TypeId> for TypeId

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

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

impl<'a, 'b, A, B> PartialEq<[A; 20]> for &'b [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 20]) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 11]> for &'b [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 11]) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 20]> for &'b mut [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 20]) -> bool

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

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

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

impl PartialEq<m32x4> for m32x4

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

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

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

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

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

impl PartialEq<m32x2> for m32x2

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

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

impl<'a, 'b, A, B> PartialEq<[B; 28]> for [A; 28] where     A: PartialEq<B>,

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

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

impl PartialEq<m1x16> for m1x16

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

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

impl PartialEq<i16x8> for i16x8

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

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

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

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

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

impl<'a, 'b, A, B> PartialEq<[A; 9]> for &'b mut [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 9]) -> bool

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 8] where     A: PartialEq<B>,

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

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

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

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

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

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 10] where     A: PartialEq<B>,

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

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

impl PartialEq<m16x2> for m16x2

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

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

impl<'a, 'b, A, B> PartialEq<[A; 14]> for &'b [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 14]) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 26]> for &'b [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 26]) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 9]> for [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 9]) -> bool

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

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

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

impl PartialEq<i32x2> for i32x2

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

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

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

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

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

impl<'a, 'b, A, B> PartialEq<[B; 11]> for [A; 11] where     A: PartialEq<B>,

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

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

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 21] where     A: PartialEq<B>,

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

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

impl PartialEq<u32x16> for u32x16

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

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

impl<'a, 'b, A, B> PartialEq<[A; 7]> for &'b [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 7]) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 3]> for &'b [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 3]) -> bool

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

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

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

impl PartialEq<i8x32> for i8x32

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

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

impl<'a, 'b, A, B> PartialEq<[A; 26]> for [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 26]) -> bool

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

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

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

impl<'a, 'b, A, B> PartialEq<[A; 30]> for [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 30]) -> bool

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 26] where     A: PartialEq<B>,

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

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

impl<'a, 'b, A, B> PartialEq<[A; 31]> for [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 31]) -> bool

impl PartialEq<m64x2> for m64x2

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

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

impl<'a, 'b, A, B> PartialEq<[B; 14]> for [A; 14] where     A: PartialEq<B>,

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

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

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

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

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

impl PartialEq<m16x16> for m16x16

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

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

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 32] where     A: PartialEq<B>,

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

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

impl<'a, 'b, A, B> PartialEq<[A; 3]> for &'b mut [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 3]) -> bool

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 16] where     A: PartialEq<B>,

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

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

impl<'a, 'b, A, B> PartialEq<[A; 0]> for &'b mut [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 0]) -> bool

impl<'a, 'b, A, B> PartialEq<[B; 19]> for [A; 19] where     A: PartialEq<B>,

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

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

impl<'a, 'b, A, B> PartialEq<[A; 4]> for [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 4]) -> bool

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

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

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

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

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

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

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

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

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

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

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

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

impl<'a, 'b, A, B> PartialEq<[A; 5]> for &'b mut [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 5]) -> bool

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 20] where     A: PartialEq<B>,

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

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

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 23] where     A: PartialEq<B>,

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

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

impl PartialEq<CharTryFromError> for CharTryFromError

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

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

impl PartialEq<u8x4> for u8x4

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

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

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

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

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

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 3] where     A: PartialEq<B>,

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

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

impl PartialEq<u16x8> for u16x8

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

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

impl<'a, 'b, A, B> PartialEq<[A; 6]> for &'b [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 6]) -> bool

impl<'a, 'b, A, B> PartialEq<[B; 17]> for [A; 17] where     A: PartialEq<B>,

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

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

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 23] where     A: PartialEq<B>,

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

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

impl<'a, 'b, A, B> PartialEq<[A; 2]> for &'b [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 2]) -> bool

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 22] where     A: PartialEq<B>,

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

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

impl<'a, 'b, A, B> PartialEq<[B; 3]> for [A; 3] where     A: PartialEq<B>,

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

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

impl PartialEq<u8x2> for u8x2

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

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

impl<'a, 'b, A, B> PartialEq<[A; 25]> for &'b mut [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 25]) -> bool

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

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

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

impl<'a, 'b, A, B> PartialEq<[A; 10]> for &'b [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 10]) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 30]> for &'b [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 30]) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 32]> for &'b mut [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 32]) -> bool

impl PartialEq<u32> for u32

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

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

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 16] where     A: PartialEq<B>,

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

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

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

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

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

impl PartialEq<u16x16> for u16x16

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

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

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

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

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

impl PartialEq<NonZeroU128> for NonZeroU128

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

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

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

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

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

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 14] where     A: PartialEq<B>,

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

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

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

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

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

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 5] where     A: PartialEq<B>,

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

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

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 22] where     A: PartialEq<B>,

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

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

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

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

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

impl<'a, 'b, A, B> PartialEq<[A; 22]> for &'b mut [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 22]) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 2]> for [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 2]) -> bool

impl PartialEq<Layout> for Layout

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

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

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 0] where     A: PartialEq<B>,

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

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

impl<'a, 'b, A, B> PartialEq<[B; 21]> for [A; 21] where     A: PartialEq<B>,

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

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

impl<'a, 'b, A, B> PartialEq<[A; 24]> for &'b mut [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 24]) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 27]> for &'b mut [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 27]) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 6]> for [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 6]) -> bool

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

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

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

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 29] where     A: PartialEq<B>,

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

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

impl<'a, 'b, A, B> PartialEq<[A; 8]> for &'b [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 8]) -> bool

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

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

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

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 7] where     A: PartialEq<B>,

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

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

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

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

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

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 12] where     A: PartialEq<B>,

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

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

impl<'a, 'b, A, B> PartialEq<[B; 20]> for [A; 20] where     A: PartialEq<B>,

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

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

impl PartialEq<i8x4> for i8x4

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

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

impl<'a, 'b, A, B> PartialEq<[A; 13]> for [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 13]) -> bool

impl PartialEq<m1x32> for m1x32

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

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

impl PartialEq<u64x4> for u64x4

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

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

impl PartialEq<i64x2> for i64x2

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

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

impl PartialEq<u32x2> for u32x2

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

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

impl<'a, 'b, A, B> PartialEq<[A; 0]> for [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 0]) -> bool

impl PartialEq<m8x32> for m8x32

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

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

impl PartialEq<m8x16> for m8x16

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

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

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

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

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

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

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

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

impl PartialEq<i64> for i64

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

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

impl<'a, 'b, A, B> PartialEq<[A; 21]> for [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 21]) -> bool

impl<'a, 'b, A, B> PartialEq<[B; 18]> for [A; 18] where     A: PartialEq<B>,

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

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

impl PartialEq<m8x8> for m8x8

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

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

impl PartialEq<InvalidSequence> for InvalidSequence

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

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

impl PartialEq<f32x8> for f32x8

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

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

impl PartialEq<NonZeroU32> for NonZeroU32

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

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

impl<'a, 'b, A, B> PartialEq<[A; 15]> for [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 15]) -> bool

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

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

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

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

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

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

impl<'a, 'b, A, B> PartialEq<[A; 25]> for &'b [B] where     B: PartialEq<A>,

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

fn ne(&self, other: &[A; 25]) -> bool

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

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

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

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 19] where     A: PartialEq<B>,

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

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

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

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

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

impl PartialEq<u8x16> for u8x16

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

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

impl PartialEq<u16> for u16

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

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

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

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

fn ne(&self, other: &Rhs) -> bool

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 28] where     A: PartialEq<B>,

fn eq(&self, other: &&'b [B]) -> bool

fn ne(&self, other: &&'b [B]) -> bool

impl<Ret, A, B, C, D, E, F, G> PartialEq<extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret

fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret) -> bool

fn ne(&self, other: &Rhs) -> bool

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 24] where     A: PartialEq<B>,

fn eq(&self, other: &&'b mut [B]) -> bool

fn ne(&self, other: &&'b mut [B]) -> bool

impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialEq<unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret

fn eq(&self, other: &unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret) -> bool

fn ne(&self, other: &Rhs) -> bool

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 24] where     A: PartialEq<B>,

fn eq(&self, other: &[B]) -> bool

fn ne(&self, other: &[B]) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 29]> for [B] where     B: PartialEq<A>,

fn eq(&self, other: &[A; 29]) -> bool

fn ne(&self, other: &[A; 29]) -> bool

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 12] where     A: PartialEq<B>,

fn eq(&self, other: &&'b mut [B]) -> bool

fn ne(&self, other: &&'b mut [B]) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 19]> for &'b [B] where     B: PartialEq<A>,

fn eq(&self, other: &[A; 19]) -> bool

fn ne(&self, other: &[A; 19]) -> bool

impl PartialEq<char> for char

fn eq(&self, other: &char) -> bool

fn ne(&self, other: &char) -> bool

impl<Ret, A, B, C> PartialEq<unsafe extern "C" fn(A, B, C) -> Ret> for unsafe extern "C" fn(A, B, C) -> Ret

fn eq(&self, other: &unsafe extern "C" fn(A, B, C) -> Ret) -> bool

fn ne(&self, other: &Rhs) -> bool

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 27] where     A: PartialEq<B>,

fn eq(&self, other: &[B]) -> bool

fn ne(&self, other: &[B]) -> bool

impl<A, B, C, D, E, F, G, H, I, J, K> PartialEq<(A, B, C, D, E, F, G, H, I, J, K)> for (A, B, C, D, E, F, G, H, I, J, K) where     A: PartialEq<A>,     B: PartialEq<B>,     C: PartialEq<C>,     D: PartialEq<D>,     E: PartialEq<E>,     F: PartialEq<F>,     G: PartialEq<G>,     H: PartialEq<H>,     I: PartialEq<I>,     J: PartialEq<J>,     K: PartialEq<K> + ?Sized,

fn eq(&self, other: &(A, B, C, D, E, F, G, H, I, J, K)) -> bool

fn ne(&self, other: &(A, B, C, D, E, F, G, H, I, J, K)) -> bool

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 0] where     A: PartialEq<B>,

fn eq(&self, other: &&'b [B]) -> bool

fn ne(&self, other: &&'b [B]) -> bool

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 31] where     A: PartialEq<B>,

fn eq(&self, other: &&'b [B]) -> bool

fn ne(&self, other: &&'b [B]) -> bool

impl<'a, 'b, A, B> PartialEq<&'b B> for &'a A where     A: PartialEq<B> + ?Sized,     B: ?Sized,

fn eq(&self, other: &&'b B) -> bool

fn ne(&self, other: &&'b B) -> bool

impl PartialEq<i32> for i32

fn eq(&self, other: &i32) -> bool

fn ne(&self, other: &i32) -> bool

impl PartialEq<u8> for u8

fn eq(&self, other: &u8) -> bool

fn ne(&self, other: &u8) -> bool

impl PartialEq<CannotReallocInPlace> for CannotReallocInPlace

fn eq(&self, other: &CannotReallocInPlace) -> bool

fn ne(&self, other: &Rhs) -> bool

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 21] where     A: PartialEq<B>,

fn eq(&self, other: &[B]) -> bool

fn ne(&self, other: &[B]) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 3]> for [B] where     B: PartialEq<A>,

fn eq(&self, other: &[A; 3]) -> bool

fn ne(&self, other: &[A; 3]) -> bool

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

fn eq(     &self,     other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret ) -> bool

fn ne(&self, other: &Rhs) -> bool

impl<Ret, A> PartialEq<unsafe extern "C" fn(A) -> Ret> for unsafe extern "C" fn(A) -> Ret

fn eq(&self, other: &unsafe extern "C" fn(A) -> Ret) -> bool

fn ne(&self, other: &Rhs) -> bool

impl<Ret, A, B, C> PartialEq<fn(A, B, C) -> Ret> for fn(A, B, C) -> Ret

fn eq(&self, other: &fn(A, B, C) -> Ret) -> bool

fn ne(&self, other: &Rhs) -> bool

impl PartialEq<u8x64> for u8x64

fn eq(&self, other: &u8x64) -> bool

fn ne(&self, other: &u8x64) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 18]> for &'b [B] where     B: PartialEq<A>,

fn eq(&self, other: &[A; 18]) -> bool

fn ne(&self, other: &[A; 18]) -> bool

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 3] where     A: PartialEq<B>,

fn eq(&self, other: &[B]) -> bool

fn ne(&self, other: &[B]) -> bool

impl<T> PartialEq<Wrapping<T>> for Wrapping<T> where     T: PartialEq<T>,

fn eq(&self, other: &Wrapping<T>) -> bool

fn ne(&self, other: &Wrapping<T>) -> bool

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 10] where     A: PartialEq<B>,

fn eq(&self, other: &&'b [B]) -> bool

fn ne(&self, other: &&'b [B]) -> bool

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 19] where     A: PartialEq<B>,

fn eq(&self, other: &&'b mut [B]) -> bool

fn ne(&self, other: &&'b mut [B]) -> bool

impl PartialEq<u16x2> for u16x2

fn eq(&self, other: &u16x2) -> bool

fn ne(&self, other: &u16x2) -> bool

impl PartialEq<m64x4> for m64x4

fn eq(&self, other: &m64x4) -> bool

fn ne(&self, other: &m64x4) -> bool

impl<Ret> PartialEq<unsafe fn() -> Ret> for unsafe fn() -> Ret

fn eq(&self, other: &unsafe fn() -> Ret) -> bool

fn ne(&self, other: &Rhs) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 26]> for &'b mut [B] where     B: PartialEq<A>,

fn eq(&self, other: &[A; 26]) -> bool

fn ne(&self, other: &[A; 26]) -> bool

impl<Ret, A, B, C> PartialEq<unsafe extern "C" fn(A, B, C, ...) -> Ret> for unsafe extern "C" fn(A, B, C, ...) -> Ret

fn eq(&self, other: &unsafe extern "C" fn(A, B, C, ...) -> Ret) -> bool

fn ne(&self, other: &Rhs) -> bool

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialEq<fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

fn eq(&self, other: &fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret) -> bool

fn ne(&self, other: &Rhs) -> bool

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 1] where     A: PartialEq<B>,

fn eq(&self, other: &&'b mut [B]) -> bool

fn ne(&self, other: &&'b mut [B]) -> bool

impl PartialEq<u8x32> for u8x32

fn eq(&self, other: &u8x32) -> bool

fn ne(&self, other: &u8x32) -> bool

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 2] where     A: PartialEq<B>,

fn eq(&self, other: &[B]) -> bool

fn ne(&self, other: &[B]) -> bool

impl<Ret, A, B, C, D, E, F, G, H, I> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret

fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret) -> bool

fn ne(&self, other: &Rhs) -> bool

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 30] where     A: PartialEq<B>,

fn eq(&self, other: &[B]) -> bool

fn ne(&self, other: &[B]) -> bool

impl<'a, 'b, A, B> PartialEq<[B; 24]> for [A; 24] where     A: PartialEq<B>,

fn eq(&self, other: &[B; 24]) -> bool

fn ne(&self, other: &[B; 24]) -> bool

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 4] where     A: PartialEq<B>,

fn eq(&self, other: &[B]) -> bool

fn ne(&self, other: &[B]) -> bool

impl PartialEq<m16x4> for m16x4

fn eq(&self, other: &m16x4) -> bool

fn ne(&self, other: &m16x4) -> bool

impl PartialEq<i8x64> for i8x64

fn eq(&self, other: &i8x64) -> bool

fn ne(&self, other: &i8x64) -> bool

impl PartialEq<i8> for i8

fn eq(&self, other: &i8) -> bool

fn ne(&self, other: &i8) -> bool

impl<A, B, C, D, E, F, G> PartialEq<(A, B, C, D, E, F, G)> for (A, B, C, D, E, F, G) where     A: PartialEq<A>,     B: PartialEq<B>,     C: PartialEq<C>,     D: PartialEq<D>,     E: PartialEq<E>,     F: PartialEq<F>,     G: PartialEq<G> + ?Sized,

fn eq(&self, other: &(A, B, C, D, E, F, G)) -> bool

fn ne(&self, other: &(A, B, C, D, E, F, G)) -> bool

impl PartialEq<f64x2> for f64x2

fn eq(&self, other: &f64x2) -> bool

fn ne(&self, other: &f64x2) -> bool

impl PartialEq<NonZeroU8> for NonZeroU8

fn eq(&self, other: &NonZeroU8) -> bool

fn ne(&self, other: &NonZeroU8) -> bool

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 6] where     A: PartialEq<B>,

fn eq(&self, other: &&'b mut [B]) -> bool

fn ne(&self, other: &&'b mut [B]) -> bool

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 28] where     A: PartialEq<B>,

fn eq(&self, other: &&'b mut [B]) -> bool

fn ne(&self, other: &&'b mut [B]) -> bool

impl PartialEq<i8x16> for i8x16

fn eq(&self, other: &i8x16) -> bool

fn ne(&self, other: &i8x16) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 29]> for &'b [B] where     B: PartialEq<A>,

fn eq(&self, other: &[A; 29]) -> bool

fn ne(&self, other: &[A; 29]) -> bool

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 14] where     A: PartialEq<B>,

fn eq(&self, other: &&'b mut [B]) -> bool

fn ne(&self, other: &&'b mut [B]) -> bool

impl PartialEq<FpCategory> for FpCategory

fn eq(&self, other: &FpCategory) -> bool

fn ne(&self, other: &Rhs) -> bool

impl<Ret, A, B, C, D> PartialEq<fn(A, B, C, D) -> Ret> for fn(A, B, C, D) -> Ret

fn eq(&self, other: &fn(A, B, C, D) -> Ret) -> bool

fn ne(&self, other: &Rhs) -> bool

impl PartialEq<i32x16> for i32x16

fn eq(&self, other: &i32x16) -> bool

fn ne(&self, other: &i32x16) -> bool

impl<Ret, A, B, C> PartialEq<extern "C" fn(A, B, C, ...) -> Ret> for extern "C" fn(A, B, C, ...) -> Ret

fn eq(&self, other: &extern "C" fn(A, B, C, ...) -> Ret) -> bool

fn ne(&self, other: &Rhs) -> bool

impl<T> PartialEq<RefCell<T>> for RefCell<T> where     T: PartialEq<T> + ?Sized,

fn eq(&self, other: &RefCell<T>) -> bool

Panics

Panics if the value in either RefCell is currently borrowed.

fn ne(&self, other: &Rhs) -> bool

impl<Ret, A> PartialEq<extern "C" fn(A) -> Ret> for extern "C" fn(A) -> Ret

fn eq(&self, other: &extern "C" fn(A) -> Ret) -> bool

fn ne(&self, other: &Rhs) -> bool

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 0] where     A: PartialEq<B>,

fn eq(&self, other: &[B]) -> bool

fn ne(&self, other: &[B]) -> bool

impl<'a, 'b, A, B> PartialEq<[B; 0]> for [A; 0] where     A: PartialEq<B>,

fn eq(&self, other: &[B; 0]) -> bool

fn ne(&self, other: &[B; 0]) -> bool

impl PartialEq<m1x8> for m1x8

fn eq(&self, other: &m1x8) -> bool

fn ne(&self, other: &m1x8) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 31]> for &'b mut [B] where     B: PartialEq<A>,

fn eq(&self, other: &[A; 31]) -> bool

fn ne(&self, other: &[A; 31]) -> bool

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 18] where     A: PartialEq<B>,

fn eq(&self, other: &[B]) -> bool

fn ne(&self, other: &[B]) -> bool

impl<A, B, C> PartialEq<(A, B, C)> for (A, B, C) where     A: PartialEq<A>,     B: PartialEq<B>,     C: PartialEq<C> + ?Sized,

fn eq(&self, other: &(A, B, C)) -> bool

fn ne(&self, other: &(A, B, C)) -> bool

impl PartialEq<i32x8> for i32x8

fn eq(&self, other: &i32x8) -> bool

fn ne(&self, other: &i32x8) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 4]> for &'b [B] where     B: PartialEq<A>,

fn eq(&self, other: &[A; 4]) -> bool

fn ne(&self, other: &[A; 4]) -> bool

impl<A, B, C, D, E> PartialEq<(A, B, C, D, E)> for (A, B, C, D, E) where     A: PartialEq<A>,     B: PartialEq<B>,     C: PartialEq<C>,     D: PartialEq<D>,     E: PartialEq<E> + ?Sized,

fn eq(&self, other: &(A, B, C, D, E)) -> bool

fn ne(&self, other: &(A, B, C, D, E)) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 29]> for &'b mut [B] where     B: PartialEq<A>,

fn eq(&self, other: &[A; 29]) -> bool

fn ne(&self, other: &[A; 29]) -> bool

impl PartialEq<usize> for usize

fn eq(&self, other: &usize) -> bool

fn ne(&self, other: &usize) -> bool

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 27] where     A: PartialEq<B>,

fn eq(&self, other: &&'b [B]) -> bool

fn ne(&self, other: &&'b [B]) -> bool

impl<'a, 'b, A, B> PartialEq<[B; 23]> for [A; 23] where     A: PartialEq<B>,

fn eq(&self, other: &[B; 23]) -> bool

fn ne(&self, other: &[B; 23]) -> bool

impl<'a, 'b, A, B> PartialEq<[B; 7]> for [A; 7] where     A: PartialEq<B>,

fn eq(&self, other: &[B; 7]) -> bool

fn ne(&self, other: &[B; 7]) -> bool

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 22] where     A: PartialEq<B>,

fn eq(&self, other: &[B]) -> bool

fn ne(&self, other: &[B]) -> bool

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 15] where     A: PartialEq<B>,

fn eq(&self, other: &&'b [B]) -> bool

fn ne(&self, other: &&'b [B]) -> bool

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 10] where     A: PartialEq<B>,

fn eq(&self, other: &&'b mut [B]) -> bool

fn ne(&self, other: &&'b mut [B]) -> bool

impl<Ret, A, B, C, D, E, F, G, H> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H) -> Ret

fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F, G, H) -> Ret) -> bool

fn ne(&self, other: &Rhs) -> bool

impl<Ret, A, B, C, D, E, F, G, H> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret

fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret) -> bool

fn ne(&self, other: &Rhs) -> bool

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 18] where     A: PartialEq<B>,

fn eq(&self, other: &&'b mut [B]) -> bool

fn ne(&self, other: &&'b mut [B]) -> bool

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 32] where     A: PartialEq<B>,

fn eq(&self, other: &&'b mut [B]) -> bool

fn ne(&self, other: &&'b mut [B]) -> bool

impl<'a, 'b, A, B> PartialEq<[B; 6]> for [A; 6] where     A: PartialEq<B>,

fn eq(&self, other: &[B; 6]) -> bool

fn ne(&self, other: &[B; 6]) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 23]> for &'b [B] where     B: PartialEq<A>,

fn eq(&self, other: &[A; 23]) -> bool

fn ne(&self, other: &[A; 23]) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 22]> for &'b [B] where     B: PartialEq<A>,

fn eq(&self, other: &[A; 22]) -> bool

fn ne(&self, other: &[A; 22]) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 5]> for &'b [B] where     B: PartialEq<A>,

fn eq(&self, other: &[A; 5]) -> bool

fn ne(&self, other: &[A; 5]) -> bool

impl<Ret, A, B, C, D, E, F, G> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret

fn eq(     &self,     other: &unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret ) -> bool

fn ne(&self, other: &Rhs) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 27]> for [B] where     B: PartialEq<A>,

fn eq(&self, other: &[A; 27]) -> bool

fn ne(&self, other: &[A; 27]) -> bool

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 20] where     A: PartialEq<B>,

fn eq(&self, other: &[B]) -> bool

fn ne(&self, other: &[B]) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 14]> for &'b mut [B] where     B: PartialEq<A>,

fn eq(&self, other: &[A; 14]) -> bool

fn ne(&self, other: &[A; 14]) -> bool

impl<Ret> PartialEq<fn() -> Ret> for fn() -> Ret

fn eq(&self, other: &fn() -> Ret) -> bool

fn ne(&self, other: &Rhs) -> bool

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 27] where     A: PartialEq<B>,

fn eq(&self, other: &&'b mut [B]) -> bool

fn ne(&self, other: &&'b mut [B]) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 21]> for &'b [B] where     B: PartialEq<A>,

fn eq(&self, other: &[A; 21]) -> bool

fn ne(&self, other: &[A; 21]) -> bool

impl PartialEq<ParseFloatError> for ParseFloatError

fn eq(&self, other: &ParseFloatError) -> bool

fn ne(&self, other: &ParseFloatError) -> bool

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 8] where     A: PartialEq<B>,

fn eq(&self, other: &&'b mut [B]) -> bool

fn ne(&self, other: &&'b mut [B]) -> bool

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 15] where     A: PartialEq<B>,

fn eq(&self, other: &[B]) -> bool

fn ne(&self, other: &[B]) -> bool

impl<'a, 'b, A, B> PartialEq<[B; 12]> for [A; 12] where     A: PartialEq<B>,

fn eq(&self, other: &[B; 12]) -> bool

fn ne(&self, other: &[B; 12]) -> bool

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 26] where     A: PartialEq<B>,

fn eq(&self, other: &&'b mut [B]) -> bool

fn ne(&self, other: &&'b mut [B]) -> bool

impl PartialEq<()> for ()

fn eq(&self, _other: &()) -> bool

fn ne(&self, _other: &()) -> bool

impl PartialEq<f32x2> for f32x2

fn eq(&self, other: &f32x2) -> bool

fn ne(&self, other: &f32x2) -> bool

impl<A, B, C, D, E, F, G, H, I, J, K, L> PartialEq<(A, B, C, D, E, F, G, H, I, J, K, L)> for (A, B, C, D, E, F, G, H, I, J, K, L) where     A: PartialEq<A>,     B: PartialEq<B>,     C: PartialEq<C>,     D: PartialEq<D>,     E: PartialEq<E>,     F: PartialEq<F>,     G: PartialEq<G>,     H: PartialEq<H>,     I: PartialEq<I>,     J: PartialEq<J>,     K: PartialEq<K>,     L: PartialEq<L> + ?Sized,

fn eq(&self, other: &(A, B, C, D, E, F, G, H, I, J, K, L)) -> bool

fn ne(&self, other: &(A, B, C, D, E, F, G, H, I, J, K, L)) -> bool

impl PartialEq<i32x4> for i32x4

fn eq(&self, other: &i32x4) -> bool

fn ne(&self, other: &i32x4) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 12]> for &'b mut [B] where     B: PartialEq<A>,

fn eq(&self, other: &[A; 12]) -> bool

fn ne(&self, other: &[A; 12]) -> bool

impl PartialEq<DecodeUtf16Error> for DecodeUtf16Error

fn eq(&self, other: &DecodeUtf16Error) -> bool

fn ne(&self, other: &DecodeUtf16Error) -> bool

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 25] where     A: PartialEq<B>,

fn eq(&self, other: &&'b mut [B]) -> bool

fn ne(&self, other: &&'b mut [B]) -> bool

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 11] where     A: PartialEq<B>,

fn eq(&self, other: &&'b [B]) -> bool

fn ne(&self, other: &&'b [B]) -> bool

impl PartialEq<i64x4> for i64x4

fn eq(&self, other: &i64x4) -> bool

fn ne(&self, other: &i64x4) -> bool

impl<'a, 'b, A, B> PartialEq<[B; 26]> for [A; 26] where     A: PartialEq<B>,

fn eq(&self, other: &[B; 26]) -> bool

fn ne(&self, other: &[B; 26]) -> bool

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 2] where     A: PartialEq<B>,

fn eq(&self, other: &&'b [B]) -> bool

fn ne(&self, other: &&'b [B]) -> bool

impl<Ret, A, B, C, D, E, F, G, H, I> PartialEq<fn(A, B, C, D, E, F, G, H, I) -> Ret> for fn(A, B, C, D, E, F, G, H, I) -> Ret

fn eq(&self, other: &fn(A, B, C, D, E, F, G, H, I) -> Ret) -> bool

fn ne(&self, other: &Rhs) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 10]> for &'b mut [B] where     B: PartialEq<A>,

fn eq(&self, other: &[A; 10]) -> bool

fn ne(&self, other: &[A; 10]) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 5]> for [B] where     B: PartialEq<A>,

fn eq(&self, other: &[A; 5]) -> bool

fn ne(&self, other: &[A; 5]) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 7]> for [B] where     B: PartialEq<A>,

fn eq(&self, other: &[A; 7]) -> bool

fn ne(&self, other: &[A; 7]) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 7]> for &'b mut [B] where     B: PartialEq<A>,

fn eq(&self, other: &[A; 7]) -> bool

fn ne(&self, other: &[A; 7]) -> bool

impl<'a, 'b, A, B> PartialEq<[B; 29]> for [A; 29] where     A: PartialEq<B>,

fn eq(&self, other: &[B; 29]) -> bool

fn ne(&self, other: &[B; 29]) -> bool

impl PartialEq<m1x64> for m1x64

fn eq(&self, other: &m1x64) -> bool

fn ne(&self, other: &m1x64) -> bool

impl PartialEq<isize> for isize

fn eq(&self, other: &isize) -> bool

fn ne(&self, other: &isize) -> bool

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 9] where     A: PartialEq<B>,

fn eq(&self, other: &[B]) -> bool

fn ne(&self, other: &[B]) -> bool

impl PartialEq<i8x8> for i8x8

fn eq(&self, other: &i8x8) -> bool

fn ne(&self, other: &i8x8) -> bool

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 31] where     A: PartialEq<B>,

fn eq(&self, other: &[B]) -> bool

fn ne(&self, other: &[B]) -> bool

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 4] where     A: PartialEq<B>,

fn eq(&self, other: &&'b [B]) -> bool

fn ne(&self, other: &&'b [B]) -> bool

impl PartialEq<NonZeroUsize> for NonZeroUsize

fn eq(&self, other: &NonZeroUsize) -> bool

fn ne(&self, other: &NonZeroUsize) -> bool

impl PartialEq<Pinned> for Pinned

fn eq(&self, other: &Pinned) -> bool

fn ne(&self, other: &Rhs) -> bool

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 3] where     A: PartialEq<B>,

fn eq(&self, other: &&'b [B]) -> bool

fn ne(&self, other: &&'b [B]) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 11]> for [B] where     B: PartialEq<A>,

fn eq(&self, other: &[A; 11]) -> bool

fn ne(&self, other: &[A; 11]) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 28]> for [B] where     B: PartialEq<A>,

fn eq(&self, other: &[A; 28]) -> bool

fn ne(&self, other: &[A; 28]) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 15]> for &'b mut [B] where     B: PartialEq<A>,

fn eq(&self, other: &[A; 15]) -> bool

fn ne(&self, other: &[A; 15]) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 27]> for &'b [B] where     B: PartialEq<A>,

fn eq(&self, other: &[A; 27]) -> bool

fn ne(&self, other: &[A; 27]) -> bool

impl<A, B> PartialEq<(A, B)> for (A, B) where     A: PartialEq<A>,     B: PartialEq<B> + ?Sized,

fn eq(&self, other: &(A, B)) -> bool

fn ne(&self, other: &(A, B)) -> bool

impl<'a, 'b, A, B> PartialEq<[B; 4]> for [A; 4] where     A: PartialEq<B>,

fn eq(&self, other: &[B; 4]) -> bool

fn ne(&self, other: &[B; 4]) -> bool

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 25] where     A: PartialEq<B>,

fn eq(&self, other: &[B]) -> bool

fn ne(&self, other: &[B]) -> bool

impl<'a, 'b, A, B> PartialEq<[B; 32]> for [A; 32] where     A: PartialEq<B>,

fn eq(&self, other: &[B; 32]) -> bool

fn ne(&self, other: &[B; 32]) -> bool

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 23] where     A: PartialEq<B>,

fn eq(&self, other: &&'b [B]) -> bool

fn ne(&self, other: &&'b [B]) -> bool

impl<T> PartialEq<*mut T> for *mut T where     T: ?Sized,

fn eq(&self, other: &*mut T) -> bool

fn ne(&self, other: &Rhs) -> bool

impl<'a, 'b, A, B> PartialEq<[B]> for [A; 26] where     A: PartialEq<B>,

fn eq(&self, other: &[B]) -> bool

fn ne(&self, other: &[B]) -> bool

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 17] where     A: PartialEq<B>,

fn eq(&self, other: &&'b mut [B]) -> bool

fn ne(&self, other: &&'b mut [B]) -> bool

impl<'a, 'b, A, B> PartialEq<[B; 9]> for [A; 9] where     A: PartialEq<B>,

fn eq(&self, other: &[B; 9]) -> bool

fn ne(&self, other: &[B; 9]) -> bool

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for [A; 15] where     A: PartialEq<B>,

fn eq(&self, other: &&'b mut [B]) -> bool

fn ne(&self, other: &&'b mut [B]) -> bool

impl<'a, 'b, A, B> PartialEq<[B; 5]> for [A; 5] where     A: PartialEq<B>,

fn eq(&self, other: &[B; 5]) -> bool

fn ne(&self, other: &[B; 5]) -> bool

impl<Ret, A, B, C, D, E, F, G, H> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret

fn eq(     &self,     other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret ) -> bool

fn ne(&self, other: &Rhs) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 16]> for [B] where     B: PartialEq<A>,

fn eq(&self, other: &[A; 16]) -> bool

fn ne(&self, other: &[A; 16]) -> bool

impl<'a, 'b, A, B> PartialEq<[B; 25]> for [A; 25] where     A: PartialEq<B>,

fn eq(&self, other: &[B; 25]) -> bool

fn ne(&self, other: &[B; 25]) -> bool

impl PartialEq<u32x4> for u32x4

fn eq(&self, other: &u32x4) -> bool

fn ne(&self, other: &u32x4) -> bool

impl<'a> PartialEq<Utf8LossyChunk<'a>> for Utf8LossyChunk<'a>

fn eq(&self, other: &Utf8LossyChunk<'a>) -> bool

fn ne(&self, other: &Utf8LossyChunk<'a>) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 17]> for &'b [B] where     B: PartialEq<A>,

fn eq(&self, other: &[A; 17]) -> bool

fn ne(&self, other: &[A; 17]) -> bool

impl<Ret, A, B, C, D, E, F, G> PartialEq<unsafe fn(A, B, C, D, E, F, G) -> Ret> for unsafe fn(A, B, C, D, E, F, G) -> Ret

fn eq(&self, other: &unsafe fn(A, B, C, D, E, F, G) -> Ret) -> bool

fn ne(&self, other: &Rhs) -> bool

impl PartialEq<f64> for f64

fn eq(&self, other: &f64) -> bool

fn ne(&self, other: &f64) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 12]> for &'b [B] where     B: PartialEq<A>,

fn eq(&self, other: &[A; 12]) -> bool

fn ne(&self, other: &[A; 12]) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 16]> for &'b mut [B] where     B: PartialEq<A>,

fn eq(&self, other: &[A; 16]) -> bool

fn ne(&self, other: &[A; 16]) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 32]> for [B] where     B: PartialEq<A>,

fn eq(&self, other: &[A; 32]) -> bool

fn ne(&self, other: &[A; 32]) -> bool

impl<'a, 'b, A, B> PartialEq<[B; 27]> for [A; 27] where     A: PartialEq<B>,

fn eq(&self, other: &[B; 27]) -> bool

fn ne(&self, other: &[B; 27]) -> bool

impl PartialEq<f64x8> for f64x8

fn eq(&self, other: &f64x8) -> bool

fn ne(&self, other: &f64x8) -> bool

impl PartialEq<u16x4> for u16x4

fn eq(&self, other: &u16x4) -> bool

fn ne(&self, other: &u16x4) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 18]> for [B] where     B: PartialEq<A>,

fn eq(&self, other: &[A; 18]) -> bool

fn ne(&self, other: &[A; 18]) -> bool

impl<Ret, A> PartialEq<extern "C" fn(A, ...) -> Ret> for extern "C" fn(A, ...) -> Ret

fn eq(&self, other: &extern "C" fn(A, ...) -> Ret) -> bool

fn ne(&self, other: &Rhs) -> bool

impl<'a, 'b, A, B> PartialEq<&'b [B]> for [A; 32] where     A: PartialEq<B>,

fn eq(&self, other: &&'b [B]) -> bool

fn ne(&self, other: &&'b [B]) -> bool

impl<Ret, A, B> PartialEq<extern "C" fn(A, B) -> Ret> for extern "C" fn(A, B) -> Ret

fn eq(&self, other: &extern "C" fn(A, B) -> Ret) -> bool

fn ne(&self, other: &Rhs) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 11]> for &'b mut [B] where     B: PartialEq<A>,

fn eq(&self, other: &[A; 11]) -> bool

fn ne(&self, other: &[A; 11]) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 23]> for &'b mut [B] where     B: PartialEq<A>,

fn eq(&self, other: &[A; 23]) -> bool

fn ne(&self, other: &[A; 23]) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 22]> for [B] where     B: PartialEq<A>,

fn eq(&self, other: &[A; 22]) -> bool

fn ne(&self, other: &[A; 22]) -> bool

impl PartialEq<m16x8> for m16x8

fn eq(&self, other: &m16x8) -> bool

fn ne(&self, other: &m16x8) -> bool

impl<'a, 'b, A, B> PartialEq<[A; 20]> for [B] where     B: PartialEq<A>,

fn eq(&self, other: &[A; 20]) -> bool

fn ne(&self, other: &[A; 20]) -> bool

impl<'a, 'b> PartialEq<String> for &'a str

fn eq(&self, other: &String) -> bool

fn ne(&self, other: &String) -> bool

impl<'a, 'b> PartialEq<str> for Cow<'a, str>

fn eq(&self, other: &str) -> bool

fn ne(&self, other: &str) -> bool

impl<T> PartialEq<Rc<T>> for Rc<T> where     T: PartialEq<T> + ?Sized,

fn eq(&self, other: &Rc<T>) -> bool

Equality for two Rcs.

Two Rcs are equal if their inner values are equal.

Examples

use std::rc::Rc;

let five = Rc::new(5);

assert!(five == Rc::new(5));

fn ne(&self, other: &Rc<T>) -> bool

Inequality for two Rcs.

Two Rcs are unequal if their inner values are unequal.

Examples

use std::rc::Rc;

let five = Rc::new(5);

assert!(five != Rc::new(6));

impl<'a, 'b> PartialEq<Cow<'a, str>> for str

fn eq(&self, other: &Cow<'a, str>) -> bool

fn ne(&self, other: &Cow<'a, str>) -> bool

impl<'a, 'b> PartialEq<Cow<'a, str>> for &'b str

fn eq(&self, other: &Cow<'a, str>) -> bool

fn ne(&self, other: &Cow<'a, str>) -> bool

impl<'a, 'b> PartialEq<&'b str> for Cow<'a, str>

fn eq(&self, other: &&'b str) -> bool

fn ne(&self, other: &&'b str) -> bool

impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for Cow<'a, [A]> where     A: Clone + PartialEq<B>,

fn eq(&self, other: &&'b mut [B]) -> bool

fn ne(&self, other: &&'b mut [B]) -> bool

impl<'a, 'b, B, C> PartialEq<Cow<'b, C>> for Cow<'a, B> where     B: PartialEq<C> + ToOwned + ?Sized,     C: ToOwned + ?Sized,

fn eq(&self, other: &Cow<'b, C>) -> bool

fn ne(&self, other: &Rhs) -> bool

impl<T> PartialEq<Arc<T>> for Arc<T> where     T: PartialEq<T> + ?Sized,

fn eq(&self, other: &Arc<T>) -> bool

Equality for two Arcs.

Two Arcs are equal if their inner values are equal.

Examples

use std::sync::Arc;

let five = Arc::new(5);

assert!(five == Arc::new(5));

fn ne(&self, other: &Arc<T>) -> bool

Inequality for two Arcs.

Two Arcs are unequal if their inner values are unequal.

Examples

use std::sync::Arc;

let five = Arc::new(5);

assert!(five != Arc::new(6));

impl<'a, 'b> PartialEq<String> for str

fn eq(&self, other: &String) -> bool

fn ne(&self, other: &String) -> bool

impl<'a, 'b> PartialEq<String> for Cow<'a, str>

fn eq(&self, other: &String) -> bool

fn ne(&self, other: &String) -> bool

impl<'a, 'b, A, B> PartialEq<&'b [B]> for Cow<'a, [A]> where     A: Clone + PartialEq<B>,

fn eq(&self, other: &&'b [B]) -> bool

fn ne(&self, other: &&'b [B]) -> bool

impl<'a, 'b, A, B> PartialEq<Vec<B>> for Cow<'a, [A]> where     A: Clone + PartialEq<B>,

fn eq(&self, other: &Vec<B>) -> bool

fn ne(&self, other: &Vec<B>) -> bool

impl PartialEq<_Unwind_Reason_Code> for _Unwind_Reason_Code

fn eq(&self, other: &_Unwind_Reason_Code) -> bool

fn ne(&self, other: &Rhs) -> bool

impl PartialEq<_Unwind_Action> for _Unwind_Action

fn eq(&self, other: &_Unwind_Action) -> bool

fn ne(&self, other: &Rhs) -> bool

impl PartialEq<Char> for char

fn eq(&self, other: &Char) -> bool

fn ne(&self, other: &Rhs) -> bool

impl<'t> PartialEq<Match<'t>> for Match<'t>

fn eq(&self, other: &Match<'t>) -> bool

fn ne(&self, other: &Match<'t>) -> bool

impl PartialEq<Error> for Error

fn eq(&self, other: &Error) -> bool

fn ne(&self, other: &Error) -> bool

impl<'t> PartialEq<Match<'t>> for Match<'t>

fn eq(&self, other: &Match<'t>) -> bool

fn ne(&self, other: &Match<'t>) -> bool

impl PartialEq<Match> for Match

fn eq(&self, other: &Match) -> bool

fn ne(&self, other: &Match) -> bool

impl PartialEq<Error> for Error

fn eq(&self, other: &Error) -> bool

fn ne(&self, other: &Error) -> bool

impl PartialEq<Flags> for Flags

fn eq(&self, other: &Flags) -> bool

fn ne(&self, other: &Flags) -> bool

impl PartialEq<ClassUnicode> for ClassUnicode

fn eq(&self, other: &ClassUnicode) -> bool

fn ne(&self, other: &ClassUnicode) -> bool

impl PartialEq<Group> for Group

fn eq(&self, other: &Group) -> bool

fn ne(&self, other: &Group) -> bool

impl PartialEq<RepetitionKind> for RepetitionKind

fn eq(&self, other: &RepetitionKind) -> bool

fn ne(&self, other: &RepetitionKind) -> bool

impl PartialEq<HirKind> for HirKind

fn eq(&self, other: &HirKind) -> bool

fn ne(&self, other: &HirKind) -> bool

impl PartialEq<Concat> for Concat

fn eq(&self, other: &Concat) -> bool

fn ne(&self, other: &Concat) -> bool

impl PartialEq<FlagsItem> for FlagsItem

fn eq(&self, other: &FlagsItem) -> bool

fn ne(&self, other: &FlagsItem) -> bool

impl PartialEq<RepetitionOp> for RepetitionOp

fn eq(&self, other: &RepetitionOp) -> bool

fn ne(&self, other: &RepetitionOp) -> bool

impl PartialEq<ClassUnicodeRange> for ClassUnicodeRange

fn eq(&self, other: &ClassUnicodeRange) -> bool

fn ne(&self, other: &ClassUnicodeRange) -> bool

impl PartialEq<Repetition> for Repetition

fn eq(&self, other: &Repetition) -> bool

fn ne(&self, other: &Repetition) -> bool

impl PartialEq<Alternation> for Alternation

fn eq(&self, other: &Alternation) -> bool

fn ne(&self, other: &Alternation) -> bool

impl PartialEq<Error> for Error

fn eq(&self, other: &Error) -> bool

fn ne(&self, other: &Error) -> bool

impl PartialEq<WithComments> for WithComments

fn eq(&self, other: &WithComments) -> bool

fn ne(&self, other: &WithComments) -> bool

impl PartialEq<ClassUnicodeKind> for ClassUnicodeKind

fn eq(&self, other: &ClassUnicodeKind) -> bool

fn ne(&self, other: &ClassUnicodeKind) -> bool

impl PartialEq<Assertion> for Assertion

fn eq(&self, other: &Assertion) -> bool

fn ne(&self, other: &Assertion) -> bool

impl PartialEq<Class> for Class

fn eq(&self, other: &Class) -> bool

fn ne(&self, other: &Class) -> bool

impl PartialEq<ClassSetUnion> for ClassSetUnion

fn eq(&self, other: &ClassSetUnion) -> bool

fn ne(&self, other: &ClassSetUnion) -> bool

impl PartialEq<ErrorKind> for ErrorKind

fn eq(&self, other: &ErrorKind) -> bool

fn ne(&self, other: &Rhs) -> bool

impl PartialEq<AssertionKind> for AssertionKind

fn eq(&self, other: &AssertionKind) -> bool

fn ne(&self, other: &Rhs) -> bool

impl PartialEq<Error> for Error

fn eq(&self, other: &Error) -> bool

fn ne(&self, other: &Error) -> bool

impl PartialEq<Hir> for Hir

fn eq(&self, other: &Hir) -> bool

fn ne(&self, other: &Hir) -> bool

impl PartialEq<ClassUnicodeOpKind> for ClassUnicodeOpKind

fn eq(&self, other: &ClassUnicodeOpKind) -> bool

fn ne(&self, other: &Rhs) -> bool

impl PartialEq<HexLiteralKind> for HexLiteralKind

fn eq(&self, other: &HexLiteralKind) -> bool

fn ne(&self, other: &Rhs) -> bool

impl PartialEq<RepetitionKind> for RepetitionKind

fn eq(&self, other: &RepetitionKind) -> bool

fn ne(&self, other: &RepetitionKind) -> bool

impl PartialEq<ClassUnicode> for ClassUnicode

fn eq(&self, other: &ClassUnicode) -> bool

fn ne(&self, other: &ClassUnicode) -> bool

impl PartialEq<Position> for Position

fn eq(&self, other: &Position) -> bool

fn ne(&self, other: &Position) -> bool

impl PartialEq<ClassBytesRange> for ClassBytesRange

fn eq(&self, other: &ClassBytesRange) -> bool

fn ne(&self, other: &ClassBytesRange) -> bool

impl PartialEq<CaptureName> for CaptureName

fn eq(&self, other: &CaptureName) -> bool

fn ne(&self, other: &CaptureName) -> bool

impl PartialEq<Comment> for Comment

fn eq(&self, other: &Comment) -> bool

fn ne(&self, other: &Comment) -> bool

impl PartialEq<FlagsItemKind> for FlagsItemKind

fn eq(&self, other: &FlagsItemKind) -> bool

fn ne(&self, other: &FlagsItemKind) -> bool

impl PartialEq<Repetition> for Repetition

fn eq(&self, other: &Repetition) -> bool

fn ne(&self, other: &Repetition) -> bool

impl PartialEq<Flag> for Flag

fn eq(&self, other: &Flag) -> bool

fn ne(&self, other: &Rhs) -> bool

impl PartialEq<Ast> for Ast

fn eq(&self, other: &Ast) -> bool

fn ne(&self, other: &Ast) -> bool

impl PartialEq<ClassSetItem> for ClassSetItem

fn eq(&self, other: &ClassSetItem) -> bool

fn ne(&self, other: &ClassSetItem) -> bool

impl PartialEq<Literal> for Literal

fn eq(&self, other: &Literal) -> bool

fn ne(&self, other: &Literal) -> bool

impl PartialEq<Literals> for Literals

fn eq(&self, other: &Literals) -> bool

fn ne(&self, other: &Literals) -> bool

impl PartialEq<Class> for Class

fn eq(&self, other: &Class) -> bool

fn ne(&self, other: &Class) -> bool

impl PartialEq<Group> for Group

fn eq(&self, other: &Group) -> bool

fn ne(&self, other: &Group) -> bool

impl PartialEq<GroupKind> for GroupKind

fn eq(&self, other: &GroupKind) -> bool

fn ne(&self, other: &GroupKind) -> bool

impl PartialEq<GroupKind> for GroupKind

fn eq(&self, other: &GroupKind) -> bool

fn ne(&self, other: &GroupKind) -> bool

impl PartialEq<SetFlags> for SetFlags

fn eq(&self, other: &SetFlags) -> bool

fn ne(&self, other: &SetFlags) -> bool

impl PartialEq<RepetitionRange> for RepetitionRange

fn eq(&self, other: &RepetitionRange) -> bool

fn ne(&self, other: &RepetitionRange) -> bool

impl PartialEq<Anchor> for Anchor

fn eq(&self, other: &Anchor) -> bool

fn ne(&self, other: &Rhs) -> bool

impl PartialEq<ErrorKind> for ErrorKind

fn eq(&self, other: &ErrorKind) -> bool

fn ne(&self, other: &ErrorKind) -> bool

impl PartialEq<Span> for Span

fn eq(&self, other: &Span) -> bool

fn ne(&self, other: &Span) -> bool

impl PartialEq<ClassSetRange> for ClassSetRange

fn eq(&self, other: &ClassSetRange) -> bool

fn ne(&self, other: &ClassSetRange) -> bool

impl PartialEq<Literal> for Literal

fn eq(&self, other: &Literal) -> bool

fn ne(&self, other: &Rhs) -> bool

impl PartialEq<ClassPerlKind> for ClassPerlKind

fn eq(&self, other: &ClassPerlKind) -> bool

fn ne(&self, other: &Rhs) -> bool

impl PartialEq<RepetitionRange> for RepetitionRange

fn eq(&self, other: &RepetitionRange) -> bool

fn ne(&self, other: &RepetitionRange) -> bool

impl PartialEq<Literal> for Literal

fn eq(&self, other: &Literal) -> bool

fn ne(&self, other: &Literal) -> bool

impl PartialEq<LiteralKind> for LiteralKind

fn eq(&self, other: &LiteralKind) -> bool

fn ne(&self, other: &LiteralKind) -> bool

impl PartialEq<ClassSet> for ClassSet

fn eq(&self, other: &ClassSet) -> bool

fn ne(&self, other: &ClassSet) -> bool

impl PartialEq<WordBoundary> for WordBoundary

fn eq(&self, other: &WordBoundary) -> bool

fn ne(&self, other: &Rhs) -> bool

impl PartialEq<ClassBytes> for ClassBytes

fn eq(&self, other: &ClassBytes) -> bool

fn ne(&self, other: &ClassBytes) -> bool

impl PartialEq<ClassAscii> for ClassAscii

fn eq(&self, other: &ClassAscii) -> bool

fn ne(&self, other: &ClassAscii) -> bool

impl PartialEq<SpecialLiteralKind> for SpecialLiteralKind

fn eq(&self, other: &SpecialLiteralKind) -> bool

fn ne(&self, other: &Rhs) -> bool

impl PartialEq<ClassAsciiKind> for ClassAsciiKind

fn eq(&self, other: &ClassAsciiKind) -> bool

fn ne(&self, other: &Rhs) -> bool

impl PartialEq<ClassSetBinaryOpKind> for ClassSetBinaryOpKind

fn eq(&self, other: &ClassSetBinaryOpKind) -> bool

fn ne(&self, other: &Rhs) -> bool

impl PartialEq<ClassSetBinaryOp> for ClassSetBinaryOp

fn eq(&self, other: &ClassSetBinaryOp) -> bool

fn ne(&self, other: &ClassSetBinaryOp) -> bool

impl PartialEq<ClassBracketed> for ClassBracketed

fn eq(&self, other: &ClassBracketed) -> bool

fn ne(&self, other: &ClassBracketed) -> bool

impl PartialEq<ClassPerl> for ClassPerl

fn eq(&self, other: &ClassPerl) -> bool

fn ne(&self, other: &ClassPerl) -> bool

impl PartialEq<Utf8Range> for Utf8Range

fn eq(&self, other: &Utf8Range) -> bool

fn ne(&self, other: &Utf8Range) -> bool

impl PartialEq<Utf8Sequence> for Utf8Sequence

fn eq(&self, other: &Utf8Sequence) -> bool

fn ne(&self, other: &Utf8Sequence) -> bool

Implementors

• impl<T, S> PartialEq<HashSet<T, S>> for HashSet<T, S> where     S: BuildHasher,     T: Eq + Hash,

• impl<K, V, S> PartialEq<HashMap<K, V, S>> for HashMap<K, V, S> where     K: Eq + Hash,     S: BuildHasher,     V: PartialEq<V>,

• impl<Idx> PartialEq<RangeTo<Idx>> for RangeTo<Idx> where     Idx: PartialEq<Idx>,

• impl PartialEq<Ordering> for Ordering

• impl<Idx> PartialEq<RangeToInclusive<Idx>> for RangeToInclusive<Idx> where     Idx: PartialEq<Idx>,

• impl<Idx> PartialEq<RangeInclusive<Idx>> for RangeInclusive<Idx> where     Idx: PartialEq<Idx>,

• impl<Idx> PartialEq<RangeFrom<Idx>> for RangeFrom<Idx> where     Idx: PartialEq<Idx>,

• impl PartialEq<Utf8Error> for Utf8Error

• impl PartialEq<SearchStep> for SearchStep

• impl PartialEq<Error> for nom::lib::std::fmt::Error

• impl<T> PartialEq<Option<T>> for Option<T> where     T: PartialEq<T>,

• impl<T> PartialEq<Bound<T>> for Bound<T> where     T: PartialEq<T>,

• impl<T, E> PartialEq<Result<T, E>> for Result<T, E> where     E: PartialEq<E>,     T: PartialEq<T>,

• impl<Y, R> PartialEq<GeneratorState<Y, R>> for GeneratorState<Y, R> where     R: PartialEq<R>,     Y: PartialEq<Y>,

• impl<Idx> PartialEq<Range<Idx>> for Range<Idx> where     Idx: PartialEq<Idx>,

• impl PartialEq<CollectionAllocErr> for CollectionAllocErr

• impl PartialEq<RangeFull> for RangeFull

• impl PartialEq<ParseBoolError> for ParseBoolError

• impl<T> PartialEq<ManuallyDrop<T>> for ManuallyDrop<T> where     T: PartialEq<T>,

• impl PartialEq<NoneError> for NoneError

• impl<T> PartialEq<Reverse<T>> for Reverse<T> where     T: PartialEq<T>,

• impl<T> PartialEq<Discriminant<T>> for Discriminant<T>

• impl<'a, 'b, A, B> PartialEq<&'b mut [B; 0]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b mut [B; 1]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 3]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 30]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 32]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 12]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 20]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 4]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b mut [B; 4]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 31]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 32]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 2]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 16]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 21]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 21]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b mut [B; 12]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b mut [B; 5]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 0]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 15]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 8]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 15]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 23]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b mut [B; 23]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 17]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 22]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 7]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 10]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 24]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b mut [B; 22]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 8]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b mut [B; 25]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 27]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 12]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 30]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<Vec<B>> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 28]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 14]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 24]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 1]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 31]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 17]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 14]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b mut [B; 27]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b mut [B; 17]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b mut [B; 26]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 26]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 14]> for Vec<A> where     A: PartialEq<B>,

• impl<T> PartialEq<BTreeSet<T>> for BTreeSet<T> where     T: PartialEq<T>,

• impl<'a, 'b, A, B> PartialEq<[B; 28]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 31]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 26]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 30]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 3]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 11]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 32]> for VecDeque<A> where     A: PartialEq<B>,

• impl PartialEq<String> for String

• impl<'a, 'b, A, B> PartialEq<&'b [B; 8]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b mut [B; 7]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 23]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 27]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<Vec<B>> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 20]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 23]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 3]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 2]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 13]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 6]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 16]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 13]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b mut [B; 31]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 1]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 27]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b mut [B; 18]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b mut [B; 20]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 27]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 18]> for VecDeque<A> where     A: PartialEq<B>,

• impl PartialEq<ParseError> for ParseError

• impl<'a, 'b, A, B> PartialEq<[B; 6]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b mut [B; 19]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b> PartialEq<Cow<'a, str>> for String

• impl<'a, 'b, A, B> PartialEq<[B; 2]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 13]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 5]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 3]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b mut [B; 32]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b> PartialEq<str> for String

• impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 18]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b mut [B; 30]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 19]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b mut [B; 2]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 1]> for Vec<A> where     A: PartialEq<B>,

• impl<K, V> PartialEq<BTreeMap<K, V>> for BTreeMap<K, V> where     K: PartialEq<K>,     V: PartialEq<V>,

• impl<'a, 'b, A, B> PartialEq<&'b mut [B; 13]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 15]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 20]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 19]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b mut [B; 11]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 25]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 25]> for VecDeque<A> where     A: PartialEq<B>,

• impl<T> PartialEq<LinkedList<T>> for LinkedList<T> where     T: PartialEq<T>,

• impl<'a, 'b, A, B> PartialEq<[B; 29]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 19]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 22]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 7]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 9]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 0]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 18]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 5]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 28]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 11]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 31]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 1]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 7]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b mut [B; 15]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 5]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 9]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 4]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 0]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 11]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b mut [B; 8]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 9]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 17]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 14]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 21]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 2]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 6]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b mut [B; 3]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 28]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 13]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 8]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 4]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 24]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 17]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 32]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 0]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 10]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 22]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 25]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 21]> for Vec<A> where     A: PartialEq<B>,

• impl<T> PartialEq<Box<T>> for Box<T> where     T: PartialEq<T> + ?Sized,

• impl<'a, 'b, A, B> PartialEq<&'b mut [B; 28]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 16]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 30]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 5]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 25]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 9]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 12]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 4]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 15]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b> PartialEq<&'a str> for String

• impl<'a, 'b, A, B> PartialEq<[B; 12]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 18]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 10]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 26]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 29]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 24]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b mut [B; 10]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b mut [B; 16]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 11]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 10]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 6]> for VecDeque<A> where     A: PartialEq<B>,

• impl<A> PartialEq<VecDeque<A>> for VecDeque<A> where     A: PartialEq<A>,

• impl<'a, 'b, A, B> PartialEq<[B; 22]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b mut [B; 29]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b mut [B; 14]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 23]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 26]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 7]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 20]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b mut [B; 9]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 29]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b mut [B; 6]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<[B; 29]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b mut [B; 24]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 19]> for Vec<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b mut [B; 21]> for VecDeque<A> where     A: PartialEq<B>,

• impl<'a, 'b, A, B> PartialEq<&'b [B; 16]> for VecDeque<A> where     A: PartialEq<B>,

• impl<E: PartialEq> PartialEq for nom::ErrorKind<E>

• impl<I: PartialEq, E: PartialEq> PartialEq for Context<I, E>

• impl PartialEq for Needed

• impl<I: PartialEq, E: PartialEq> PartialEq for Err<I, E>

• impl PartialEq for CompareResult

• impl PartialEq for Endianness

• impl<'a> PartialEq for CompleteStr<'a>

• impl<'a> PartialEq for CompleteByteSlice<'a>

• impl<T: PartialEq> PartialEq for Input<T>