Trait nom::lib::std::cmp::PartialEq 1.0.0[−][src]
Trait for equality comparisons which are partial equivalence relations.
This trait allows for partial equality, for types that do not have a full
equivalence relation. For example, in floating point numbers NaN != NaN
,
so floating point types implement PartialEq
but not Eq
.
Formally, the equality must be (for all a
, b
, c
of type A
, B
,
C
):
-
Symmetric: if
A: PartialEq<B>
andB: PartialEq<A>
, thena == b
impliesb == a
; and -
Transitive: if
A: PartialEq<B>
andB: PartialEq<C>
andA: PartialEq<C>
, thena == b
andb == c
impliesa == c
.
Note that the B: PartialEq<A>
(symmetric) and A: PartialEq<C>
(transitive) impls are not forced to exist, but these requirements apply
whenever they do exist.
Derivable
This trait can be used with #[derive]
. When derive
d on structs, two
instances are equal if all fields are equal, and not equal if any fields
are not equal. When derive
d on enums, each variant is equal to itself
and not equal to the other variants.
How can I implement PartialEq
?
PartialEq
only requires the eq
method to be implemented; ne
is defined
in terms of it by default. Any manual implementation of ne
must respect
the rule that eq
is a strict inverse of ne
; that is, !(a == b)
if and
only if a != b
.
Implementations of PartialEq
, PartialOrd
, and Ord
must agree with
each other. It's easy to accidentally make them disagree by deriving some
of the traits and manually implementing others.
An example implementation for a domain in which two books are considered the same book if their ISBN matches, even if the formats differ:
enum BookFormat { Paperback, Hardback, Ebook, } struct Book { isbn: i32, format: BookFormat, } impl PartialEq for Book { fn eq(&self, other: &Self) -> bool { self.isbn == other.isbn } } let b1 = Book { isbn: 3, format: BookFormat::Paperback }; let b2 = Book { isbn: 3, format: BookFormat::Ebook }; let b3 = Book { isbn: 10, format: BookFormat::Paperback }; assert!(b1 == b2); assert!(b1 != b3);
How can I compare two different types?
The type you can compare with is controlled by PartialEq
's type parameter.
For example, let's tweak our previous code a bit:
// The derive implements <BookFormat> == <BookFormat> comparisons #[derive(PartialEq)] enum BookFormat { Paperback, Hardback, Ebook, } struct Book { isbn: i32, format: BookFormat, } // Implement <Book> == <BookFormat> comparisons impl PartialEq<BookFormat> for Book { fn eq(&self, other: &BookFormat) -> bool { self.format == *other } } // Implement <BookFormat> == <Book> comparisons impl PartialEq<Book> for BookFormat { fn eq(&self, other: &Book) -> bool { *self == other.format } } let b1 = Book { isbn: 3, format: BookFormat::Paperback }; assert!(b1 == BookFormat::Paperback); assert!(BookFormat::Ebook != b1);
By changing impl PartialEq for Book
to impl PartialEq<BookFormat> for Book
,
we allow BookFormat
s to be compared with Book
s.
A comparison like the one above, which ignores some fields of the struct,
can be dangerous. It can easily lead to an unintended violation of the
requirements for a partial equivalence relation. For example, if we kept
the above implementation of PartialEq<Book>
for BookFormat
and added an
implementation of PartialEq<Book>
for Book
(either via a #[derive]
or
via the manual implementation from the first example) then the result would
violate transitivity:
#[derive(PartialEq)] enum BookFormat { Paperback, Hardback, Ebook, } #[derive(PartialEq)] struct Book { isbn: i32, format: BookFormat, } impl PartialEq<BookFormat> for Book { fn eq(&self, other: &BookFormat) -> bool { self.format == *other } } impl PartialEq<Book> for BookFormat { fn eq(&self, other: &Book) -> bool { *self == other.format } } fn main() { let b1 = Book { isbn: 1, format: BookFormat::Paperback }; let b2 = Book { isbn: 2, format: BookFormat::Paperback }; assert!(b1 == BookFormat::Paperback); assert!(BookFormat::Paperback == b2); // The following should hold by transitivity but doesn't. assert!(b1 == b2); // <-- PANICS }
Examples
let x: u32 = 0; let y: u32 = 1; assert_eq!(x == y, false); assert_eq!(x.eq(&y), false);
Required methods
#[must_use]pub fn eq(&self, other: &Rhs) -> bool
[src]
This method tests for self
and other
values to be equal, and is used
by ==
.
Provided methods
Loading content...Implementations on Foreign Types
impl PartialEq<NulError> for NulError
[src]
impl PartialEq<FromVecWithNulError> for FromVecWithNulError
[src]
pub fn eq(&self, other: &FromVecWithNulError) -> bool
[src]
pub fn ne(&self, other: &FromVecWithNulError) -> bool
[src]
impl<'a, 'b> PartialEq<PathBuf> for OsString
[src]
impl PartialEq<WaitTimeoutResult> for WaitTimeoutResult
[src]
pub fn eq(&self, other: &WaitTimeoutResult) -> bool
[src]
pub fn ne(&self, other: &WaitTimeoutResult) -> bool
[src]
impl<'a, 'b> PartialEq<OsStr> for Path
[src]
impl<'a, 'b> PartialEq<&'a OsStr> for OsString
[src]
impl PartialEq<CStr> for CStr
[src]
impl PartialEq<AddrParseError> for AddrParseError
[src]
pub fn eq(&self, other: &AddrParseError) -> bool
[src]
pub fn ne(&self, other: &AddrParseError) -> bool
[src]
impl<'a, 'b> PartialEq<Cow<'a, Path>> for OsStr
[src]
impl PartialEq<OsString> for OsString
[src]
impl PartialEq<SeekFrom> for SeekFrom
[src]
impl<'a, 'b> PartialEq<&'a Path> for OsString
[src]
impl<'a, 'b> PartialEq<Path> for OsString
[src]
impl<'a, 'b> PartialEq<OsString> for &'a Path
[src]
impl<'a, 'b> PartialEq<OsString> for Path
[src]
impl<'a, 'b> PartialEq<Cow<'a, Path>> for &'b Path
[src]
impl PartialEq<Output> for Output
[src]
impl<'a, 'b> PartialEq<Cow<'a, OsStr>> for Path
[src]
impl PartialEq<UCred> for UCred
[src]
impl<'a, 'b> PartialEq<Path> for PathBuf
[src]
impl PartialEq<SystemTime> for SystemTime
[src]
pub fn eq(&self, other: &SystemTime) -> bool
[src]
pub fn ne(&self, other: &SystemTime) -> bool
[src]
impl<'a> PartialEq<Component<'a>> for Component<'a>
[src]
pub fn eq(&self, other: &Component<'a>) -> bool
[src]
pub fn ne(&self, other: &Component<'a>) -> bool
[src]
impl<'a> PartialEq<OsString> for &'a str
[src]
impl PartialEq<SocketAddrV6> for SocketAddrV6
[src]
pub fn eq(&self, other: &SocketAddrV6) -> bool
[src]
impl PartialEq<TryRecvError> for TryRecvError
[src]
pub fn eq(&self, other: &TryRecvError) -> bool
[src]
impl<'a, 'b> PartialEq<Cow<'a, OsStr>> for OsStr
[src]
impl<'a, 'b> PartialEq<Path> for &'a OsStr
[src]
impl PartialEq<OsString> for str
[src]
impl PartialEq<Ipv6Addr> for IpAddr
[src]
impl PartialEq<ThreadId> for ThreadId
[src]
impl<'a, 'b> PartialEq<&'a OsStr> for PathBuf
[src]
impl PartialEq<OsStr> for OsStr
[src]
impl<'a> PartialEq<Prefix<'a>> for Prefix<'a>
[src]
impl PartialEq<Ipv6Addr> for Ipv6Addr
[src]
impl PartialEq<ErrorKind> for ErrorKind
[src]
impl<'a, 'b> PartialEq<PathBuf> for &'a OsStr
[src]
impl<T> PartialEq<SendError<T>> for SendError<T> where
T: PartialEq<T>,
[src]
T: PartialEq<T>,
pub fn eq(&self, other: &SendError<T>) -> bool
[src]
pub fn ne(&self, other: &SendError<T>) -> bool
[src]
impl PartialEq<IntoStringError> for IntoStringError
[src]
pub fn eq(&self, other: &IntoStringError) -> bool
[src]
pub fn ne(&self, other: &IntoStringError) -> bool
[src]
impl PartialEq<BacktraceStatus> for BacktraceStatus
[src]
pub fn eq(&self, other: &BacktraceStatus) -> bool
[src]
impl<'a, 'b> PartialEq<&'a OsStr> for Path
[src]
impl<'a, 'b> PartialEq<OsStr> for OsString
[src]
impl PartialEq<Permissions> for Permissions
[src]
pub fn eq(&self, other: &Permissions) -> bool
[src]
pub fn ne(&self, other: &Permissions) -> bool
[src]
impl PartialEq<Path> for Path
[src]
impl PartialEq<str> for OsString
[src]
impl<'a, 'b> PartialEq<OsString> for PathBuf
[src]
impl<'a, 'b> PartialEq<Cow<'a, Path>> for Path
[src]
impl<'a> PartialEq<Components<'a>> for Components<'a>
[src]
pub fn eq(&self, other: &Components<'a>) -> bool
[src]
impl<'a, 'b> PartialEq<OsString> for &'a OsStr
[src]
impl<'a, 'b> PartialEq<&'a Path> for OsStr
[src]
impl PartialEq<IpAddr> for Ipv4Addr
[src]
impl PartialEq<Instant> for Instant
[src]
impl<'a, 'b> PartialEq<Cow<'b, OsStr>> for &'a Path
[src]
impl PartialEq<CString> for CString
[src]
impl<'a, 'b> PartialEq<Cow<'a, Path>> for PathBuf
[src]
impl PartialEq<RecvError> for RecvError
[src]
impl PartialEq<SocketAddrV4> for SocketAddrV4
[src]
pub fn eq(&self, other: &SocketAddrV4) -> bool
[src]
impl<'a, 'b> PartialEq<Path> for OsStr
[src]
impl<'a, 'b> PartialEq<PathBuf> for &'a Path
[src]
impl<'a, 'b> PartialEq<Cow<'a, OsStr>> for &'b OsStr
[src]
impl PartialEq<Shutdown> for Shutdown
[src]
impl<T> PartialEq<TrySendError<T>> for TrySendError<T> where
T: PartialEq<T>,
[src]
T: PartialEq<T>,
pub fn eq(&self, other: &TrySendError<T>) -> bool
[src]
pub fn ne(&self, other: &TrySendError<T>) -> bool
[src]
impl<T> PartialEq<Cursor<T>> for Cursor<T> where
T: PartialEq<T>,
[src]
T: PartialEq<T>,
impl<'a, 'b> PartialEq<Cow<'a, OsStr>> for OsString
[src]
impl<'a, 'b> PartialEq<OsString> for OsStr
[src]
impl<'a, 'b> PartialEq<Cow<'a, Path>> for &'b OsStr
[src]
impl<'a, 'b> PartialEq<Cow<'a, OsStr>> for PathBuf
[src]
impl<'a, 'b> PartialEq<PathBuf> for Path
[src]
impl PartialEq<FromBytesWithNulError> for FromBytesWithNulError
[src]
pub fn eq(&self, other: &FromBytesWithNulError) -> bool
[src]
pub fn ne(&self, other: &FromBytesWithNulError) -> bool
[src]
impl<'_> PartialEq<&'_ str> for OsString
[src]
impl PartialEq<str> for OsStr
[src]
impl PartialEq<Ipv6MulticastScope> for Ipv6MulticastScope
[src]
pub fn eq(&self, other: &Ipv6MulticastScope) -> bool
[src]
impl<'a, 'b> PartialEq<Cow<'a, Path>> for OsString
[src]
impl PartialEq<Ipv4Addr> for IpAddr
[src]
impl PartialEq<StripPrefixError> for StripPrefixError
[src]
pub fn eq(&self, other: &StripPrefixError) -> bool
[src]
pub fn ne(&self, other: &StripPrefixError) -> bool
[src]
impl<'a, 'b> PartialEq<OsStr> for &'a Path
[src]
impl<T> PartialEq<SyncOnceCell<T>> for SyncOnceCell<T> where
T: PartialEq<T>,
[src]
T: PartialEq<T>,
pub fn eq(&self, other: &SyncOnceCell<T>) -> bool
[src]
impl<'a, 'b> PartialEq<OsStr> for PathBuf
[src]
impl<'a> PartialEq<PrefixComponent<'a>> for PrefixComponent<'a>
[src]
pub fn eq(&self, other: &PrefixComponent<'a>) -> bool
[src]
impl PartialEq<FileType> for FileType
[src]
impl PartialEq<VarError> for VarError
[src]
impl<'a, 'b> PartialEq<&'a Path> for PathBuf
[src]
impl PartialEq<AccessError> for AccessError
[src]
pub fn eq(&self, other: &AccessError) -> bool
[src]
pub fn ne(&self, other: &AccessError) -> bool
[src]
impl PartialEq<ExitStatus> for ExitStatus
[src]
pub fn eq(&self, other: &ExitStatus) -> bool
[src]
pub fn ne(&self, other: &ExitStatus) -> bool
[src]
impl PartialEq<PathBuf> for PathBuf
[src]
impl<'a, 'b> PartialEq<PathBuf> for OsStr
[src]
impl PartialEq<IpAddr> for Ipv6Addr
[src]
impl PartialEq<IpAddr> for IpAddr
[src]
impl PartialEq<Ipv4Addr> for Ipv4Addr
[src]
impl PartialEq<RecvTimeoutError> for RecvTimeoutError
[src]
pub fn eq(&self, other: &RecvTimeoutError) -> bool
[src]
impl PartialEq<OsStr> for str
[src]
impl PartialEq<SocketAddr> for SocketAddr
[src]
pub fn eq(&self, other: &SocketAddr) -> bool
[src]
pub fn ne(&self, other: &SocketAddr) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G> PartialEq<fn(A, B, C, D, E, F, G) -> Ret> for fn(A, B, C, D, E, F, G) -> Ret
[src]
impl<Ret, A, B, C, D, E, F> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F) -> Ret
[src]
impl PartialEq<NonZeroI32> for NonZeroI32
[src]
pub fn eq(&self, other: &NonZeroI32) -> bool
[src]
pub fn ne(&self, other: &NonZeroI32) -> bool
[src]
impl<A, B, C, D, E, F, G, H, I, J, K> PartialEq<(A, B, C, D, E, F, G, H, I, J, K)> for (A, B, C, D, E, F, G, H, I, J, K) where
C: PartialEq<C>,
F: PartialEq<F>,
E: PartialEq<E>,
I: PartialEq<I>,
G: PartialEq<G>,
H: PartialEq<H>,
A: PartialEq<A>,
B: PartialEq<B>,
D: PartialEq<D>,
J: PartialEq<J>,
K: PartialEq<K> + ?Sized,
[src]
C: PartialEq<C>,
F: PartialEq<F>,
E: PartialEq<E>,
I: PartialEq<I>,
G: PartialEq<G>,
H: PartialEq<H>,
A: PartialEq<A>,
B: PartialEq<B>,
D: PartialEq<D>,
J: PartialEq<J>,
K: PartialEq<K> + ?Sized,
pub fn eq(&self, other: &(A, B, C, D, E, F, G, H, I, J, K)) -> bool
[src]
pub fn ne(&self, other: &(A, B, C, D, E, F, G, H, I, J, K)) -> bool
[src]
impl<T> PartialEq<*mut T> for *mut T where
T: ?Sized,
[src]
T: ?Sized,
impl<Ret, A, B, C, D, E, F, G, H, I> PartialEq<fn(A, B, C, D, E, F, G, H, I) -> Ret> for fn(A, B, C, D, E, F, G, H, I) -> Ret
[src]
impl<Ret, A, B, C, D, E, F> PartialEq<unsafe fn(A, B, C, D, E, F) -> Ret> for unsafe fn(A, B, C, D, E, F) -> Ret
[src]
impl<Ret, A, B, C, D, E, F, G, H, I> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret
[src]
pub fn eq(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret
) -> bool
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret
) -> bool
impl<Ret, A> PartialEq<unsafe fn(A) -> Ret> for unsafe fn(A) -> Ret
[src]
impl<Ret, A, B, C, D> PartialEq<unsafe fn(A, B, C, D) -> Ret> for unsafe fn(A, B, C, D) -> Ret
[src]
impl<Ret, A, B, C, D, E, F> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret
[src]
pub fn eq(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret
) -> bool
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret
) -> bool
impl<Ret, A> PartialEq<extern "C" fn(A) -> Ret> for extern "C" fn(A) -> Ret
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialEq<fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for fn(A, B, C, D, E, F, G, H, I, J) -> Ret
[src]
impl<Ret, A, B, C, D> PartialEq<extern "C" fn(A, B, C, D) -> Ret> for extern "C" fn(A, B, C, D) -> Ret
[src]
impl PartialEq<Ordering> for Ordering
[src]
impl PartialEq<CharTryFromError> for CharTryFromError
[src]
pub fn eq(&self, other: &CharTryFromError) -> bool
[src]
pub fn ne(&self, other: &CharTryFromError) -> bool
[src]
impl<'_, '_, A, B> PartialEq<&'_ mut B> for &'_ A where
A: PartialEq<B> + ?Sized,
B: ?Sized,
[src]
A: PartialEq<B> + ?Sized,
B: ?Sized,
impl<Ret, A, B, C, D, E, F, G, H, I> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret
[src]
impl<Ret, A, B, C, D> PartialEq<unsafe extern "C" fn(A, B, C, D) -> Ret> for unsafe extern "C" fn(A, B, C, D) -> Ret
[src]
impl<'_, '_, A, B> PartialEq<&'_ mut B> for &'_ mut A where
A: PartialEq<B> + ?Sized,
B: ?Sized,
[src]
A: PartialEq<B> + ?Sized,
B: ?Sized,
impl<Ret, A, B, C, D, E, F, G, H, I> PartialEq<unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret
[src]
impl<A, B, C, D, E, F, G, H, I, J, K, L> PartialEq<(A, B, C, D, E, F, G, H, I, J, K, L)> for (A, B, C, D, E, F, G, H, I, J, K, L) where
C: PartialEq<C>,
F: PartialEq<F>,
E: PartialEq<E>,
I: PartialEq<I>,
G: PartialEq<G>,
H: PartialEq<H>,
A: PartialEq<A>,
B: PartialEq<B>,
D: PartialEq<D>,
J: PartialEq<J>,
K: PartialEq<K>,
L: PartialEq<L> + ?Sized,
[src]
C: PartialEq<C>,
F: PartialEq<F>,
E: PartialEq<E>,
I: PartialEq<I>,
G: PartialEq<G>,
H: PartialEq<H>,
A: PartialEq<A>,
B: PartialEq<B>,
D: PartialEq<D>,
J: PartialEq<J>,
K: PartialEq<K>,
L: PartialEq<L> + ?Sized,
pub fn eq(&self, other: &(A, B, C, D, E, F, G, H, I, J, K, L)) -> bool
[src]
pub fn ne(&self, other: &(A, B, C, D, E, F, G, H, I, J, K, L)) -> bool
[src]
impl PartialEq<str> for str
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
[src]
impl PartialEq<char> for char
[src]
impl<Ret, A> PartialEq<unsafe extern "C" fn(A, ...) -> Ret> for unsafe extern "C" fn(A, ...) -> Ret
[src]
impl<Ret, A, B> PartialEq<extern "C" fn(A, B, ...) -> Ret> for extern "C" fn(A, B, ...) -> Ret
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
[src]
pub fn eq(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
) -> bool
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
) -> bool
impl<Ret, A, B, C, D, E, F> PartialEq<fn(A, B, C, D, E, F) -> Ret> for fn(A, B, C, D, E, F) -> Ret
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialEq<unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
[src]
impl PartialEq<i8> for i8
[src]
impl<Ret, A, B, C, D, E> PartialEq<fn(A, B, C, D, E) -> Ret> for fn(A, B, C, D, E) -> Ret
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialEq<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret> for fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
[src]
impl PartialEq<PhantomPinned> for PhantomPinned
[src]
pub fn eq(&self, other: &PhantomPinned) -> bool
[src]
impl<T> PartialEq<Wrapping<T>> for Wrapping<T> where
T: PartialEq<T>,
[src]
T: PartialEq<T>,
pub fn eq(&self, other: &Wrapping<T>) -> bool
[src]
pub fn ne(&self, other: &Wrapping<T>) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialEq<unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret
[src]
impl PartialEq<f64> for f64
[src]
impl<A, B, const N: usize> PartialEq<[B; N]> for [A; N] where
A: PartialEq<B>,
[src]
A: PartialEq<B>,
impl<Ret, A, B, C, D> PartialEq<fn(A, B, C, D) -> Ret> for fn(A, B, C, D) -> Ret
[src]
impl<T> PartialEq<NonNull<T>> for NonNull<T> where
T: ?Sized,
[src]
T: ?Sized,
impl PartialEq<()> for ()
[src]
impl PartialEq<NonZeroU64> for NonZeroU64
[src]
pub fn eq(&self, other: &NonZeroU64) -> bool
[src]
pub fn ne(&self, other: &NonZeroU64) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
[src]
impl<Ret, A, B, C, D, E> PartialEq<unsafe fn(A, B, C, D, E) -> Ret> for unsafe fn(A, B, C, D, E) -> Ret
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret
[src]
impl<Ret> PartialEq<extern "C" fn() -> Ret> for extern "C" fn() -> Ret
[src]
impl<Ret, A> PartialEq<unsafe extern "C" fn(A) -> Ret> for unsafe extern "C" fn(A) -> Ret
[src]
impl<Ret, A, B, C, D, E> PartialEq<extern "C" fn(A, B, C, D, E, ...) -> Ret> for extern "C" fn(A, B, C, D, E, ...) -> Ret
[src]
impl<Ret> PartialEq<fn() -> Ret> for fn() -> Ret
[src]
impl<T> PartialEq<*const T> for *const T where
T: ?Sized,
[src]
T: ?Sized,
impl PartialEq<NonZeroI128> for NonZeroI128
[src]
pub fn eq(&self, other: &NonZeroI128) -> bool
[src]
pub fn ne(&self, other: &NonZeroI128) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret
[src]
impl<Ret, A, B, C, D, E, F, G> PartialEq<unsafe fn(A, B, C, D, E, F, G) -> Ret> for unsafe fn(A, B, C, D, E, F, G) -> Ret
[src]
impl PartialEq<i16> for i16
[src]
impl<Ret, A, B, C, D> PartialEq<unsafe extern "C" fn(A, B, C, D, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, ...) -> Ret
[src]
impl PartialEq<NonZeroU32> for NonZeroU32
[src]
pub fn eq(&self, other: &NonZeroU32) -> bool
[src]
pub fn ne(&self, other: &NonZeroU32) -> bool
[src]
impl<A, B, C, D, E, F, G, H> PartialEq<(A, B, C, D, E, F, G, H)> for (A, B, C, D, E, F, G, H) where
C: PartialEq<C>,
F: PartialEq<F>,
E: PartialEq<E>,
G: PartialEq<G>,
H: PartialEq<H> + ?Sized,
A: PartialEq<A>,
B: PartialEq<B>,
D: PartialEq<D>,
[src]
C: PartialEq<C>,
F: PartialEq<F>,
E: PartialEq<E>,
G: PartialEq<G>,
H: PartialEq<H> + ?Sized,
A: PartialEq<A>,
B: PartialEq<B>,
D: PartialEq<D>,
pub fn eq(&self, other: &(A, B, C, D, E, F, G, H)) -> bool
[src]
pub fn ne(&self, other: &(A, B, C, D, E, F, G, H)) -> bool
[src]
impl<Ret, A> PartialEq<fn(A) -> Ret> for fn(A) -> Ret
[src]
impl<A, B, C, D, E, F, G, H, I> PartialEq<(A, B, C, D, E, F, G, H, I)> for (A, B, C, D, E, F, G, H, I) where
C: PartialEq<C>,
F: PartialEq<F>,
E: PartialEq<E>,
I: PartialEq<I> + ?Sized,
G: PartialEq<G>,
H: PartialEq<H>,
A: PartialEq<A>,
B: PartialEq<B>,
D: PartialEq<D>,
[src]
C: PartialEq<C>,
F: PartialEq<F>,
E: PartialEq<E>,
I: PartialEq<I> + ?Sized,
G: PartialEq<G>,
H: PartialEq<H>,
A: PartialEq<A>,
B: PartialEq<B>,
D: PartialEq<D>,
pub fn eq(&self, other: &(A, B, C, D, E, F, G, H, I)) -> bool
[src]
pub fn ne(&self, other: &(A, B, C, D, E, F, G, H, I)) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret
[src]
pub fn eq(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret
) -> bool
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret
) -> bool
impl<Ret, A, B, C, D, E, F, G> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret
[src]
impl<A, B> PartialEq<(A, B)> for (A, B) where
A: PartialEq<A>,
B: PartialEq<B> + ?Sized,
[src]
A: PartialEq<A>,
B: PartialEq<B> + ?Sized,
impl<A, B, C> PartialEq<(A, B, C)> for (A, B, C) where
C: PartialEq<C> + ?Sized,
A: PartialEq<A>,
B: PartialEq<B>,
[src]
C: PartialEq<C> + ?Sized,
A: PartialEq<A>,
B: PartialEq<B>,
impl<T> PartialEq<Cell<T>> for Cell<T> where
T: PartialEq<T> + Copy,
[src]
T: PartialEq<T> + Copy,
impl PartialEq<NonZeroUsize> for NonZeroUsize
[src]
pub fn eq(&self, other: &NonZeroUsize) -> bool
[src]
pub fn ne(&self, other: &NonZeroUsize) -> bool
[src]
impl<A, B, C, D> PartialEq<(A, B, C, D)> for (A, B, C, D) where
C: PartialEq<C>,
A: PartialEq<A>,
B: PartialEq<B>,
D: PartialEq<D> + ?Sized,
[src]
C: PartialEq<C>,
A: PartialEq<A>,
B: PartialEq<B>,
D: PartialEq<D> + ?Sized,
pub fn eq(&self, other: &(A, B, C, D)) -> bool
[src]
pub fn ne(&self, other: &(A, B, C, D)) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret
[src]
impl<A, B, const N: usize> PartialEq<[B]> for [A; N] where
A: PartialEq<B>,
[src]
A: PartialEq<B>,
impl PartialEq<NonZeroU128> for NonZeroU128
[src]
pub fn eq(&self, other: &NonZeroU128) -> bool
[src]
pub fn ne(&self, other: &NonZeroU128) -> bool
[src]
impl PartialEq<IntErrorKind> for IntErrorKind
[src]
pub fn eq(&self, other: &IntErrorKind) -> bool
[src]
impl PartialEq<DecodeUtf16Error> for DecodeUtf16Error
[src]
pub fn eq(&self, other: &DecodeUtf16Error) -> bool
[src]
pub fn ne(&self, other: &DecodeUtf16Error) -> bool
[src]
impl<'_, A, B, const N: usize> PartialEq<[A; N]> for &'_ mut [B] where
B: PartialEq<A>,
[src]
B: PartialEq<A>,
impl<Ret, A> PartialEq<extern "C" fn(A, ...) -> Ret> for extern "C" fn(A, ...) -> Ret
[src]
impl<Ret, A, B, C, D, E, F, G, H> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H) -> Ret
[src]
impl<Ret, A, B, C, D, E, F> PartialEq<extern "C" fn(A, B, C, D, E, F, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, ...) -> Ret
[src]
impl PartialEq<NonZeroIsize> for NonZeroIsize
[src]
pub fn eq(&self, other: &NonZeroIsize) -> bool
[src]
pub fn ne(&self, other: &NonZeroIsize) -> bool
[src]
impl<'a> PartialEq<Utf8LossyChunk<'a>> for Utf8LossyChunk<'a>
[src]
pub fn eq(&self, other: &Utf8LossyChunk<'a>) -> bool
[src]
pub fn ne(&self, other: &Utf8LossyChunk<'a>) -> bool
[src]
impl<Ret, A, B, C, D, E> PartialEq<unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret
[src]
impl PartialEq<i32> for i32
[src]
impl<'_, '_, A, B> PartialEq<&'_ B> for &'_ mut A where
A: PartialEq<B> + ?Sized,
B: ?Sized,
[src]
A: PartialEq<B> + ?Sized,
B: ?Sized,
impl<A, B, C, D, E, F> PartialEq<(A, B, C, D, E, F)> for (A, B, C, D, E, F) where
C: PartialEq<C>,
F: PartialEq<F> + ?Sized,
E: PartialEq<E>,
A: PartialEq<A>,
B: PartialEq<B>,
D: PartialEq<D>,
[src]
C: PartialEq<C>,
F: PartialEq<F> + ?Sized,
E: PartialEq<E>,
A: PartialEq<A>,
B: PartialEq<B>,
D: PartialEq<D>,
pub fn eq(&self, other: &(A, B, C, D, E, F)) -> bool
[src]
pub fn ne(&self, other: &(A, B, C, D, E, F)) -> bool
[src]
impl<Ret, A, B, C> PartialEq<unsafe extern "C" fn(A, B, C) -> Ret> for unsafe extern "C" fn(A, B, C) -> Ret
[src]
impl<'_, A, B, const N: usize> PartialEq<[A; N]> for &'_ [B] where
B: PartialEq<A>,
[src]
B: PartialEq<A>,
impl<Ret, A, B, C, D> PartialEq<extern "C" fn(A, B, C, D, ...) -> Ret> for extern "C" fn(A, B, C, D, ...) -> Ret
[src]
impl<A> PartialEq<(A,)> for (A,) where
A: PartialEq<A> + ?Sized,
[src]
A: PartialEq<A> + ?Sized,
impl PartialEq<i64> for i64
[src]
impl PartialEq<ParseIntError> for ParseIntError
[src]
pub fn eq(&self, other: &ParseIntError) -> bool
[src]
pub fn ne(&self, other: &ParseIntError) -> bool
[src]
impl PartialEq<u128> for u128
[src]
impl<Ret, A, B> PartialEq<unsafe fn(A, B) -> Ret> for unsafe fn(A, B) -> Ret
[src]
impl<P, Q> PartialEq<Pin<Q>> for Pin<P> where
P: Deref,
Q: Deref,
<P as Deref>::Target: PartialEq<<Q as Deref>::Target>,
[src]
P: Deref,
Q: Deref,
<P as Deref>::Target: PartialEq<<Q as Deref>::Target>,
impl<Ret, A, B> PartialEq<unsafe extern "C" fn(A, B, ...) -> Ret> for unsafe extern "C" fn(A, B, ...) -> Ret
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret
[src]
impl<Ret> PartialEq<unsafe fn() -> Ret> for unsafe fn() -> Ret
[src]
impl<Ret, A, B, C, D, E, F, G> PartialEq<extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret
[src]
impl<Ret, A, B, C, D, E, F, G, H> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret
[src]
impl<'_, '_, A, B> PartialEq<&'_ B> for &'_ A where
A: PartialEq<B> + ?Sized,
B: ?Sized,
[src]
A: PartialEq<B> + ?Sized,
B: ?Sized,
impl PartialEq<Duration> for Duration
[src]
impl PartialEq<u16> for u16
[src]
impl<Ret, A, B, C, D, E, F, G, H, I> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret
[src]
impl PartialEq<ParseFloatError> for ParseFloatError
[src]
pub fn eq(&self, other: &ParseFloatError) -> bool
[src]
pub fn ne(&self, other: &ParseFloatError) -> bool
[src]
impl PartialEq<u64> for u64
[src]
impl<T> PartialEq<PhantomData<T>> for PhantomData<T> where
T: ?Sized,
[src]
T: ?Sized,
pub fn eq(&self, _other: &PhantomData<T>) -> bool
[src]
impl<A, B, C, D, E, F, G, H, I, J> PartialEq<(A, B, C, D, E, F, G, H, I, J)> for (A, B, C, D, E, F, G, H, I, J) where
C: PartialEq<C>,
F: PartialEq<F>,
E: PartialEq<E>,
I: PartialEq<I>,
G: PartialEq<G>,
H: PartialEq<H>,
A: PartialEq<A>,
B: PartialEq<B>,
D: PartialEq<D>,
J: PartialEq<J> + ?Sized,
[src]
C: PartialEq<C>,
F: PartialEq<F>,
E: PartialEq<E>,
I: PartialEq<I>,
G: PartialEq<G>,
H: PartialEq<H>,
A: PartialEq<A>,
B: PartialEq<B>,
D: PartialEq<D>,
J: PartialEq<J> + ?Sized,
pub fn eq(&self, other: &(A, B, C, D, E, F, G, H, I, J)) -> bool
[src]
pub fn ne(&self, other: &(A, B, C, D, E, F, G, H, I, J)) -> bool
[src]
impl<Ret, A, B, C, D, E> PartialEq<unsafe extern "C" fn(A, B, C, D, E) -> Ret> for unsafe extern "C" fn(A, B, C, D, E) -> Ret
[src]
impl PartialEq<isize> for isize
[src]
impl<T> PartialEq<RefCell<T>> for RefCell<T> where
T: PartialEq<T> + ?Sized,
[src]
T: PartialEq<T> + ?Sized,
pub fn eq(&self, other: &RefCell<T>) -> bool
[src]
Panics
Panics if the value in either RefCell
is currently borrowed.
impl<T> PartialEq<Poll<T>> for Poll<T> where
T: PartialEq<T>,
[src]
T: PartialEq<T>,
impl PartialEq<NonZeroI8> for NonZeroI8
[src]
impl PartialEq<TryFromIntError> for TryFromIntError
[src]
pub fn eq(&self, other: &TryFromIntError) -> bool
[src]
pub fn ne(&self, other: &TryFromIntError) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialEq<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
[src]
impl<Ret, A, B, C, D, E, F, G, H> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret
[src]
impl<Ret, A, B, C, D, E, F, G, H, I> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret
[src]
impl PartialEq<usize> for usize
[src]
impl<A, B, const N: usize> PartialEq<[A; N]> for [B] where
B: PartialEq<A>,
[src]
B: PartialEq<A>,
impl<Ret, A, B, C, D, E, F, G, H> PartialEq<fn(A, B, C, D, E, F, G, H) -> Ret> for fn(A, B, C, D, E, F, G, H) -> Ret
[src]
impl<Ret, A, B, C, D, E, F, G, H> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret
[src]
impl<A, B> PartialEq<[B]> for [A] where
A: PartialEq<B>,
[src]
A: PartialEq<B>,
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret
[src]
impl<'_, A, B, const N: usize> PartialEq<&'_ mut [B]> for [A; N] where
A: PartialEq<B>,
[src]
A: PartialEq<B>,
impl PartialEq<ParseCharError> for ParseCharError
[src]
pub fn eq(&self, other: &ParseCharError) -> bool
[src]
pub fn ne(&self, other: &ParseCharError) -> bool
[src]
impl PartialEq<i128> for i128
[src]
impl<A, B, C, D, E, F, G> PartialEq<(A, B, C, D, E, F, G)> for (A, B, C, D, E, F, G) where
C: PartialEq<C>,
F: PartialEq<F>,
E: PartialEq<E>,
G: PartialEq<G> + ?Sized,
A: PartialEq<A>,
B: PartialEq<B>,
D: PartialEq<D>,
[src]
C: PartialEq<C>,
F: PartialEq<F>,
E: PartialEq<E>,
G: PartialEq<G> + ?Sized,
A: PartialEq<A>,
B: PartialEq<B>,
D: PartialEq<D>,
pub fn eq(&self, other: &(A, B, C, D, E, F, G)) -> bool
[src]
pub fn ne(&self, other: &(A, B, C, D, E, F, G)) -> bool
[src]
impl PartialEq<u8> for u8
[src]
impl PartialEq<f32> for f32
[src]
impl<Ret, A, B, C, D, E, F> PartialEq<extern "C" fn(A, B, C, D, E, F) -> Ret> for extern "C" fn(A, B, C, D, E, F) -> Ret
[src]
impl PartialEq<RawWakerVTable> for RawWakerVTable
[src]
pub fn eq(&self, other: &RawWakerVTable) -> bool
[src]
pub fn ne(&self, other: &RawWakerVTable) -> bool
[src]
impl PartialEq<TypeId> for TypeId
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialEq<fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
[src]
impl PartialEq<NonZeroU8> for NonZeroU8
[src]
impl PartialEq<RawWaker> for RawWaker
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret
[src]
pub fn eq(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret
) -> bool
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret
) -> bool
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
[src]
pub fn eq(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
) -> bool
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
) -> bool
impl PartialEq<NonZeroI64> for NonZeroI64
[src]
pub fn eq(&self, other: &NonZeroI64) -> bool
[src]
pub fn ne(&self, other: &NonZeroI64) -> bool
[src]
impl<Ret, A, B, C, D, E> PartialEq<extern "C" fn(A, B, C, D, E) -> Ret> for extern "C" fn(A, B, C, D, E) -> Ret
[src]
impl PartialEq<u32> for u32
[src]
impl<T> PartialEq<OnceCell<T>> for OnceCell<T> where
T: PartialEq<T>,
[src]
T: PartialEq<T>,
impl<Ret, A, B> PartialEq<extern "C" fn(A, B) -> Ret> for extern "C" fn(A, B) -> Ret
[src]
impl PartialEq<NonZeroU16> for NonZeroU16
[src]
pub fn eq(&self, other: &NonZeroU16) -> bool
[src]
pub fn ne(&self, other: &NonZeroU16) -> bool
[src]
impl<'_, A, B, const N: usize> PartialEq<&'_ [B]> for [A; N] where
A: PartialEq<B>,
[src]
A: PartialEq<B>,
impl<Ret, A, B, C> PartialEq<unsafe fn(A, B, C) -> Ret> for unsafe fn(A, B, C) -> Ret
[src]
impl PartialEq<CpuidResult> for CpuidResult
[src]
pub fn eq(&self, other: &CpuidResult) -> bool
[src]
pub fn ne(&self, other: &CpuidResult) -> bool
[src]
impl<'a> PartialEq<Location<'a>> for Location<'a>
[src]
pub fn eq(&self, other: &Location<'a>) -> bool
[src]
pub fn ne(&self, other: &Location<'a>) -> bool
[src]
impl<Ret, A, B, C> PartialEq<unsafe extern "C" fn(A, B, C, ...) -> Ret> for unsafe extern "C" fn(A, B, C, ...) -> Ret
[src]
impl<Ret, A, B, C, D, E, F, G, H> PartialEq<unsafe fn(A, B, C, D, E, F, G, H) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H) -> Ret
[src]
impl<Ret, A, B, C> PartialEq<extern "C" fn(A, B, C, ...) -> Ret> for extern "C" fn(A, B, C, ...) -> Ret
[src]
impl PartialEq<NonZeroI16> for NonZeroI16
[src]
pub fn eq(&self, other: &NonZeroI16) -> bool
[src]
pub fn ne(&self, other: &NonZeroI16) -> bool
[src]
impl<Ret, A, B> PartialEq<unsafe extern "C" fn(A, B) -> Ret> for unsafe extern "C" fn(A, B) -> Ret
[src]
impl<Ret> PartialEq<unsafe extern "C" fn() -> Ret> for unsafe extern "C" fn() -> Ret
[src]
impl<Ret, A, B, C, D, E, F, G> PartialEq<extern "C" fn(A, B, C, D, E, F, G) -> Ret> for extern "C" fn(A, B, C, D, E, F, G) -> Ret
[src]
impl PartialEq<bool> for bool
[src]
impl PartialEq<!> for !
[src]
impl PartialEq<FpCategory> for FpCategory
[src]
pub fn eq(&self, other: &FpCategory) -> bool
[src]
impl<A, B, C, D, E> PartialEq<(A, B, C, D, E)> for (A, B, C, D, E) where
C: PartialEq<C>,
E: PartialEq<E> + ?Sized,
A: PartialEq<A>,
B: PartialEq<B>,
D: PartialEq<D>,
[src]
C: PartialEq<C>,
E: PartialEq<E> + ?Sized,
A: PartialEq<A>,
B: PartialEq<B>,
D: PartialEq<D>,
pub fn eq(&self, other: &(A, B, C, D, E)) -> bool
[src]
pub fn ne(&self, other: &(A, B, C, D, E)) -> bool
[src]
impl<Ret, A, B, C> PartialEq<extern "C" fn(A, B, C) -> Ret> for extern "C" fn(A, B, C) -> Ret
[src]
impl<Ret, A, B> PartialEq<fn(A, B) -> Ret> for fn(A, B) -> Ret
[src]
impl<Ret, A, B, C> PartialEq<fn(A, B, C) -> Ret> for fn(A, B, C) -> Ret
[src]
impl<'a, 'b> PartialEq<Cow<'a, str>> for str
[src]
pub fn eq(&self, other: &Cow<'a, str>) -> bool
[src]
pub fn ne(&self, other: &Cow<'a, str>) -> bool
[src]
impl<'_, T, U, A> PartialEq<Vec<U, A>> for &'_ mut [T] where
T: PartialEq<U>,
A: Allocator,
[src]
T: PartialEq<U>,
A: Allocator,
impl<'a, 'b> PartialEq<String> for str
[src]
impl<T> PartialEq<Arc<T>> for Arc<T> where
T: PartialEq<T> + ?Sized,
[src]
T: PartialEq<T> + ?Sized,
pub fn eq(&self, other: &Arc<T>) -> bool
[src]
Equality for two Arc
s.
Two Arc
s are equal if their inner values are equal, even if they are
stored in different allocation.
If T
also implements Eq
(implying reflexivity of equality),
two Arc
s that point to the same allocation are always equal.
Examples
use std::sync::Arc; let five = Arc::new(5); assert!(five == Arc::new(5));
pub fn ne(&self, other: &Arc<T>) -> bool
[src]
Inequality for two Arc
s.
Two Arc
s are unequal if their inner values are unequal.
If T
also implements Eq
(implying reflexivity of equality),
two Arc
s that point to the same value are never unequal.
Examples
use std::sync::Arc; let five = Arc::new(5); assert!(five != Arc::new(6));
impl<'a, 'b> PartialEq<String> for &'a str
[src]
impl<T> PartialEq<Rc<T>> for Rc<T> where
T: PartialEq<T> + ?Sized,
[src]
T: PartialEq<T> + ?Sized,
pub fn eq(&self, other: &Rc<T>) -> bool
[src]
Equality for two Rc
s.
Two Rc
s are equal if their inner values are equal, even if they are
stored in different allocation.
If T
also implements Eq
(implying reflexivity of equality),
two Rc
s that point to the same allocation are
always equal.
Examples
use std::rc::Rc; let five = Rc::new(5); assert!(five == Rc::new(5));
pub fn ne(&self, other: &Rc<T>) -> bool
[src]
Inequality for two Rc
s.
Two Rc
s are unequal if their inner values are unequal.
If T
also implements Eq
(implying reflexivity of equality),
two Rc
s that point to the same allocation are
never unequal.
Examples
use std::rc::Rc; let five = Rc::new(5); assert!(five != Rc::new(6));
impl<'a, 'b> PartialEq<Cow<'a, str>> for &'b str
[src]
pub fn eq(&self, other: &Cow<'a, str>) -> bool
[src]
pub fn ne(&self, other: &Cow<'a, str>) -> bool
[src]
impl<T, U, A> PartialEq<Vec<U, A>> for [T] where
T: PartialEq<U>,
A: Allocator,
[src]
T: PartialEq<U>,
A: Allocator,
impl<'_, T, U, A> PartialEq<Vec<U, A>> for &'_ [T] where
T: PartialEq<U>,
A: Allocator,
[src]
T: PartialEq<U>,
A: Allocator,
impl PartialEq<_Unwind_Action> for _Unwind_Action
impl PartialEq<_Unwind_Reason_Code> for _Unwind_Reason_Code
impl PartialEq<Lsb0> for Lsb0
[src]
impl<'_, O1, O2, T1, T2> PartialEq<BitBox<O2, T2>> for &'_ BitSlice<O1, T1> where
O2: BitOrder,
O1: BitOrder,
T1: BitStore,
T2: BitStore,
[src]
O2: BitOrder,
O1: BitOrder,
T1: BitStore,
T2: BitStore,
impl<O1, O2, T1, T2> PartialEq<BitVec<O2, T2>> for BitSlice<O1, T1> where
O2: BitOrder,
O1: BitOrder,
T1: BitStore,
T2: BitStore,
[src]
O2: BitOrder,
O1: BitOrder,
T1: BitStore,
T2: BitStore,
impl PartialEq<Msb0> for Msb0
[src]
impl<O, V, T> PartialEq<BitArray<O, V>> for BitSlice<O, T> where
O: BitOrder,
T: BitStore,
V: BitView,
[src]
O: BitOrder,
T: BitStore,
V: BitView,
impl<'_, O1, O2, T1, T2> PartialEq<BitSlice<O2, T2>> for &'_ BitSlice<O1, T1> where
O2: BitOrder,
O1: BitOrder,
T1: BitStore,
T2: BitStore,
[src]
O2: BitOrder,
O1: BitOrder,
T1: BitStore,
T2: BitStore,
impl<R> PartialEq<BitTail<R>> for BitTail<R> where
R: PartialEq<R> + BitRegister,
[src]
R: PartialEq<R> + BitRegister,
impl<R> PartialEq<BitMask<R>> for BitMask<R> where
R: PartialEq<R> + BitRegister,
[src]
R: PartialEq<R> + BitRegister,
impl<'_, O1, O2, T1, T2> PartialEq<&'_ BitSlice<O2, T2>> for BitSlice<O1, T1> where
O2: BitOrder,
O1: BitOrder,
T1: BitStore,
T2: BitStore,
[src]
O2: BitOrder,
O1: BitOrder,
T1: BitStore,
T2: BitStore,
impl<'_, O1, O2, T1, T2> PartialEq<&'_ mut BitSlice<O2, T2>> for BitSlice<O1, T1> where
O2: BitOrder,
O1: BitOrder,
T1: BitStore,
T2: BitStore,
[src]
O2: BitOrder,
O1: BitOrder,
T1: BitStore,
T2: BitStore,
impl<O, T, Rhs> PartialEq<Rhs> for BitVec<O, T> where
O: BitOrder,
T: BitStore,
Rhs: PartialEq<BitSlice<O, T>> + ?Sized,
[src]
O: BitOrder,
T: BitStore,
Rhs: PartialEq<BitSlice<O, T>> + ?Sized,
impl<O1, O2, T1, T2> PartialEq<BitSlice<O2, T2>> for BitSlice<O1, T1> where
O2: BitOrder,
O1: BitOrder,
T1: BitStore,
T2: BitStore,
[src]
O2: BitOrder,
O1: BitOrder,
T1: BitStore,
T2: BitStore,
Tests if two BitSlice
s are semantically — not bitwise — equal.
It is valid to compare slices of different ordering or memory types.
The equality condition requires that they have the same length and that at each index, the two slices have the same bit value.
impl<O, V, Rhs> PartialEq<Rhs> for BitArray<O, V> where
O: BitOrder,
Rhs: ?Sized,
V: BitView,
BitSlice<O, <V as BitView>::Store>: PartialEq<Rhs>,
[src]
O: BitOrder,
Rhs: ?Sized,
V: BitView,
BitSlice<O, <V as BitView>::Store>: PartialEq<Rhs>,
impl<O, T, Rhs> PartialEq<Rhs> for BitBox<O, T> where
O: BitOrder,
T: BitStore,
Rhs: PartialEq<BitSlice<O, T>> + ?Sized,
[src]
O: BitOrder,
T: BitStore,
Rhs: PartialEq<BitSlice<O, T>> + ?Sized,
impl<R> PartialEq<BitIdx<R>> for BitIdx<R> where
R: PartialEq<R> + BitRegister,
[src]
R: PartialEq<R> + BitRegister,
impl<'_, O1, O2, T1, T2> PartialEq<BitVec<O2, T2>> for &'_ mut BitSlice<O1, T1> where
O2: BitOrder,
O1: BitOrder,
T1: BitStore,
T2: BitStore,
[src]
O2: BitOrder,
O1: BitOrder,
T1: BitStore,
T2: BitStore,
impl<R> PartialEq<BitSel<R>> for BitSel<R> where
R: PartialEq<R> + BitRegister,
[src]
R: PartialEq<R> + BitRegister,
impl<'_, O1, O2, T1, T2> PartialEq<BitSlice<O2, T2>> for &'_ mut BitSlice<O1, T1> where
O2: BitOrder,
O1: BitOrder,
T1: BitStore,
T2: BitStore,
[src]
O2: BitOrder,
O1: BitOrder,
T1: BitStore,
T2: BitStore,
impl<'_, O1, O2, T1, T2> PartialEq<BitBox<O2, T2>> for &'_ mut BitSlice<O1, T1> where
O2: BitOrder,
O1: BitOrder,
T1: BitStore,
T2: BitStore,
[src]
O2: BitOrder,
O1: BitOrder,
T1: BitStore,
T2: BitStore,
impl<R> PartialEq<BitPos<R>> for BitPos<R> where
R: PartialEq<R> + BitRegister,
[src]
R: PartialEq<R> + BitRegister,
impl<'_, O1, O2, T1, T2> PartialEq<BitVec<O2, T2>> for &'_ BitSlice<O1, T1> where
O2: BitOrder,
O1: BitOrder,
T1: BitStore,
T2: BitStore,
[src]
O2: BitOrder,
O1: BitOrder,
T1: BitStore,
T2: BitStore,
impl<O1, O2, T1, T2> PartialEq<BitBox<O2, T2>> for BitSlice<O1, T1> where
O2: BitOrder,
O1: BitOrder,
T1: BitStore,
T2: BitStore,
[src]
O2: BitOrder,
O1: BitOrder,
T1: BitStore,
T2: BitStore,
impl PartialEq<Error> for Error
[src]
impl PartialEq<ErrorCode> for ErrorCode
[src]
impl<T> PartialEq<CapacityError<T>> for CapacityError<T> where
T: PartialEq<T>,
[src]
T: PartialEq<T>,
pub fn eq(&self, other: &CapacityError<T>) -> bool
[src]
pub fn ne(&self, other: &CapacityError<T>) -> bool
[src]
impl<A> PartialEq<ArrayVec<A>> for ArrayVec<A> where
A: Array,
<A as Array>::Item: PartialEq<<A as Array>::Item>,
[src]
A: Array,
<A as Array>::Item: PartialEq<<A as Array>::Item>,
impl<A> PartialEq<ArrayString<A>> for ArrayString<A> where
A: Array<Item = u8> + Copy,
[src]
A: Array<Item = u8> + Copy,
pub fn eq(&self, rhs: &ArrayString<A>) -> bool
[src]
impl<A> PartialEq<str> for ArrayString<A> where
A: Array<Item = u8> + Copy,
[src]
A: Array<Item = u8> + Copy,
impl<A> PartialEq<[<A as Array>::Item]> for ArrayVec<A> where
A: Array,
<A as Array>::Item: PartialEq<<A as Array>::Item>,
[src]
A: Array,
<A as Array>::Item: PartialEq<<A as Array>::Item>,
impl<A> PartialEq<ArrayString<A>> for str where
A: Array<Item = u8> + Copy,
[src]
A: Array<Item = u8> + Copy,
pub fn eq(&self, rhs: &ArrayString<A>) -> bool
[src]
impl PartialEq<Error> for Error
[src]
impl<'t> PartialEq<Match<'t>> for Match<'t>
[src]
impl<'t> PartialEq<Match<'t>> for Match<'t>
[src]
impl PartialEq<Char> for char
[src]
impl PartialEq<Match> for Match
impl PartialEq<MatchKind> for MatchKind
impl PartialEq<MatchKind> for MatchKind
impl PartialEq<ClassSet> for ClassSet
impl PartialEq<Repetition> for Repetition
impl PartialEq<AssertionKind> for AssertionKind
impl PartialEq<HexLiteralKind> for HexLiteralKind
impl PartialEq<ClassAsciiKind> for ClassAsciiKind
impl PartialEq<LiteralKind> for LiteralKind
impl PartialEq<RepetitionKind> for RepetitionKind
impl PartialEq<ClassSetItem> for ClassSetItem
impl PartialEq<FlagsItem> for FlagsItem
impl PartialEq<RepetitionRange> for RepetitionRange
impl PartialEq<ClassBytes> for ClassBytes
impl PartialEq<SetFlags> for SetFlags
impl PartialEq<SpecialLiteralKind> for SpecialLiteralKind
impl PartialEq<GroupKind> for GroupKind
impl PartialEq<ClassBracketed> for ClassBracketed
impl PartialEq<Class> for Class
impl PartialEq<ClassAscii> for ClassAscii
impl PartialEq<ClassUnicodeRange> for ClassUnicodeRange
pub fn eq(&self, other: &ClassUnicodeRange) -> bool
pub fn ne(&self, other: &ClassUnicodeRange) -> bool
impl PartialEq<FlagsItemKind> for FlagsItemKind
impl PartialEq<Flag> for Flag
impl PartialEq<Literals> for Literals
impl PartialEq<ClassPerl> for ClassPerl
impl PartialEq<RepetitionRange> for RepetitionRange
impl PartialEq<Literal> for Literal
impl PartialEq<Error> for Error
impl PartialEq<Comment> for Comment
impl PartialEq<Assertion> for Assertion
impl PartialEq<Alternation> for Alternation
impl PartialEq<Literal> for Literal
impl PartialEq<Utf8Sequence> for Utf8Sequence
impl PartialEq<Literal> for Literal
impl PartialEq<ClassUnicode> for ClassUnicode
impl PartialEq<ClassUnicodeKind> for ClassUnicodeKind
pub fn eq(&self, other: &ClassUnicodeKind) -> bool
pub fn ne(&self, other: &ClassUnicodeKind) -> bool
impl PartialEq<ClassSetUnion> for ClassSetUnion
impl PartialEq<ErrorKind> for ErrorKind
impl PartialEq<ErrorKind> for ErrorKind
impl PartialEq<ClassSetRange> for ClassSetRange
impl PartialEq<Group> for Group
impl PartialEq<WithComments> for WithComments
impl PartialEq<ClassBytesRange> for ClassBytesRange
impl PartialEq<RepetitionOp> for RepetitionOp
impl PartialEq<ClassPerlKind> for ClassPerlKind
impl PartialEq<Span> for Span
impl PartialEq<WordBoundary> for WordBoundary
impl PartialEq<Repetition> for Repetition
impl PartialEq<ClassUnicodeOpKind> for ClassUnicodeOpKind
impl PartialEq<Anchor> for Anchor
impl PartialEq<Group> for Group
impl PartialEq<CaptureName> for CaptureName
impl PartialEq<ClassSetBinaryOpKind> for ClassSetBinaryOpKind
impl PartialEq<Class> for Class
impl PartialEq<Error> for Error
impl PartialEq<Position> for Position
impl PartialEq<GroupKind> for GroupKind
impl PartialEq<Ast> for Ast
impl PartialEq<ClassSetBinaryOp> for ClassSetBinaryOp
pub fn eq(&self, other: &ClassSetBinaryOp) -> bool
pub fn ne(&self, other: &ClassSetBinaryOp) -> bool
impl PartialEq<Flags> for Flags
impl PartialEq<ClassUnicode> for ClassUnicode
impl PartialEq<RepetitionKind> for RepetitionKind
impl PartialEq<Concat> for Concat
impl PartialEq<Utf8Range> for Utf8Range
impl PartialEq<Hir> for Hir
impl PartialEq<Error> for Error
impl PartialEq<HirKind> for HirKind
impl<T> PartialEq<OnceCell<T>> for OnceCell<T> where
T: PartialEq<T>,
T: PartialEq<T>,
impl<T> PartialEq<OnceCell<T>> for OnceCell<T> where
T: PartialEq<T>,
Loading content...T: PartialEq<T>,
Implementors
impl PartialEq<CompareResult> for CompareResult
[src]
fn eq(&self, other: &CompareResult) -> bool
[src]
impl PartialEq<Needed> for Needed
[src]
impl PartialEq<ErrorKind> for nom::error::ErrorKind
[src]
impl PartialEq<VerboseErrorKind> for VerboseErrorKind
[src]
fn eq(&self, other: &VerboseErrorKind) -> bool
[src]
fn ne(&self, other: &VerboseErrorKind) -> bool
[src]
impl PartialEq<Ordering> for nom::lib::std::cmp::Ordering
[src]
impl PartialEq<TryReserveError> for TryReserveError
[src]
pub fn eq(&self, other: &TryReserveError) -> bool
[src]
pub fn ne(&self, other: &TryReserveError) -> bool
[src]
impl PartialEq<Infallible> for Infallible
1.34.0[src]
pub fn eq(&self, &Infallible) -> bool
[src]
impl PartialEq<SearchStep> for SearchStep
[src]
pub fn eq(&self, other: &SearchStep) -> bool
[src]
pub fn ne(&self, other: &SearchStep) -> bool
[src]
impl PartialEq<Endianness> for Endianness
[src]
fn eq(&self, other: &Endianness) -> bool
[src]
impl PartialEq<AllocError> for AllocError
[src]
pub fn eq(&self, other: &AllocError) -> bool
[src]
impl PartialEq<Layout> for Layout
1.28.0[src]
impl PartialEq<LayoutError> for LayoutError
1.50.0[src]
pub fn eq(&self, other: &LayoutError) -> bool
[src]
pub fn ne(&self, other: &LayoutError) -> bool
[src]
impl PartialEq<Error> for nom::lib::std::fmt::Error
[src]
impl PartialEq<RangeFull> for RangeFull
[src]
impl PartialEq<NoneError> for NoneError
[src]
impl PartialEq<ParseBoolError> for ParseBoolError
[src]
pub fn eq(&self, other: &ParseBoolError) -> bool
[src]
pub fn ne(&self, other: &ParseBoolError) -> bool
[src]
impl PartialEq<Utf8Error> for Utf8Error
[src]
impl PartialEq<FromUtf8Error> for FromUtf8Error
[src]
pub fn eq(&self, other: &FromUtf8Error) -> bool
[src]
pub fn ne(&self, other: &FromUtf8Error) -> bool
[src]
impl PartialEq<String> for String
[src]
impl<'_, '_, T, U> PartialEq<&'_ [U]> for Cow<'_, [T]> where
T: PartialEq<U> + Clone,
[src]
T: PartialEq<U> + Clone,
impl<'_, '_, T, U> PartialEq<&'_ mut [U]> for Cow<'_, [T]> where
T: PartialEq<U> + Clone,
[src]
T: PartialEq<U> + Clone,
impl<'_, A, B> PartialEq<&'_ [B]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
A: PartialEq<B>,
impl<'_, A, B> PartialEq<&'_ mut [B]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
A: PartialEq<B>,
impl<'_, A, B, const N: usize> PartialEq<&'_ [B; N]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
A: PartialEq<B>,
impl<'_, A, B, const N: usize> PartialEq<&'_ mut [B; N]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
A: PartialEq<B>,
impl<'_, T, U, A> PartialEq<&'_ [U]> for Vec<T, A> where
T: PartialEq<U>,
A: Allocator,
[src]
T: PartialEq<U>,
A: Allocator,
impl<'_, T, U, A> PartialEq<&'_ mut [U]> for Vec<T, A> where
T: PartialEq<U>,
A: Allocator,
[src]
T: PartialEq<U>,
A: Allocator,
impl<'_, T, U, A> PartialEq<Vec<U, A>> for Cow<'_, [T]> where
T: PartialEq<U> + Clone,
A: Allocator,
[src]
T: PartialEq<U> + Clone,
A: Allocator,
impl<'_, T, U, A, const N: usize> PartialEq<&'_ [U; N]> for Vec<T, A> where
T: PartialEq<U>,
A: Allocator,
[src]
T: PartialEq<U>,
A: Allocator,
impl<'a, 'b> PartialEq<&'a str> for String
[src]
impl<'a, 'b> PartialEq<&'a Path> for Cow<'b, OsStr>
1.8.0[src]
impl<'a, 'b> PartialEq<&'b str> for Cow<'a, str>
[src]
impl<'a, 'b> PartialEq<&'b OsStr> for Cow<'a, OsStr>
1.8.0[src]
impl<'a, 'b> PartialEq<&'b OsStr> for Cow<'a, Path>
1.8.0[src]
impl<'a, 'b> PartialEq<&'b Path> for Cow<'a, Path>
1.6.0[src]
impl<'a, 'b> PartialEq<Cow<'a, str>> for String
[src]
pub fn eq(&self, other: &Cow<'a, str>) -> bool
[src]
pub fn ne(&self, other: &Cow<'a, str>) -> bool
[src]
impl<'a, 'b> PartialEq<str> for Cow<'a, str>
[src]
impl<'a, 'b> PartialEq<str> for String
[src]
impl<'a, 'b> PartialEq<String> for Cow<'a, str>
[src]
impl<'a, 'b> PartialEq<OsStr> for Cow<'a, OsStr>
1.8.0[src]
impl<'a, 'b> PartialEq<OsStr> for Cow<'a, Path>
1.8.0[src]
impl<'a, 'b> PartialEq<OsString> for Cow<'a, OsStr>
1.8.0[src]
impl<'a, 'b> PartialEq<OsString> for Cow<'a, Path>
1.8.0[src]
impl<'a, 'b> PartialEq<Path> for Cow<'a, OsStr>
1.8.0[src]
impl<'a, 'b> PartialEq<Path> for Cow<'a, Path>
1.6.0[src]
impl<'a, 'b> PartialEq<PathBuf> for Cow<'a, OsStr>
1.8.0[src]
impl<'a, 'b> PartialEq<PathBuf> for Cow<'a, Path>
1.6.0[src]
impl<'a, 'b, B, C> PartialEq<Cow<'b, C>> for Cow<'a, B> where
C: ToOwned + ?Sized,
B: PartialEq<C> + ToOwned + ?Sized,
[src]
C: ToOwned + ?Sized,
B: PartialEq<C> + ToOwned + ?Sized,
impl<A> PartialEq<VecDeque<A>> for VecDeque<A> where
A: PartialEq<A>,
[src]
A: PartialEq<A>,
impl<A, B> PartialEq<Vec<B, Global>> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
A: PartialEq<B>,
impl<A, B, const N: usize> PartialEq<[B; N]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
A: PartialEq<B>,
impl<B, C> PartialEq<ControlFlow<B, C>> for ControlFlow<B, C> where
C: PartialEq<C>,
B: PartialEq<B>,
[src]
C: PartialEq<C>,
B: PartialEq<B>,
pub fn eq(&self, other: &ControlFlow<B, C>) -> bool
[src]
pub fn ne(&self, other: &ControlFlow<B, C>) -> bool
[src]
impl<E: PartialEq> PartialEq<Err<E>> for Err<E>
[src]
impl<H> PartialEq<BuildHasherDefault<H>> for BuildHasherDefault<H>
1.29.0[src]
pub fn eq(&self, _other: &BuildHasherDefault<H>) -> bool
[src]
impl<I: PartialEq> PartialEq<Error<I>> for nom::error::Error<I>
[src]
impl<I: PartialEq> PartialEq<VerboseError<I>> for VerboseError<I>
[src]
fn eq(&self, other: &VerboseError<I>) -> bool
[src]
fn ne(&self, other: &VerboseError<I>) -> bool
[src]
impl<Idx> PartialEq<Range<Idx>> for Range<Idx> where
Idx: PartialEq<Idx>,
[src]
Idx: PartialEq<Idx>,
impl<Idx> PartialEq<RangeFrom<Idx>> for RangeFrom<Idx> where
Idx: PartialEq<Idx>,
[src]
Idx: PartialEq<Idx>,
pub fn eq(&self, other: &RangeFrom<Idx>) -> bool
[src]
pub fn ne(&self, other: &RangeFrom<Idx>) -> bool
[src]
impl<Idx> PartialEq<RangeInclusive<Idx>> for RangeInclusive<Idx> where
Idx: PartialEq<Idx>,
1.26.0[src]
Idx: PartialEq<Idx>,
pub fn eq(&self, other: &RangeInclusive<Idx>) -> bool
[src]
pub fn ne(&self, other: &RangeInclusive<Idx>) -> bool
[src]
impl<Idx> PartialEq<RangeTo<Idx>> for RangeTo<Idx> where
Idx: PartialEq<Idx>,
[src]
Idx: PartialEq<Idx>,
pub fn eq(&self, other: &RangeTo<Idx>) -> bool
[src]
pub fn ne(&self, other: &RangeTo<Idx>) -> bool
[src]
impl<Idx> PartialEq<RangeToInclusive<Idx>> for RangeToInclusive<Idx> where
Idx: PartialEq<Idx>,
1.26.0[src]
Idx: PartialEq<Idx>,
pub fn eq(&self, other: &RangeToInclusive<Idx>) -> bool
[src]
pub fn ne(&self, other: &RangeToInclusive<Idx>) -> bool
[src]
impl<K, V> PartialEq<BTreeMap<K, V>> for BTreeMap<K, V> where
K: PartialEq<K>,
V: PartialEq<V>,
[src]
K: PartialEq<K>,
V: PartialEq<V>,
impl<K, V, S> PartialEq<HashMap<K, V, S>> for HashMap<K, V, S> where
K: Eq + Hash,
S: BuildHasher,
V: PartialEq<V>,
[src]
K: Eq + Hash,
S: BuildHasher,
V: PartialEq<V>,
impl<T> PartialEq<Bound<T>> for Bound<T> where
T: PartialEq<T>,
1.17.0[src]
T: PartialEq<T>,
impl<T> PartialEq<Option<T>> for Option<T> where
T: PartialEq<T>,
[src]
T: PartialEq<T>,
impl<T> PartialEq<Reverse<T>> for Reverse<T> where
T: PartialEq<T>,
1.19.0[src]
T: PartialEq<T>,
impl<T> PartialEq<BTreeSet<T>> for BTreeSet<T> where
T: PartialEq<T>,
[src]
T: PartialEq<T>,
pub fn eq(&self, other: &BTreeSet<T>) -> bool
[src]
pub fn ne(&self, other: &BTreeSet<T>) -> bool
[src]
impl<T> PartialEq<LinkedList<T>> for LinkedList<T> where
T: PartialEq<T>,
[src]
T: PartialEq<T>,
pub fn eq(&self, other: &LinkedList<T>) -> bool
[src]
pub fn ne(&self, other: &LinkedList<T>) -> bool
[src]
impl<T> PartialEq<Discriminant<T>> for Discriminant<T>
1.21.0[src]
pub fn eq(&self, rhs: &Discriminant<T>) -> bool
[src]
impl<T> PartialEq<ManuallyDrop<T>> for ManuallyDrop<T> where
T: PartialEq<T> + ?Sized,
1.20.0[src]
T: PartialEq<T> + ?Sized,
pub fn eq(&self, other: &ManuallyDrop<T>) -> bool
[src]
pub fn ne(&self, other: &ManuallyDrop<T>) -> bool
[src]
impl<T, A> PartialEq<Box<T, A>> for Box<T, A> where
T: PartialEq<T> + ?Sized,
A: Allocator,
[src]
T: PartialEq<T> + ?Sized,
A: Allocator,
impl<T, E> PartialEq<Result<T, E>> for Result<T, E> where
E: PartialEq<E>,
T: PartialEq<T>,
[src]
E: PartialEq<E>,
T: PartialEq<T>,
pub fn eq(&self, other: &Result<T, E>) -> bool
[src]
pub fn ne(&self, other: &Result<T, E>) -> bool
[src]
impl<T, S> PartialEq<HashSet<T, S>> for HashSet<T, S> where
T: Eq + Hash,
S: BuildHasher,
[src]
T: Eq + Hash,
S: BuildHasher,
impl<T, U, A> PartialEq<[U]> for Vec<T, A> where
T: PartialEq<U>,
A: Allocator,
1.48.0[src]
T: PartialEq<U>,
A: Allocator,
impl<T, U, A> PartialEq<Vec<U, A>> for Vec<T, A> where
T: PartialEq<U>,
A: Allocator,
[src]
T: PartialEq<U>,
A: Allocator,
impl<T, U, A, const N: usize> PartialEq<[U; N]> for Vec<T, A> where
T: PartialEq<U>,
A: Allocator,
[src]
T: PartialEq<U>,
A: Allocator,
impl<Y, R> PartialEq<GeneratorState<Y, R>> for GeneratorState<Y, R> where
R: PartialEq<R>,
Y: PartialEq<Y>,
[src]
R: PartialEq<R>,
Y: PartialEq<Y>,