pub trait PartialEq<Rhs = Self> where
Rhs: ?Sized, {
fn eq(&self, other: &Rhs) -> bool;
fn ne(&self, other: &Rhs) -> bool { ... }
}
Expand description
Trait for equality comparisons which are partial equivalence relations.
x.eq(y)
can also be written x == y
, and x.ne(y)
can be written x != y
.
We use the easier-to-read infix notation in the remainder of this documentation.
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
.
Implementations must ensure that eq
and ne
are consistent with each other:
a != b
if and only if!(a == b)
(ensured by the default implementation).
If PartialOrd
or Ord
are also implemented for Self
and Rhs
, their methods must also
be consistent with PartialEq
(see the documentation of those traits for the exact
requirements). It’s easy to accidentally make them disagree by deriving some of the traits and
manually implementing others.
The equality relation ==
must satisfy the following conditions
(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
?
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
Provided Methods
Implementations on Foreign Types
sourceimpl PartialEq<BacktraceStatus> for BacktraceStatus
impl PartialEq<BacktraceStatus> for BacktraceStatus
fn eq(&self, other: &BacktraceStatus) -> bool
sourceimpl PartialEq<TryRecvError> for TryRecvError
impl PartialEq<TryRecvError> for TryRecvError
fn eq(&self, other: &TryRecvError) -> bool
sourceimpl<'a> PartialEq<PrefixComponent<'a>> for PrefixComponent<'a>
impl<'a> PartialEq<PrefixComponent<'a>> for PrefixComponent<'a>
fn eq(&self, other: &PrefixComponent<'a>) -> bool
sourceimpl PartialEq<ExitStatusError> for ExitStatusError
impl PartialEq<ExitStatusError> for ExitStatusError
fn eq(&self, other: &ExitStatusError) -> bool
fn ne(&self, other: &ExitStatusError) -> bool
1.8.0 · sourceimpl PartialEq<SystemTime> for SystemTime
impl PartialEq<SystemTime> for SystemTime
fn eq(&self, other: &SystemTime) -> bool
fn ne(&self, other: &SystemTime) -> bool
sourceimpl<'a> PartialEq<Components<'a>> for Components<'a>
impl<'a> PartialEq<Components<'a>> for Components<'a>
fn eq(&self, other: &Components<'a>) -> bool
sourceimpl<T> PartialEq<TrySendError<T>> for TrySendError<T> where
T: PartialEq<T>,
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
1.26.0 · sourceimpl PartialEq<AccessError> for AccessError
impl PartialEq<AccessError> for AccessError
fn eq(&self, other: &AccessError) -> bool
sourceimpl PartialEq<Permissions> for Permissions
impl PartialEq<Permissions> for Permissions
fn eq(&self, other: &Permissions) -> bool
fn ne(&self, other: &Permissions) -> bool
1.5.0 · sourceimpl PartialEq<WaitTimeoutResult> for WaitTimeoutResult
impl PartialEq<WaitTimeoutResult> for WaitTimeoutResult
fn eq(&self, other: &WaitTimeoutResult) -> bool
fn ne(&self, other: &WaitTimeoutResult) -> bool
sourceimpl PartialEq<BacktraceStyle> for BacktraceStyle
impl PartialEq<BacktraceStyle> for BacktraceStyle
fn eq(&self, other: &BacktraceStyle) -> bool
sourceimpl<T> PartialEq<SyncOnceCell<T>> for SyncOnceCell<T> where
T: PartialEq<T>,
impl<T> PartialEq<SyncOnceCell<T>> for SyncOnceCell<T> where
T: PartialEq<T>,
fn eq(&self, other: &SyncOnceCell<T>) -> bool
1.7.0 · sourceimpl PartialEq<StripPrefixError> for StripPrefixError
impl PartialEq<StripPrefixError> for StripPrefixError
fn eq(&self, other: &StripPrefixError) -> bool
fn ne(&self, other: &StripPrefixError) -> bool
sourceimpl PartialEq<ExitStatus> for ExitStatus
impl PartialEq<ExitStatus> for ExitStatus
fn eq(&self, other: &ExitStatus) -> bool
fn ne(&self, other: &ExitStatus) -> bool
1.12.0 · sourceimpl PartialEq<RecvTimeoutError> for RecvTimeoutError
impl PartialEq<RecvTimeoutError> for RecvTimeoutError
fn eq(&self, other: &RecvTimeoutError) -> bool
1.4.0 · sourceimpl<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
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
1.34.0 · sourceimpl PartialEq<NonZeroI64> for NonZeroI64
impl PartialEq<NonZeroI64> for NonZeroI64
fn eq(&self, other: &NonZeroI64) -> bool
fn ne(&self, other: &NonZeroI64) -> bool
1.4.0 · sourceimpl<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
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
1.34.0 · sourceimpl PartialEq<NonZeroI128> for NonZeroI128
impl PartialEq<NonZeroI128> for NonZeroI128
fn eq(&self, other: &NonZeroI128) -> bool
fn ne(&self, other: &NonZeroI128) -> bool
1.4.0 · sourceimpl<Ret, A, B> PartialEq<unsafe extern "C" fn(A, B, ...) -> Ret> for unsafe extern "C" fn(A, B, ...) -> Ret
impl<Ret, A, B> PartialEq<unsafe extern "C" fn(A, B, ...) -> Ret> for unsafe extern "C" fn(A, B, ...) -> Ret
sourceimpl<H, I, J, K, L> PartialEq<(H, I, J, K, L)> for (H, I, J, K, L) where
H: PartialEq<H>,
I: PartialEq<I>,
J: PartialEq<J>,
K: PartialEq<K>,
L: PartialEq<L> + ?Sized,
impl<H, I, J, K, L> PartialEq<(H, I, J, K, L)> for (H, I, J, K, L) where
H: PartialEq<H>,
I: PartialEq<I>,
J: PartialEq<J>,
K: PartialEq<K>,
L: PartialEq<L> + ?Sized,
1.4.0 · sourceimpl<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
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
1.4.0 · sourceimpl<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
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
sourceimpl<F, G, H, I, J, K, L> PartialEq<(F, G, H, I, J, K, L)> for (F, G, H, I, J, K, L) where
F: PartialEq<F>,
G: PartialEq<G>,
H: PartialEq<H>,
I: PartialEq<I>,
J: PartialEq<J>,
K: PartialEq<K>,
L: PartialEq<L> + ?Sized,
impl<F, G, H, I, J, K, L> PartialEq<(F, G, H, I, J, K, L)> for (F, G, H, I, J, K, L) where
F: PartialEq<F>,
G: PartialEq<G>,
H: PartialEq<H>,
I: PartialEq<I>,
J: PartialEq<J>,
K: PartialEq<K>,
L: PartialEq<L> + ?Sized,
1.4.0 · sourceimpl<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
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
1.4.0 · sourceimpl<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
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
1.4.0 · sourceimpl<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
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
1.4.0 · sourceimpl<Ret, A> PartialEq<unsafe extern "C" fn(A) -> Ret> for unsafe extern "C" fn(A) -> Ret
impl<Ret, A> PartialEq<unsafe extern "C" fn(A) -> Ret> for unsafe extern "C" fn(A) -> Ret
1.4.0 · sourceimpl<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
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
1.4.0 · sourceimpl<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
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
1.4.0 · sourceimpl<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
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
1.4.0 · sourceimpl<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
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
1.4.0 · sourceimpl<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
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
1.4.0 · sourceimpl<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
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
1.29.0 · sourceimpl<H> PartialEq<BuildHasherDefault<H>> for BuildHasherDefault<H>
impl<H> PartialEq<BuildHasherDefault<H>> for BuildHasherDefault<H>
fn eq(&self, _other: &BuildHasherDefault<H>) -> bool
1.4.0 · sourceimpl<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
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
1.4.0 · sourceimpl<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
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
1.34.0 · sourceimpl PartialEq<NonZeroI32> for NonZeroI32
impl PartialEq<NonZeroI32> for NonZeroI32
fn eq(&self, other: &NonZeroI32) -> bool
fn ne(&self, other: &NonZeroI32) -> bool
1.4.0 · sourceimpl<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
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
1.4.0 · sourceimpl<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
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
1.27.0 · sourceimpl PartialEq<CpuidResult> for CpuidResult
impl PartialEq<CpuidResult> for CpuidResult
fn eq(&self, other: &CpuidResult) -> bool
fn ne(&self, other: &CpuidResult) -> bool
1.4.0 · sourceimpl<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
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
sourceimpl PartialEq<FromBytesWithNulError> for FromBytesWithNulError
impl PartialEq<FromBytesWithNulError> for FromBytesWithNulError
fn eq(&self, other: &FromBytesWithNulError) -> bool
fn ne(&self, other: &FromBytesWithNulError) -> bool
1.4.0 · sourceimpl<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
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
sourceimpl<B, C, D, E, F, G, H, I, J, K, L> PartialEq<(B, C, D, E, F, G, H, I, J, K, L)> for (B, C, D, E, F, G, H, I, J, K, L) where
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,
impl<B, C, D, E, F, G, H, I, J, K, L> PartialEq<(B, C, D, E, F, G, H, I, J, K, L)> for (B, C, D, E, F, G, H, I, J, K, L) where
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,
1.4.0 · sourceimpl<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
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
1.4.0 · sourceimpl<Ret, A, B, C> PartialEq<unsafe extern "C" fn(A, B, C) -> Ret> for unsafe extern "C" fn(A, B, C) -> Ret
impl<Ret, A, B, C> PartialEq<unsafe extern "C" fn(A, B, C) -> Ret> for unsafe extern "C" fn(A, B, C) -> Ret
1.33.0 · sourceimpl PartialEq<PhantomPinned> for PhantomPinned
impl PartialEq<PhantomPinned> for PhantomPinned
fn eq(&self, other: &PhantomPinned) -> bool
1.4.0 · sourceimpl<Ret, A, B, C, D, E> PartialEq<fn(A, B, C, D, E) -> Ret> for fn(A, B, C, D, E) -> Ret
impl<Ret, A, B, C, D, E> PartialEq<fn(A, B, C, D, E) -> Ret> for fn(A, B, C, D, E) -> Ret
1.4.0 · sourceimpl<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
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
1.34.0 · sourceimpl PartialEq<NonZeroIsize> for NonZeroIsize
impl PartialEq<NonZeroIsize> for NonZeroIsize
fn eq(&self, other: &NonZeroIsize) -> bool
fn ne(&self, other: &NonZeroIsize) -> bool
1.4.0 · sourceimpl<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
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
1.4.0 · sourceimpl<Ret, A, B, C, D, E> PartialEq<unsafe fn(A, B, C, D, E) -> Ret> for unsafe fn(A, B, C, D, E) -> Ret
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
1.4.0 · sourceimpl<Ret, A> PartialEq<unsafe extern "C" fn(A, ...) -> Ret> for unsafe extern "C" fn(A, ...) -> Ret
impl<Ret, A> PartialEq<unsafe extern "C" fn(A, ...) -> Ret> for unsafe extern "C" fn(A, ...) -> Ret
1.4.0 · sourceimpl<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
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
sourceimpl<T> PartialEq<PhantomData<T>> for PhantomData<T> where
T: ?Sized,
impl<T> PartialEq<PhantomData<T>> for PhantomData<T> where
T: ?Sized,
fn eq(&self, _other: &PhantomData<T>) -> bool
sourceimpl<'a> PartialEq<Utf8LossyChunk<'a>> for Utf8LossyChunk<'a>
impl<'a> PartialEq<Utf8LossyChunk<'a>> for Utf8LossyChunk<'a>
fn eq(&self, other: &Utf8LossyChunk<'a>) -> bool
fn ne(&self, other: &Utf8LossyChunk<'a>) -> bool
1.55.0 · sourceimpl PartialEq<IntErrorKind> for IntErrorKind
impl PartialEq<IntErrorKind> for IntErrorKind
fn eq(&self, other: &IntErrorKind) -> bool
1.4.0 · sourceimpl<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
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
1.28.0 · sourceimpl PartialEq<NonZeroU128> for NonZeroU128
impl PartialEq<NonZeroU128> for NonZeroU128
fn eq(&self, other: &NonZeroU128) -> bool
fn ne(&self, other: &NonZeroU128) -> bool
1.4.0 · sourceimpl<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
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
1.28.0 · sourceimpl PartialEq<NonZeroU32> for NonZeroU32
impl PartialEq<NonZeroU32> for NonZeroU32
fn eq(&self, other: &NonZeroU32) -> bool
fn ne(&self, other: &NonZeroU32) -> bool
1.50.0 · sourceimpl PartialEq<LayoutError> for LayoutError
impl PartialEq<LayoutError> for LayoutError
fn eq(&self, other: &LayoutError) -> bool
1.21.0 · sourceimpl<T> PartialEq<Discriminant<T>> for Discriminant<T>
impl<T> PartialEq<Discriminant<T>> for Discriminant<T>
fn eq(&self, rhs: &Discriminant<T>) -> bool
1.4.0 · sourceimpl<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
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
sourceimpl<T, const LANES: usize> PartialEq<Simd<T, LANES>> for Simd<T, LANES> where
T: SimdElement + PartialEq<T>,
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> PartialEq<Simd<T, LANES>> for Simd<T, LANES> where
T: SimdElement + PartialEq<T>,
LaneCount<LANES>: SupportedLaneCount,
1.34.0 · sourceimpl PartialEq<TryFromIntError> for TryFromIntError
impl PartialEq<TryFromIntError> for TryFromIntError
fn eq(&self, other: &TryFromIntError) -> bool
fn ne(&self, other: &TryFromIntError) -> bool
1.28.0 · sourceimpl PartialEq<NonZeroUsize> for NonZeroUsize
impl PartialEq<NonZeroUsize> for NonZeroUsize
fn eq(&self, other: &NonZeroUsize) -> bool
fn ne(&self, other: &NonZeroUsize) -> bool
sourceimpl<I, J, K, L> PartialEq<(I, J, K, L)> for (I, J, K, L) where
I: PartialEq<I>,
J: PartialEq<J>,
K: PartialEq<K>,
L: PartialEq<L> + ?Sized,
impl<I, J, K, L> PartialEq<(I, J, K, L)> for (I, J, K, L) where
I: PartialEq<I>,
J: PartialEq<J>,
K: PartialEq<K>,
L: PartialEq<L> + ?Sized,
1.26.0 · sourceimpl<Idx> PartialEq<RangeToInclusive<Idx>> for RangeToInclusive<Idx> where
Idx: PartialEq<Idx>,
impl<Idx> PartialEq<RangeToInclusive<Idx>> for RangeToInclusive<Idx> where
Idx: PartialEq<Idx>,
fn eq(&self, other: &RangeToInclusive<Idx>) -> bool
fn ne(&self, other: &RangeToInclusive<Idx>) -> bool
1.34.0 · sourceimpl PartialEq<Infallible> for Infallible
impl PartialEq<Infallible> for Infallible
fn eq(&self, &Infallible) -> bool
1.4.0 · sourceimpl<Ret, A, B> PartialEq<extern "C" fn(A, B, ...) -> Ret> for extern "C" fn(A, B, ...) -> Ret
impl<Ret, A, B> PartialEq<extern "C" fn(A, B, ...) -> Ret> for extern "C" fn(A, B, ...) -> Ret
1.4.0 · sourceimpl<Ret, A, B> PartialEq<unsafe extern "C" fn(A, B) -> Ret> for unsafe extern "C" fn(A, B) -> Ret
impl<Ret, A, B> PartialEq<unsafe extern "C" fn(A, B) -> Ret> for unsafe extern "C" fn(A, B) -> Ret
sourceimpl PartialEq<FromBytesUntilNulError> for FromBytesUntilNulError
impl PartialEq<FromBytesUntilNulError> for FromBytesUntilNulError
fn eq(&self, other: &FromBytesUntilNulError) -> bool
fn ne(&self, other: &FromBytesUntilNulError) -> bool
1.4.0 · sourceimpl<Ret, A, B, C> PartialEq<extern "C" fn(A, B, C, ...) -> Ret> for extern "C" fn(A, B, C, ...) -> Ret
impl<Ret, A, B, C> PartialEq<extern "C" fn(A, B, C, ...) -> Ret> for extern "C" fn(A, B, C, ...) -> Ret
sourceimpl PartialEq<FpCategory> for FpCategory
impl PartialEq<FpCategory> for FpCategory
fn eq(&self, other: &FpCategory) -> bool
sourceimpl<Y, R> PartialEq<GeneratorState<Y, R>> for GeneratorState<Y, R> where
Y: PartialEq<Y>,
R: PartialEq<R>,
impl<Y, R> PartialEq<GeneratorState<Y, R>> for GeneratorState<Y, R> where
Y: PartialEq<Y>,
R: PartialEq<R>,
fn eq(&self, other: &GeneratorState<Y, R>) -> bool
fn ne(&self, other: &GeneratorState<Y, R>) -> bool
sourceimpl PartialEq<FromFloatSecsError> for FromFloatSecsError
impl PartialEq<FromFloatSecsError> for FromFloatSecsError
fn eq(&self, other: &FromFloatSecsError) -> bool
fn ne(&self, other: &FromFloatSecsError) -> bool
1.55.0 · sourceimpl<B, C> PartialEq<ControlFlow<B, C>> for ControlFlow<B, C> where
B: PartialEq<B>,
C: PartialEq<C>,
impl<B, C> PartialEq<ControlFlow<B, C>> for ControlFlow<B, C> where
B: PartialEq<B>,
C: PartialEq<C>,
fn eq(&self, other: &ControlFlow<B, C>) -> bool
fn ne(&self, other: &ControlFlow<B, C>) -> bool
sourceimpl<T> PartialEq<Saturating<T>> for Saturating<T> where
T: PartialEq<T>,
impl<T> PartialEq<Saturating<T>> for Saturating<T> where
T: PartialEq<T>,
fn eq(&self, other: &Saturating<T>) -> bool
fn ne(&self, other: &Saturating<T>) -> bool
1.26.0 · sourceimpl<Idx> PartialEq<RangeInclusive<Idx>> for RangeInclusive<Idx> where
Idx: PartialEq<Idx>,
impl<Idx> PartialEq<RangeInclusive<Idx>> for RangeInclusive<Idx> where
Idx: PartialEq<Idx>,
fn eq(&self, other: &RangeInclusive<Idx>) -> bool
fn ne(&self, other: &RangeInclusive<Idx>) -> bool
sourceimpl<E, F, G, H, I, J, K, L> PartialEq<(E, F, G, H, I, J, K, L)> for (E, F, G, H, I, J, K, L) where
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,
impl<E, F, G, H, I, J, K, L> PartialEq<(E, F, G, H, I, J, K, L)> for (E, F, G, H, I, J, K, L) where
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,
1.4.0 · sourceimpl<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
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
sourceimpl<G, H, I, J, K, L> PartialEq<(G, H, I, J, K, L)> for (G, H, I, J, K, L) where
G: PartialEq<G>,
H: PartialEq<H>,
I: PartialEq<I>,
J: PartialEq<J>,
K: PartialEq<K>,
L: PartialEq<L> + ?Sized,
impl<G, H, I, J, K, L> PartialEq<(G, H, I, J, K, L)> for (G, H, I, J, K, L) where
G: PartialEq<G>,
H: PartialEq<H>,
I: PartialEq<I>,
J: PartialEq<J>,
K: PartialEq<K>,
L: PartialEq<L> + ?Sized,
sourceimpl PartialEq<ParseFloatError> for ParseFloatError
impl PartialEq<ParseFloatError> for ParseFloatError
fn eq(&self, other: &ParseFloatError) -> bool
fn ne(&self, other: &ParseFloatError) -> bool
1.4.0 · sourceimpl<Ret, A, B, C, D> PartialEq<unsafe fn(A, B, C, D) -> Ret> for unsafe fn(A, B, C, D) -> Ret
impl<Ret, A, B, C, D> PartialEq<unsafe fn(A, B, C, D) -> Ret> for unsafe fn(A, B, C, D) -> Ret
1.28.0 · sourceimpl PartialEq<NonZeroU64> for NonZeroU64
impl PartialEq<NonZeroU64> for NonZeroU64
fn eq(&self, other: &NonZeroU64) -> bool
fn ne(&self, other: &NonZeroU64) -> bool
1.4.0 · sourceimpl<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
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
1.4.0 · sourceimpl<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
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
1.4.0 · sourceimpl<Ret, A, B, C> PartialEq<unsafe extern "C" fn(A, B, C, ...) -> Ret> for unsafe extern "C" fn(A, B, C, ...) -> Ret
impl<Ret, A, B, C> PartialEq<unsafe extern "C" fn(A, B, C, ...) -> Ret> for unsafe extern "C" fn(A, B, C, ...) -> Ret
sourceimpl<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,
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,
1.4.0 · sourceimpl<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
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
sourceimpl<Dyn> PartialEq<DynMetadata<Dyn>> for DynMetadata<Dyn> where
Dyn: ?Sized,
impl<Dyn> PartialEq<DynMetadata<Dyn>> for DynMetadata<Dyn> where
Dyn: ?Sized,
fn eq(&self, other: &DynMetadata<Dyn>) -> bool
sourceimpl PartialEq<AllocError> for AllocError
impl PartialEq<AllocError> for AllocError
fn eq(&self, other: &AllocError) -> bool
1.4.0 · sourceimpl<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
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
1.4.0 · sourceimpl<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
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
1.34.0 · sourceimpl PartialEq<CharTryFromError> for CharTryFromError
impl PartialEq<CharTryFromError> for CharTryFromError
fn eq(&self, other: &CharTryFromError) -> bool
fn ne(&self, other: &CharTryFromError) -> bool
1.4.0 · sourceimpl<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
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
1.4.0 · sourceimpl<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
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
1.4.0 · sourceimpl<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
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
1.36.0 · sourceimpl PartialEq<RawWakerVTable> for RawWakerVTable
impl PartialEq<RawWakerVTable> for RawWakerVTable
fn eq(&self, other: &RawWakerVTable) -> bool
fn ne(&self, other: &RawWakerVTable) -> bool
1.4.0 · sourceimpl<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
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
1.4.0 · sourceimpl<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
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
1.4.0 · sourceimpl<Ret, A, B, C, D> PartialEq<extern "C" fn(A, B, C, D, ...) -> Ret> for extern "C" fn(A, B, C, D, ...) -> Ret
impl<Ret, A, B, C, D> PartialEq<extern "C" fn(A, B, C, D, ...) -> Ret> for extern "C" fn(A, B, C, D, ...) -> Ret
1.4.0 · sourceimpl<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
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
1.4.0 · sourceimpl<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
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
1.4.0 · sourceimpl<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
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
1.59.0 · sourceimpl PartialEq<TryFromCharError> for TryFromCharError
impl PartialEq<TryFromCharError> for TryFromCharError
fn eq(&self, other: &TryFromCharError) -> bool
fn ne(&self, other: &TryFromCharError) -> bool
sourceimpl PartialEq<ParseIntError> for ParseIntError
impl PartialEq<ParseIntError> for ParseIntError
fn eq(&self, other: &ParseIntError) -> bool
fn ne(&self, other: &ParseIntError) -> bool
1.4.0 · sourceimpl<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
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
1.9.0 · sourceimpl PartialEq<DecodeUtf16Error> for DecodeUtf16Error
impl PartialEq<DecodeUtf16Error> for DecodeUtf16Error
fn eq(&self, other: &DecodeUtf16Error) -> bool
fn ne(&self, other: &DecodeUtf16Error) -> bool
1.4.0 · sourceimpl<Ret, A, B, C> PartialEq<extern "C" fn(A, B, C) -> Ret> for extern "C" fn(A, B, C) -> Ret
impl<Ret, A, B, C> PartialEq<extern "C" fn(A, B, C) -> Ret> for extern "C" fn(A, B, C) -> Ret
1.4.0 · sourceimpl<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
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
sourceimpl<'_, '_, A, B> PartialEq<&'_ mut B> for &'_ mut A where
A: PartialEq<B> + ?Sized,
B: ?Sized,
impl<'_, '_, A, B> PartialEq<&'_ mut B> for &'_ mut A where
A: PartialEq<B> + ?Sized,
B: ?Sized,
1.20.0 · sourceimpl PartialEq<ParseCharError> for ParseCharError
impl PartialEq<ParseCharError> for ParseCharError
fn eq(&self, other: &ParseCharError) -> bool
fn ne(&self, other: &ParseCharError) -> bool
1.4.0 · sourceimpl<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
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
1.20.0 · sourceimpl<T> PartialEq<ManuallyDrop<T>> for ManuallyDrop<T> where
T: PartialEq<T> + ?Sized,
impl<T> PartialEq<ManuallyDrop<T>> for ManuallyDrop<T> where
T: PartialEq<T> + ?Sized,
fn eq(&self, other: &ManuallyDrop<T>) -> bool
fn ne(&self, other: &ManuallyDrop<T>) -> bool
sourceimpl<C, D, E, F, G, H, I, J, K, L> PartialEq<(C, D, E, F, G, H, I, J, K, L)> for (C, D, E, F, G, H, I, J, K, L) where
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,
impl<C, D, E, F, G, H, I, J, K, L> PartialEq<(C, D, E, F, G, H, I, J, K, L)> for (C, D, E, F, G, H, I, J, K, L) where
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,
1.4.0 · sourceimpl<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
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
1.4.0 · sourceimpl<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
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
1.4.0 · sourceimpl<Ret, A, B, C, D> PartialEq<extern "C" fn(A, B, C, D) -> Ret> for extern "C" fn(A, B, C, D) -> Ret
impl<Ret, A, B, C, D> PartialEq<extern "C" fn(A, B, C, D) -> Ret> for extern "C" fn(A, B, C, D) -> Ret
sourceimpl<T, const LANES: usize> PartialEq<Mask<T, LANES>> for Mask<T, LANES> where
T: MaskElement + PartialEq<T>,
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> PartialEq<Mask<T, LANES>> for Mask<T, LANES> where
T: MaskElement + PartialEq<T>,
LaneCount<LANES>: SupportedLaneCount,
1.4.0 · sourceimpl<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
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
sourceimpl<D, E, F, G, H, I, J, K, L> PartialEq<(D, E, F, G, H, I, J, K, L)> for (D, E, F, G, H, I, J, K, L) where
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,
impl<D, E, F, G, H, I, J, K, L> PartialEq<(D, E, F, G, H, I, J, K, L)> for (D, E, F, G, H, I, J, K, L) where
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,
1.28.0 · sourceimpl PartialEq<NonZeroU16> for NonZeroU16
impl PartialEq<NonZeroU16> for NonZeroU16
fn eq(&self, other: &NonZeroU16) -> bool
fn ne(&self, other: &NonZeroU16) -> bool
1.4.0 · sourceimpl<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
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
1.4.0 · sourceimpl<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
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
1.34.0 · sourceimpl PartialEq<NonZeroI16> for NonZeroI16
impl PartialEq<NonZeroI16> for NonZeroI16
fn eq(&self, other: &NonZeroI16) -> bool
fn ne(&self, other: &NonZeroI16) -> bool
sourceimpl<J, K, L> PartialEq<(J, K, L)> for (J, K, L) where
J: PartialEq<J>,
K: PartialEq<K>,
L: PartialEq<L> + ?Sized,
impl<J, K, L> PartialEq<(J, K, L)> for (J, K, L) where
J: PartialEq<J>,
K: PartialEq<K>,
L: PartialEq<L> + ?Sized,
1.17.0 · sourceimpl<'_, T, U, A, const N: usize> PartialEq<&'_ [U; N]> for VecDeque<T, A> where
A: Allocator,
T: PartialEq<U>,
impl<'_, T, U, A, const N: usize> PartialEq<&'_ [U; N]> for VecDeque<T, A> where
A: Allocator,
T: PartialEq<U>,
1.17.0 · sourceimpl<'_, T, U, A, const N: usize> PartialEq<&'_ mut [U; N]> for VecDeque<T, A> where
A: Allocator,
T: PartialEq<U>,
impl<'_, T, U, A, const N: usize> PartialEq<&'_ mut [U; N]> for VecDeque<T, A> where
A: Allocator,
T: PartialEq<U>,
1.17.0 · sourceimpl<T, U, A, const N: usize> PartialEq<[U; N]> for VecDeque<T, A> where
A: Allocator,
T: PartialEq<U>,
impl<T, U, A, const N: usize> PartialEq<[U; N]> for VecDeque<T, A> where
A: Allocator,
T: PartialEq<U>,
sourceimpl<T> PartialEq<LinkedList<T>> for LinkedList<T> where
T: PartialEq<T>,
impl<T> PartialEq<LinkedList<T>> for LinkedList<T> where
T: PartialEq<T>,
fn eq(&self, other: &LinkedList<T>) -> bool
fn ne(&self, other: &LinkedList<T>) -> bool
1.17.0 · sourceimpl<'_, T, U, A> PartialEq<&'_ mut [U]> for VecDeque<T, A> where
A: Allocator,
T: PartialEq<U>,
impl<'_, T, U, A> PartialEq<&'_ mut [U]> for VecDeque<T, A> where
A: Allocator,
T: PartialEq<U>,
sourceimpl<'_, T, U, A, const N: usize> PartialEq<&'_ [U; N]> for Vec<T, A> where
A: Allocator,
T: PartialEq<U>,
impl<'_, T, U, A, const N: usize> PartialEq<&'_ [U; N]> for Vec<T, A> where
A: Allocator,
T: PartialEq<U>,
sourceimpl<T, U, A1, A2> PartialEq<Vec<U, A2>> for Vec<T, A1> where
A1: Allocator,
A2: Allocator,
T: PartialEq<U>,
impl<T, U, A1, A2> PartialEq<Vec<U, A2>> for Vec<T, A1> where
A1: Allocator,
A2: Allocator,
T: PartialEq<U>,
sourceimpl<T, U, A, const N: usize> PartialEq<[U; N]> for Vec<T, A> where
A: Allocator,
T: PartialEq<U>,
impl<T, U, A, const N: usize> PartialEq<[U; N]> for Vec<T, A> where
A: Allocator,
T: PartialEq<U>,
sourceimpl PartialEq<IntoStringError> for IntoStringError
impl PartialEq<IntoStringError> for IntoStringError
fn eq(&self, other: &IntoStringError) -> bool
fn ne(&self, other: &IntoStringError) -> bool
sourceimpl<K, V> PartialEq<BTreeMap<K, V>> for BTreeMap<K, V> where
K: PartialEq<K>,
V: PartialEq<V>,
impl<K, V> PartialEq<BTreeMap<K, V>> for BTreeMap<K, V> where
K: PartialEq<K>,
V: PartialEq<V>,
1.57.0 · sourceimpl PartialEq<TryReserveError> for TryReserveError
impl PartialEq<TryReserveError> for TryReserveError
fn eq(&self, other: &TryReserveError) -> bool
fn ne(&self, other: &TryReserveError) -> bool
1.17.0 · sourceimpl<T, U, A> PartialEq<Vec<U, A>> for VecDeque<T, A> where
A: Allocator,
T: PartialEq<U>,
impl<T, U, A> PartialEq<Vec<U, A>> for VecDeque<T, A> where
A: Allocator,
T: PartialEq<U>,
sourceimpl PartialEq<FromVecWithNulError> for FromVecWithNulError
impl PartialEq<FromVecWithNulError> for FromVecWithNulError
fn eq(&self, other: &FromVecWithNulError) -> bool
fn ne(&self, other: &FromVecWithNulError) -> bool
1.17.0 · sourceimpl<'_, T, U, A> PartialEq<&'_ [U]> for VecDeque<T, A> where
A: Allocator,
T: PartialEq<U>,
impl<'_, T, U, A> PartialEq<&'_ [U]> for VecDeque<T, A> where
A: Allocator,
T: PartialEq<U>,
sourceimpl PartialEq<TryReserveErrorKind> for TryReserveErrorKind
impl PartialEq<TryReserveErrorKind> for TryReserveErrorKind
fn eq(&self, other: &TryReserveErrorKind) -> bool
fn ne(&self, other: &TryReserveErrorKind) -> bool
sourceimpl PartialEq<FromUtf8Error> for FromUtf8Error
impl PartialEq<FromUtf8Error> for FromUtf8Error
fn eq(&self, other: &FromUtf8Error) -> bool
fn ne(&self, other: &FromUtf8Error) -> bool
sourceimpl<T> PartialEq<Rc<T>> for Rc<T> where
T: PartialEq<T> + ?Sized,
impl<T> PartialEq<Rc<T>> for Rc<T> where
T: PartialEq<T> + ?Sized,
sourcefn eq(&self, other: &Rc<T>) -> bool
fn eq(&self, other: &Rc<T>) -> bool
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));
sourcefn ne(&self, other: &Rc<T>) -> bool
fn ne(&self, other: &Rc<T>) -> bool
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));
1.46.0 · sourceimpl<'_, T, U, A> PartialEq<Vec<U, A>> for &'_ [T] where
A: Allocator,
T: PartialEq<U>,
impl<'_, T, U, A> PartialEq<Vec<U, A>> for &'_ [T] where
A: Allocator,
T: PartialEq<U>,
1.46.0 · sourceimpl<'_, T, U, A> PartialEq<Vec<U, A>> for &'_ mut [T] where
A: Allocator,
T: PartialEq<U>,
impl<'_, T, U, A> PartialEq<Vec<U, A>> for &'_ mut [T] where
A: Allocator,
T: PartialEq<U>,
sourceimpl PartialEq<_Unwind_Reason_Code> for _Unwind_Reason_Code
impl PartialEq<_Unwind_Reason_Code> for _Unwind_Reason_Code
fn eq(&self, other: &_Unwind_Reason_Code) -> bool
sourceimpl PartialEq<_Unwind_Action> for _Unwind_Action
impl PartialEq<_Unwind_Action> for _Unwind_Action
fn eq(&self, other: &_Unwind_Action) -> bool
sourceimpl PartialEq<HandshakeType> for HandshakeType
impl PartialEq<HandshakeType> for HandshakeType
fn eq(&self, other: &HandshakeType) -> bool
fn ne(&self, other: &HandshakeType) -> bool
sourceimpl PartialEq<Tls12CipherSuite> for Tls12CipherSuite
Available on crate feature tls12
only.
impl PartialEq<Tls12CipherSuite> for Tls12CipherSuite
tls12
only.fn eq(&self, other: &Tls12CipherSuite) -> bool
sourceimpl PartialEq<HeartbeatMessageType> for HeartbeatMessageType
impl PartialEq<HeartbeatMessageType> for HeartbeatMessageType
fn eq(&self, other: &HeartbeatMessageType) -> bool
fn ne(&self, other: &HeartbeatMessageType) -> bool
sourceimpl PartialEq<ContentType> for ContentType
impl PartialEq<ContentType> for ContentType
fn eq(&self, other: &ContentType) -> bool
fn ne(&self, other: &ContentType) -> bool
sourceimpl PartialEq<ExtensionType> for ExtensionType
impl PartialEq<ExtensionType> for ExtensionType
fn eq(&self, other: &ExtensionType) -> bool
fn ne(&self, other: &ExtensionType) -> bool
sourceimpl PartialEq<AlertDescription> for AlertDescription
impl PartialEq<AlertDescription> for AlertDescription
fn eq(&self, other: &AlertDescription) -> bool
fn ne(&self, other: &AlertDescription) -> bool
sourceimpl PartialEq<ProtocolVersion> for ProtocolVersion
impl PartialEq<ProtocolVersion> for ProtocolVersion
fn eq(&self, other: &ProtocolVersion) -> bool
fn ne(&self, other: &ProtocolVersion) -> bool
sourceimpl PartialEq<PayloadU16> for PayloadU16
impl PartialEq<PayloadU16> for PayloadU16
fn eq(&self, other: &PayloadU16) -> bool
fn ne(&self, other: &PayloadU16) -> bool
sourceimpl PartialEq<NamedCurve> for NamedCurve
impl PartialEq<NamedCurve> for NamedCurve
fn eq(&self, other: &NamedCurve) -> bool
fn ne(&self, other: &NamedCurve) -> bool
sourceimpl PartialEq<ServerName> for ServerName
impl PartialEq<ServerName> for ServerName
fn eq(&self, other: &ServerName) -> bool
fn ne(&self, other: &ServerName) -> bool
sourceimpl PartialEq<HashAlgorithm> for HashAlgorithm
impl PartialEq<HashAlgorithm> for HashAlgorithm
fn eq(&self, other: &HashAlgorithm) -> bool
fn ne(&self, other: &HashAlgorithm) -> bool
sourceimpl PartialEq<PSKKeyExchangeMode> for PSKKeyExchangeMode
impl PartialEq<PSKKeyExchangeMode> for PSKKeyExchangeMode
fn eq(&self, other: &PSKKeyExchangeMode) -> bool
fn ne(&self, other: &PSKKeyExchangeMode) -> bool
sourceimpl PartialEq<PrivateKey> for PrivateKey
impl PartialEq<PrivateKey> for PrivateKey
fn eq(&self, other: &PrivateKey) -> bool
fn ne(&self, other: &PrivateKey) -> bool
sourceimpl PartialEq<CipherSuite> for CipherSuite
impl PartialEq<CipherSuite> for CipherSuite
fn eq(&self, other: &CipherSuite) -> bool
fn ne(&self, other: &CipherSuite) -> bool
sourceimpl PartialEq<Tls13CipherSuite> for Tls13CipherSuite
impl PartialEq<Tls13CipherSuite> for Tls13CipherSuite
fn eq(&self, other: &Tls13CipherSuite) -> bool
sourceimpl PartialEq<KeyUpdateRequest> for KeyUpdateRequest
impl PartialEq<KeyUpdateRequest> for KeyUpdateRequest
fn eq(&self, other: &KeyUpdateRequest) -> bool
fn ne(&self, other: &KeyUpdateRequest) -> bool
sourceimpl PartialEq<HeartbeatMode> for HeartbeatMode
impl PartialEq<HeartbeatMode> for HeartbeatMode
fn eq(&self, other: &HeartbeatMode) -> bool
fn ne(&self, other: &HeartbeatMode) -> bool
sourceimpl PartialEq<PayloadU24> for PayloadU24
impl PartialEq<PayloadU24> for PayloadU24
fn eq(&self, other: &PayloadU24) -> bool
fn ne(&self, other: &PayloadU24) -> bool
sourceimpl PartialEq<ClientCertificateType> for ClientCertificateType
impl PartialEq<ClientCertificateType> for ClientCertificateType
fn eq(&self, other: &ClientCertificateType) -> bool
fn ne(&self, other: &ClientCertificateType) -> bool
sourceimpl PartialEq<CertificateStatusType> for CertificateStatusType
impl PartialEq<CertificateStatusType> for CertificateStatusType
fn eq(&self, other: &CertificateStatusType) -> bool
fn ne(&self, other: &CertificateStatusType) -> bool
sourceimpl PartialEq<NamedGroup> for NamedGroup
impl PartialEq<NamedGroup> for NamedGroup
fn eq(&self, other: &NamedGroup) -> bool
fn ne(&self, other: &NamedGroup) -> bool
sourceimpl PartialEq<Certificate> for Certificate
impl PartialEq<Certificate> for Certificate
fn eq(&self, other: &Certificate) -> bool
fn ne(&self, other: &Certificate) -> bool
sourceimpl PartialEq<SignatureScheme> for SignatureScheme
impl PartialEq<SignatureScheme> for SignatureScheme
fn eq(&self, other: &SignatureScheme) -> bool
fn ne(&self, other: &SignatureScheme) -> bool
sourceimpl PartialEq<Compression> for Compression
impl PartialEq<Compression> for Compression
fn eq(&self, other: &Compression) -> bool
fn ne(&self, other: &Compression) -> bool
sourceimpl PartialEq<SignatureAlgorithm> for SignatureAlgorithm
impl PartialEq<SignatureAlgorithm> for SignatureAlgorithm
fn eq(&self, other: &SignatureAlgorithm) -> bool
fn ne(&self, other: &SignatureAlgorithm) -> bool
sourceimpl PartialEq<SupportedProtocolVersion> for SupportedProtocolVersion
impl PartialEq<SupportedProtocolVersion> for SupportedProtocolVersion
fn eq(&self, other: &SupportedProtocolVersion) -> bool
fn ne(&self, other: &SupportedProtocolVersion) -> bool
sourceimpl PartialEq<AlertLevel> for AlertLevel
impl PartialEq<AlertLevel> for AlertLevel
fn eq(&self, other: &AlertLevel) -> bool
fn ne(&self, other: &AlertLevel) -> bool
sourceimpl PartialEq<SupportedCipherSuite> for SupportedCipherSuite
impl PartialEq<SupportedCipherSuite> for SupportedCipherSuite
fn eq(&self, other: &SupportedCipherSuite) -> bool
fn ne(&self, other: &SupportedCipherSuite) -> bool
sourceimpl PartialEq<ServerNameType> for ServerNameType
impl PartialEq<ServerNameType> for ServerNameType
fn eq(&self, other: &ServerNameType) -> bool
fn ne(&self, other: &ServerNameType) -> bool
sourceimpl PartialEq<ECPointFormat> for ECPointFormat
impl PartialEq<ECPointFormat> for ECPointFormat
fn eq(&self, other: &ECPointFormat) -> bool
fn ne(&self, other: &ECPointFormat) -> bool
sourceimpl PartialEq<BulkAlgorithm> for BulkAlgorithm
impl PartialEq<BulkAlgorithm> for BulkAlgorithm
fn eq(&self, other: &BulkAlgorithm) -> bool
sourceimpl PartialEq<ECCurveType> for ECCurveType
impl PartialEq<ECCurveType> for ECCurveType
fn eq(&self, other: &ECCurveType) -> bool
fn ne(&self, other: &ECCurveType) -> bool
sourceimpl<'a> PartialEq<MetadataBuilder<'a>> for MetadataBuilder<'a>
impl<'a> PartialEq<MetadataBuilder<'a>> for MetadataBuilder<'a>
fn eq(&self, other: &MetadataBuilder<'a>) -> bool
fn ne(&self, other: &MetadataBuilder<'a>) -> bool
sourceimpl PartialEq<LevelFilter> for LevelFilter
impl PartialEq<LevelFilter> for LevelFilter
fn eq(&self, other: &LevelFilter) -> bool
sourceimpl PartialEq<ParseLevelError> for ParseLevelError
impl PartialEq<ParseLevelError> for ParseLevelError
fn eq(&self, other: &ParseLevelError) -> bool
fn ne(&self, other: &ParseLevelError) -> bool
sourceimpl PartialEq<LevelFilter> for Level
impl PartialEq<LevelFilter> for Level
fn eq(&self, other: &LevelFilter) -> bool
sourceimpl PartialEq<EcdsaSigningAlgorithm> for EcdsaSigningAlgorithm
impl PartialEq<EcdsaSigningAlgorithm> for EcdsaSigningAlgorithm
fn eq(&self, other: &EcdsaSigningAlgorithm) -> bool
sourceimpl PartialEq<Unspecified> for Unspecified
impl PartialEq<Unspecified> for Unspecified
fn eq(&self, other: &Unspecified) -> bool
sourceimpl PartialEq<EndOfInput> for EndOfInput
impl PartialEq<EndOfInput> for EndOfInput
fn eq(&self, other: &EndOfInput) -> bool
sourceimpl PartialEq<InvalidDnsNameError> for InvalidDnsNameError
impl PartialEq<InvalidDnsNameError> for InvalidDnsNameError
fn eq(&self, other: &InvalidDnsNameError) -> bool
sourceimpl PartialEq<TryRecvError> for TryRecvError
impl PartialEq<TryRecvError> for TryRecvError
fn eq(&self, other: &TryRecvError) -> bool
fn ne(&self, other: &TryRecvError) -> bool
sourceimpl PartialEq<TryAcquireError> for TryAcquireError
impl PartialEq<TryAcquireError> for TryAcquireError
fn eq(&self, other: &TryAcquireError) -> bool
sourceimpl<T> PartialEq<SendTimeoutError<T>> for SendTimeoutError<T> where
T: PartialEq<T>,
impl<T> PartialEq<SendTimeoutError<T>> for SendTimeoutError<T> where
T: PartialEq<T>,
fn eq(&self, other: &SendTimeoutError<T>) -> bool
fn ne(&self, other: &SendTimeoutError<T>) -> bool
sourceimpl PartialEq<TryRecvError> for TryRecvError
impl PartialEq<TryRecvError> for TryRecvError
fn eq(&self, other: &TryRecvError) -> bool
sourceimpl<T> PartialEq<TrySendError<T>> for TrySendError<T> where
T: PartialEq<T>,
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
sourceimpl PartialEq<TryRecvError> for TryRecvError
impl PartialEq<TryRecvError> for TryRecvError
fn eq(&self, other: &TryRecvError) -> bool
sourceimpl PartialEq<MissedTickBehavior> for MissedTickBehavior
impl PartialEq<MissedTickBehavior> for MissedTickBehavior
fn eq(&self, other: &MissedTickBehavior) -> bool
impl PartialEq<WaitTimeoutResult> for WaitTimeoutResult
impl PartialEq<WaitTimeoutResult> for WaitTimeoutResult
impl PartialEq<ParkToken> for ParkToken
impl PartialEq<ParkToken> for ParkToken
impl PartialEq<UnparkToken> for UnparkToken
impl PartialEq<UnparkToken> for UnparkToken
impl PartialEq<UnparkResult> for UnparkResult
impl PartialEq<UnparkResult> for UnparkResult
impl PartialEq<ParkResult> for ParkResult
impl PartialEq<ParkResult> for ParkResult
impl<A, B> PartialEq<SmallVec<B>> for SmallVec<A> where
A: Array,
B: Array,
<A as Array>::Item: PartialEq<<B as Array>::Item>,
impl<A, B> PartialEq<SmallVec<B>> for SmallVec<A> where
A: Array,
B: Array,
<A as Array>::Item: PartialEq<<B as Array>::Item>,
impl PartialEq<Interest> for Interest
impl PartialEq<Interest> for Interest
impl PartialEq<Token> for Token
impl PartialEq<Token> for Token
sourceimpl PartialEq<BernoulliError> for BernoulliError
impl PartialEq<BernoulliError> for BernoulliError
fn eq(&self, other: &BernoulliError) -> bool
sourceimpl<X> PartialEq<UniformInt<X>> for UniformInt<X> where
X: PartialEq<X>,
impl<X> PartialEq<UniformInt<X>> for UniformInt<X> where
X: PartialEq<X>,
fn eq(&self, other: &UniformInt<X>) -> bool
fn ne(&self, other: &UniformInt<X>) -> bool
sourceimpl<X> PartialEq<WeightedIndex<X>> for WeightedIndex<X> where
X: PartialEq<X> + SampleUniform + PartialOrd<X>,
<X as SampleUniform>::Sampler: PartialEq<<X as SampleUniform>::Sampler>,
impl<X> PartialEq<WeightedIndex<X>> for WeightedIndex<X> where
X: PartialEq<X> + SampleUniform + PartialOrd<X>,
<X as SampleUniform>::Sampler: PartialEq<<X as SampleUniform>::Sampler>,
fn eq(&self, other: &WeightedIndex<X>) -> bool
fn ne(&self, other: &WeightedIndex<X>) -> bool
sourceimpl PartialEq<WeightedError> for WeightedError
impl PartialEq<WeightedError> for WeightedError
fn eq(&self, other: &WeightedError) -> bool
sourceimpl<X> PartialEq<UniformFloat<X>> for UniformFloat<X> where
X: PartialEq<X>,
impl<X> PartialEq<UniformFloat<X>> for UniformFloat<X> where
X: PartialEq<X>,
fn eq(&self, other: &UniformFloat<X>) -> bool
fn ne(&self, other: &UniformFloat<X>) -> bool
sourceimpl<X> PartialEq<Uniform<X>> for Uniform<X> where
X: PartialEq<X> + SampleUniform,
<X as SampleUniform>::Sampler: PartialEq<<X as SampleUniform>::Sampler>,
impl<X> PartialEq<Uniform<X>> for Uniform<X> where
X: PartialEq<X> + SampleUniform,
<X as SampleUniform>::Sampler: PartialEq<<X as SampleUniform>::Sampler>,
sourceimpl PartialEq<ChaCha8Rng> for ChaCha8Rng
impl PartialEq<ChaCha8Rng> for ChaCha8Rng
fn eq(&self, rhs: &ChaCha8Rng) -> bool
sourceimpl PartialEq<ChaCha8Core> for ChaCha8Core
impl PartialEq<ChaCha8Core> for ChaCha8Core
fn eq(&self, other: &ChaCha8Core) -> bool
fn ne(&self, other: &ChaCha8Core) -> bool
sourceimpl PartialEq<ChaCha20Rng> for ChaCha20Rng
impl PartialEq<ChaCha20Rng> for ChaCha20Rng
fn eq(&self, rhs: &ChaCha20Rng) -> bool
sourceimpl PartialEq<ChaCha12Rng> for ChaCha12Rng
impl PartialEq<ChaCha12Rng> for ChaCha12Rng
fn eq(&self, rhs: &ChaCha12Rng) -> bool
sourceimpl PartialEq<ChaCha20Core> for ChaCha20Core
impl PartialEq<ChaCha20Core> for ChaCha20Core
fn eq(&self, other: &ChaCha20Core) -> bool
fn ne(&self, other: &ChaCha20Core) -> bool
sourceimpl PartialEq<ChaCha12Core> for ChaCha12Core
impl PartialEq<ChaCha12Core> for ChaCha12Core
fn eq(&self, other: &ChaCha12Core) -> bool
fn ne(&self, other: &ChaCha12Core) -> bool
sourceimpl<'a> PartialEq<ParsedExtension<'a>> for ParsedExtension<'a>
impl<'a> PartialEq<ParsedExtension<'a>> for ParsedExtension<'a>
fn eq(&self, other: &ParsedExtension<'a>) -> bool
fn ne(&self, other: &ParsedExtension<'a>) -> bool
sourceimpl PartialEq<ReasonCode> for ReasonCode
impl PartialEq<ReasonCode> for ReasonCode
fn eq(&self, other: &ReasonCode) -> bool
fn ne(&self, other: &ReasonCode) -> bool
sourceimpl PartialEq<NSCertType> for NSCertType
impl PartialEq<NSCertType> for NSCertType
fn eq(&self, other: &NSCertType) -> bool
fn ne(&self, other: &NSCertType) -> bool
sourceimpl<'a> PartialEq<ExtendedKeyUsage<'a>> for ExtendedKeyUsage<'a>
impl<'a> PartialEq<ExtendedKeyUsage<'a>> for ExtendedKeyUsage<'a>
fn eq(&self, other: &ExtendedKeyUsage<'a>) -> bool
fn ne(&self, other: &ExtendedKeyUsage<'a>) -> bool
sourceimpl<'a> PartialEq<GeneralSubtree<'a>> for GeneralSubtree<'a>
impl<'a> PartialEq<GeneralSubtree<'a>> for GeneralSubtree<'a>
fn eq(&self, other: &GeneralSubtree<'a>) -> bool
fn ne(&self, other: &GeneralSubtree<'a>) -> bool
sourceimpl PartialEq<X509Version> for X509Version
impl PartialEq<X509Version> for X509Version
fn eq(&self, other: &X509Version) -> bool
fn ne(&self, other: &X509Version) -> bool
sourceimpl PartialEq<PolicyConstraints> for PolicyConstraints
impl PartialEq<PolicyConstraints> for PolicyConstraints
fn eq(&self, other: &PolicyConstraints) -> bool
fn ne(&self, other: &PolicyConstraints) -> bool
sourceimpl<'a> PartialEq<NameConstraints<'a>> for NameConstraints<'a>
impl<'a> PartialEq<NameConstraints<'a>> for NameConstraints<'a>
fn eq(&self, other: &NameConstraints<'a>) -> bool
fn ne(&self, other: &NameConstraints<'a>) -> bool
sourceimpl<'a> PartialEq<DistributionPointName<'a>> for DistributionPointName<'a>
impl<'a> PartialEq<DistributionPointName<'a>> for DistributionPointName<'a>
fn eq(&self, other: &DistributionPointName<'a>) -> bool
fn ne(&self, other: &DistributionPointName<'a>) -> bool
sourceimpl<'a> PartialEq<AuthorityKeyIdentifier<'a>> for AuthorityKeyIdentifier<'a>
impl<'a> PartialEq<AuthorityKeyIdentifier<'a>> for AuthorityKeyIdentifier<'a>
fn eq(&self, other: &AuthorityKeyIdentifier<'a>) -> bool
fn ne(&self, other: &AuthorityKeyIdentifier<'a>) -> bool
sourceimpl PartialEq<InhibitAnyPolicy> for InhibitAnyPolicy
impl PartialEq<InhibitAnyPolicy> for InhibitAnyPolicy
fn eq(&self, other: &InhibitAnyPolicy) -> bool
fn ne(&self, other: &InhibitAnyPolicy) -> bool
sourceimpl<'a> PartialEq<SubjectAlternativeName<'a>> for SubjectAlternativeName<'a>
impl<'a> PartialEq<SubjectAlternativeName<'a>> for SubjectAlternativeName<'a>
fn eq(&self, other: &SubjectAlternativeName<'a>) -> bool
fn ne(&self, other: &SubjectAlternativeName<'a>) -> bool
sourceimpl<'a> PartialEq<ExtensionRequest<'a>> for ExtensionRequest<'a>
impl<'a> PartialEq<ExtensionRequest<'a>> for ExtensionRequest<'a>
fn eq(&self, other: &ExtensionRequest<'a>) -> bool
fn ne(&self, other: &ExtensionRequest<'a>) -> bool
sourceimpl<'a> PartialEq<UniqueIdentifier<'a>> for UniqueIdentifier<'a>
impl<'a> PartialEq<UniqueIdentifier<'a>> for UniqueIdentifier<'a>
fn eq(&self, other: &UniqueIdentifier<'a>) -> bool
fn ne(&self, other: &UniqueIdentifier<'a>) -> bool
sourceimpl<'a> PartialEq<AlgorithmIdentifier<'a>> for AlgorithmIdentifier<'a>
impl<'a> PartialEq<AlgorithmIdentifier<'a>> for AlgorithmIdentifier<'a>
fn eq(&self, other: &AlgorithmIdentifier<'a>) -> bool
fn ne(&self, other: &AlgorithmIdentifier<'a>) -> bool
sourceimpl<'a> PartialEq<TbsCertificate<'a>> for TbsCertificate<'a>
impl<'a> PartialEq<TbsCertificate<'a>> for TbsCertificate<'a>
fn eq(&self, other: &TbsCertificate<'a>) -> bool
fn ne(&self, other: &TbsCertificate<'a>) -> bool
sourceimpl PartialEq<TbsCertificateParser> for TbsCertificateParser
impl PartialEq<TbsCertificateParser> for TbsCertificateParser
fn eq(&self, other: &TbsCertificateParser) -> bool
fn ne(&self, other: &TbsCertificateParser) -> bool
sourceimpl<'a> PartialEq<RevokedCertificate<'a>> for RevokedCertificate<'a>
impl<'a> PartialEq<RevokedCertificate<'a>> for RevokedCertificate<'a>
fn eq(&self, other: &RevokedCertificate<'a>) -> bool
fn ne(&self, other: &RevokedCertificate<'a>) -> bool
sourceimpl<'a> PartialEq<DigitallySigned<'a>> for DigitallySigned<'a>
impl<'a> PartialEq<DigitallySigned<'a>> for DigitallySigned<'a>
fn eq(&self, other: &DigitallySigned<'a>) -> bool
fn ne(&self, other: &DigitallySigned<'a>) -> bool
sourceimpl<'a> PartialEq<X509Extension<'a>> for X509Extension<'a>
impl<'a> PartialEq<X509Extension<'a>> for X509Extension<'a>
fn eq(&self, other: &X509Extension<'a>) -> bool
fn ne(&self, other: &X509Extension<'a>) -> bool
sourceimpl<'a> PartialEq<X509CriAttribute<'a>> for X509CriAttribute<'a>
impl<'a> PartialEq<X509CriAttribute<'a>> for X509CriAttribute<'a>
fn eq(&self, other: &X509CriAttribute<'a>) -> bool
fn ne(&self, other: &X509CriAttribute<'a>) -> bool
sourceimpl<'a> PartialEq<IssuerAlternativeName<'a>> for IssuerAlternativeName<'a>
impl<'a> PartialEq<IssuerAlternativeName<'a>> for IssuerAlternativeName<'a>
fn eq(&self, other: &IssuerAlternativeName<'a>) -> bool
fn ne(&self, other: &IssuerAlternativeName<'a>) -> bool
sourceimpl<'a> PartialEq<PolicyMappings<'a>> for PolicyMappings<'a>
impl<'a> PartialEq<PolicyMappings<'a>> for PolicyMappings<'a>
fn eq(&self, other: &PolicyMappings<'a>) -> bool
fn ne(&self, other: &PolicyMappings<'a>) -> bool
sourceimpl<'a> PartialEq<AuthorityInfoAccess<'a>> for AuthorityInfoAccess<'a>
impl<'a> PartialEq<AuthorityInfoAccess<'a>> for AuthorityInfoAccess<'a>
fn eq(&self, other: &AuthorityInfoAccess<'a>) -> bool
fn ne(&self, other: &AuthorityInfoAccess<'a>) -> bool
sourceimpl<'a> PartialEq<GeneralName<'a>> for GeneralName<'a>
impl<'a> PartialEq<GeneralName<'a>> for GeneralName<'a>
fn eq(&self, other: &GeneralName<'a>) -> bool
fn ne(&self, other: &GeneralName<'a>) -> bool
sourceimpl<'a> PartialEq<CRLDistributionPoint<'a>> for CRLDistributionPoint<'a>
impl<'a> PartialEq<CRLDistributionPoint<'a>> for CRLDistributionPoint<'a>
fn eq(&self, other: &CRLDistributionPoint<'a>) -> bool
fn ne(&self, other: &CRLDistributionPoint<'a>) -> bool
sourceimpl<'a> PartialEq<RelativeDistinguishedName<'a>> for RelativeDistinguishedName<'a>
impl<'a> PartialEq<RelativeDistinguishedName<'a>> for RelativeDistinguishedName<'a>
fn eq(&self, other: &RelativeDistinguishedName<'a>) -> bool
fn ne(&self, other: &RelativeDistinguishedName<'a>) -> bool
sourceimpl<'a> PartialEq<X509CertificationRequestInfo<'a>> for X509CertificationRequestInfo<'a>
impl<'a> PartialEq<X509CertificationRequestInfo<'a>> for X509CertificationRequestInfo<'a>
fn eq(&self, other: &X509CertificationRequestInfo<'a>) -> bool
fn ne(&self, other: &X509CertificationRequestInfo<'a>) -> bool
sourceimpl<'a> PartialEq<X509CertificationRequest<'a>> for X509CertificationRequest<'a>
impl<'a> PartialEq<X509CertificationRequest<'a>> for X509CertificationRequest<'a>
fn eq(&self, other: &X509CertificationRequest<'a>) -> bool
fn ne(&self, other: &X509CertificationRequest<'a>) -> bool
sourceimpl<'a> PartialEq<PolicyInformation<'a>> for PolicyInformation<'a>
impl<'a> PartialEq<PolicyInformation<'a>> for PolicyInformation<'a>
fn eq(&self, other: &PolicyInformation<'a>) -> bool
fn ne(&self, other: &PolicyInformation<'a>) -> bool
sourceimpl<'a> PartialEq<SignedCertificateTimestamp<'a>> for SignedCertificateTimestamp<'a>
impl<'a> PartialEq<SignedCertificateTimestamp<'a>> for SignedCertificateTimestamp<'a>
fn eq(&self, other: &SignedCertificateTimestamp<'a>) -> bool
fn ne(&self, other: &SignedCertificateTimestamp<'a>) -> bool
sourceimpl PartialEq<BasicConstraints> for BasicConstraints
impl PartialEq<BasicConstraints> for BasicConstraints
fn eq(&self, other: &BasicConstraints) -> bool
fn ne(&self, other: &BasicConstraints) -> bool
sourceimpl<'a> PartialEq<PolicyQualifierInfo<'a>> for PolicyQualifierInfo<'a>
impl<'a> PartialEq<PolicyQualifierInfo<'a>> for PolicyQualifierInfo<'a>
fn eq(&self, other: &PolicyQualifierInfo<'a>) -> bool
fn ne(&self, other: &PolicyQualifierInfo<'a>) -> bool
sourceimpl<'a> PartialEq<TbsCertList<'a>> for TbsCertList<'a>
impl<'a> PartialEq<TbsCertList<'a>> for TbsCertList<'a>
fn eq(&self, other: &TbsCertList<'a>) -> bool
fn ne(&self, other: &TbsCertList<'a>) -> bool
sourceimpl<T> PartialEq<BasicExtension<T>> for BasicExtension<T> where
T: PartialEq<T>,
impl<T> PartialEq<BasicExtension<T>> for BasicExtension<T> where
T: PartialEq<T>,
fn eq(&self, other: &BasicExtension<T>) -> bool
fn ne(&self, other: &BasicExtension<T>) -> bool
sourceimpl<'a> PartialEq<AttributeTypeAndValue<'a>> for AttributeTypeAndValue<'a>
impl<'a> PartialEq<AttributeTypeAndValue<'a>> for AttributeTypeAndValue<'a>
fn eq(&self, other: &AttributeTypeAndValue<'a>) -> bool
fn ne(&self, other: &AttributeTypeAndValue<'a>) -> bool
sourceimpl<'a> PartialEq<KeyIdentifier<'a>> for KeyIdentifier<'a>
impl<'a> PartialEq<KeyIdentifier<'a>> for KeyIdentifier<'a>
fn eq(&self, other: &KeyIdentifier<'a>) -> bool
fn ne(&self, other: &KeyIdentifier<'a>) -> bool
sourceimpl PartialEq<ReasonFlags> for ReasonFlags
impl PartialEq<ReasonFlags> for ReasonFlags
fn eq(&self, other: &ReasonFlags) -> bool
fn ne(&self, other: &ReasonFlags) -> bool
sourceimpl PartialEq<X509ExtensionParser> for X509ExtensionParser
impl PartialEq<X509ExtensionParser> for X509ExtensionParser
fn eq(&self, other: &X509ExtensionParser) -> bool
fn ne(&self, other: &X509ExtensionParser) -> bool
sourceimpl<'a> PartialEq<AccessDescription<'a>> for AccessDescription<'a>
impl<'a> PartialEq<AccessDescription<'a>> for AccessDescription<'a>
fn eq(&self, other: &AccessDescription<'a>) -> bool
fn ne(&self, other: &AccessDescription<'a>) -> bool
sourceimpl PartialEq<X509CertificateParser> for X509CertificateParser
impl PartialEq<X509CertificateParser> for X509CertificateParser
fn eq(&self, other: &X509CertificateParser) -> bool
fn ne(&self, other: &X509CertificateParser) -> bool
sourceimpl<'a> PartialEq<SubjectPublicKeyInfo<'a>> for SubjectPublicKeyInfo<'a>
impl<'a> PartialEq<SubjectPublicKeyInfo<'a>> for SubjectPublicKeyInfo<'a>
fn eq(&self, other: &SubjectPublicKeyInfo<'a>) -> bool
fn ne(&self, other: &SubjectPublicKeyInfo<'a>) -> bool
sourceimpl<'a> PartialEq<UnparsedObject<'a>> for UnparsedObject<'a>
impl<'a> PartialEq<UnparsedObject<'a>> for UnparsedObject<'a>
fn eq(&self, other: &UnparsedObject<'a>) -> bool
fn ne(&self, other: &UnparsedObject<'a>) -> bool
sourceimpl<'a> PartialEq<ParsedCriAttribute<'a>> for ParsedCriAttribute<'a>
impl<'a> PartialEq<ParsedCriAttribute<'a>> for ParsedCriAttribute<'a>
fn eq(&self, other: &ParsedCriAttribute<'a>) -> bool
fn ne(&self, other: &ParsedCriAttribute<'a>) -> bool
sourceimpl<'a> PartialEq<X509Certificate<'a>> for X509Certificate<'a>
impl<'a> PartialEq<X509Certificate<'a>> for X509Certificate<'a>
fn eq(&self, other: &X509Certificate<'a>) -> bool
fn ne(&self, other: &X509Certificate<'a>) -> bool
sourceimpl<'a> PartialEq<RSAPublicKey<'a>> for RSAPublicKey<'a>
impl<'a> PartialEq<RSAPublicKey<'a>> for RSAPublicKey<'a>
fn eq(&self, other: &RSAPublicKey<'a>) -> bool
fn ne(&self, other: &RSAPublicKey<'a>) -> bool
sourceimpl<'a> PartialEq<PolicyMapping<'a>> for PolicyMapping<'a>
impl<'a> PartialEq<PolicyMapping<'a>> for PolicyMapping<'a>
fn eq(&self, other: &PolicyMapping<'a>) -> bool
fn ne(&self, other: &PolicyMapping<'a>) -> bool
sourceimpl<'a> PartialEq<CtExtensions<'a>> for CtExtensions<'a>
impl<'a> PartialEq<CtExtensions<'a>> for CtExtensions<'a>
fn eq(&self, other: &CtExtensions<'a>) -> bool
fn ne(&self, other: &CtExtensions<'a>) -> bool
impl<'a> PartialEq<BitStringObject<'a>> for BitStringObject<'a>
impl<'a> PartialEq<BitStringObject<'a>> for BitStringObject<'a>
impl PartialEq<PrettyPrinterFlag> for PrettyPrinterFlag
impl PartialEq<PrettyPrinterFlag> for PrettyPrinterFlag
impl<'a> PartialEq<BerObject<'a>> for BerObject<'a>
impl<'a> PartialEq<BerObject<'a>> for BerObject<'a>
impl<'a> PartialEq<BerObjectContent<'a>> for BerObjectContent<'a>
impl<'a> PartialEq<BerObjectContent<'a>> for BerObjectContent<'a>
impl<'a, TagKind, T> PartialEq<TaggedParser<'a, TagKind, T>> for TaggedParser<'a, TagKind, T> where
TagKind: PartialEq<TagKind>,
T: PartialEq<T>,
impl<'a, TagKind, T> PartialEq<TaggedParser<'a, TagKind, T>> for TaggedParser<'a, TagKind, T> where
TagKind: PartialEq<TagKind>,
T: PartialEq<T>,
impl<T, TagKind, const CLASS: u8, const TAG: u32> PartialEq<TaggedValue<T, TagKind, CLASS, TAG>> for TaggedValue<T, TagKind, CLASS, TAG> where
T: PartialEq<T>,
TagKind: PartialEq<TagKind>,
impl<T, TagKind, const CLASS: u8, const TAG: u32> PartialEq<TaggedValue<T, TagKind, CLASS, TAG>> for TaggedValue<T, TagKind, CLASS, TAG> where
T: PartialEq<T>,
TagKind: PartialEq<TagKind>,
impl<'a> PartialEq<Any<'a>> for Any<'a>
impl<'a> PartialEq<Any<'a>> for Any<'a>
impl<'a> PartialEq<BmpString<'a>> for BmpString<'a>
impl<'a> PartialEq<BmpString<'a>> for BmpString<'a>
impl<'a> PartialEq<ObjectDescriptor<'a>> for ObjectDescriptor<'a>
impl<'a> PartialEq<ObjectDescriptor<'a>> for ObjectDescriptor<'a>
impl PartialEq<ASN1TimeZone> for ASN1TimeZone
impl PartialEq<ASN1TimeZone> for ASN1TimeZone
impl PartialEq<Error> for Error
impl PartialEq<Error> for Error
impl<'a> PartialEq<PrintableString<'a>> for PrintableString<'a>
impl<'a> PartialEq<PrintableString<'a>> for PrintableString<'a>
impl<'a> PartialEq<Ia5String<'a>> for Ia5String<'a>
impl<'a> PartialEq<Ia5String<'a>> for Ia5String<'a>
impl<'a> PartialEq<Oid<'a>> for Oid<'a>
impl<'a> PartialEq<Oid<'a>> for Oid<'a>
impl<'a> PartialEq<TeletexString<'a>> for TeletexString<'a>
impl<'a> PartialEq<TeletexString<'a>> for TeletexString<'a>
impl<'a> PartialEq<VideotexString<'a>> for VideotexString<'a>
impl<'a> PartialEq<VideotexString<'a>> for VideotexString<'a>
impl<'a> PartialEq<Header<'a>> for Header<'a>
impl<'a> PartialEq<Header<'a>> for Header<'a>
Compare two BER headers. len
fields are compared only if both objects have it set (same for raw_tag
)
impl PartialEq<UtcTime> for UtcTime
impl PartialEq<UtcTime> for UtcTime
impl PartialEq<ASN1DateTime> for ASN1DateTime
impl PartialEq<ASN1DateTime> for ASN1DateTime
impl PartialEq<GeneralizedTime> for GeneralizedTime
impl PartialEq<GeneralizedTime> for GeneralizedTime
impl<'a> PartialEq<NumericString<'a>> for NumericString<'a>
impl<'a> PartialEq<NumericString<'a>> for NumericString<'a>
impl<'a> PartialEq<GeneralString<'a>> for GeneralString<'a>
impl<'a> PartialEq<GeneralString<'a>> for GeneralString<'a>
impl<'a> PartialEq<OctetString<'a>> for OctetString<'a>
impl<'a> PartialEq<OctetString<'a>> for OctetString<'a>
impl PartialEq<Enumerated> for Enumerated
impl PartialEq<Enumerated> for Enumerated
impl<'a> PartialEq<Integer<'a>> for Integer<'a>
impl<'a> PartialEq<Integer<'a>> for Integer<'a>
impl<'a> PartialEq<VisibleString<'a>> for VisibleString<'a>
impl<'a> PartialEq<VisibleString<'a>> for VisibleString<'a>
impl PartialEq<Length> for Length
impl PartialEq<Length> for Length
impl PartialEq<BerClassFromIntError> for BerClassFromIntError
impl PartialEq<BerClassFromIntError> for BerClassFromIntError
impl<'a> PartialEq<PdvIdentification<'a>> for PdvIdentification<'a>
impl<'a> PartialEq<PdvIdentification<'a>> for PdvIdentification<'a>
impl<'a> PartialEq<Utf8String<'a>> for Utf8String<'a>
impl<'a> PartialEq<Utf8String<'a>> for Utf8String<'a>
impl<'a> PartialEq<UniversalString<'a>> for UniversalString<'a>
impl<'a> PartialEq<UniversalString<'a>> for UniversalString<'a>
impl<'a> PartialEq<BitString<'a>> for BitString<'a>
impl<'a> PartialEq<BitString<'a>> for BitString<'a>
impl<'a> PartialEq<Sequence<'a>> for Sequence<'a>
impl<'a> PartialEq<Sequence<'a>> for Sequence<'a>
impl PartialEq<Boolean> for Boolean
impl PartialEq<Boolean> for Boolean
impl<'a> PartialEq<GraphicString<'a>> for GraphicString<'a>
impl<'a> PartialEq<GraphicString<'a>> for GraphicString<'a>
sourceimpl PartialEq<SubsecondDigits> for SubsecondDigits
impl PartialEq<SubsecondDigits> for SubsecondDigits
fn eq(&self, other: &SubsecondDigits) -> bool
sourceimpl<'a> PartialEq<FormatItem<'a>> for FormatItem<'a>
impl<'a> PartialEq<FormatItem<'a>> for FormatItem<'a>
fn eq(&self, other: &FormatItem<'a>) -> bool
fn ne(&self, other: &FormatItem<'a>) -> bool
sourceimpl PartialEq<PrimitiveDateTime> for PrimitiveDateTime
impl PartialEq<PrimitiveDateTime> for PrimitiveDateTime
fn eq(&self, other: &PrimitiveDateTime) -> bool
fn ne(&self, other: &PrimitiveDateTime) -> bool
sourceimpl PartialEq<OffsetDateTime> for SystemTime
Available on crate feature std
only.
impl PartialEq<OffsetDateTime> for SystemTime
std
only.fn eq(&self, rhs: &OffsetDateTime) -> bool
sourceimpl PartialEq<WeekNumberRepr> for WeekNumberRepr
impl PartialEq<WeekNumberRepr> for WeekNumberRepr
fn eq(&self, other: &WeekNumberRepr) -> bool
sourceimpl PartialEq<ParseFromDescription> for ParseFromDescription
impl PartialEq<ParseFromDescription> for ParseFromDescription
fn eq(&self, other: &ParseFromDescription) -> bool
fn ne(&self, other: &ParseFromDescription) -> bool
sourceimpl PartialEq<WeekdayRepr> for WeekdayRepr
impl PartialEq<WeekdayRepr> for WeekdayRepr
fn eq(&self, other: &WeekdayRepr) -> bool
sourceimpl PartialEq<ConversionRange> for ConversionRange
impl PartialEq<ConversionRange> for ConversionRange
fn eq(&self, other: &ConversionRange) -> bool
sourceimpl PartialEq<OffsetMinute> for OffsetMinute
impl PartialEq<OffsetMinute> for OffsetMinute
fn eq(&self, other: &OffsetMinute) -> bool
fn ne(&self, other: &OffsetMinute) -> bool
sourceimpl<'_> PartialEq<FormatItem<'_>> for Component
impl<'_> PartialEq<FormatItem<'_>> for Component
fn eq(&self, rhs: &FormatItem<'_>) -> bool
sourceimpl<'_, '_, '_> PartialEq<FormatItem<'_>> for &'_ [FormatItem<'_>]
impl<'_, '_, '_> PartialEq<FormatItem<'_>> for &'_ [FormatItem<'_>]
fn eq(&self, rhs: &FormatItem<'_>) -> bool
sourceimpl PartialEq<OffsetSecond> for OffsetSecond
impl PartialEq<OffsetSecond> for OffsetSecond
fn eq(&self, other: &OffsetSecond) -> bool
fn ne(&self, other: &OffsetSecond) -> bool
sourceimpl PartialEq<DifferentVariant> for DifferentVariant
impl PartialEq<DifferentVariant> for DifferentVariant
fn eq(&self, other: &DifferentVariant) -> bool
sourceimpl PartialEq<InvalidFormatDescription> for InvalidFormatDescription
impl PartialEq<InvalidFormatDescription> for InvalidFormatDescription
fn eq(&self, other: &InvalidFormatDescription) -> bool
fn ne(&self, other: &InvalidFormatDescription) -> bool
sourceimpl PartialEq<OffsetHour> for OffsetHour
impl PartialEq<OffsetHour> for OffsetHour
fn eq(&self, other: &OffsetHour) -> bool
fn ne(&self, other: &OffsetHour) -> bool
sourceimpl PartialEq<InvalidVariant> for InvalidVariant
impl PartialEq<InvalidVariant> for InvalidVariant
fn eq(&self, other: &InvalidVariant) -> bool
sourceimpl<'_, '_, '_> PartialEq<&'_ [FormatItem<'_>]> for FormatItem<'_>
impl<'_, '_, '_> PartialEq<&'_ [FormatItem<'_>]> for FormatItem<'_>
sourceimpl PartialEq<ComponentRange> for ComponentRange
impl PartialEq<ComponentRange> for ComponentRange
fn eq(&self, other: &ComponentRange) -> bool
fn ne(&self, other: &ComponentRange) -> bool
sourceimpl PartialEq<TryFromParsed> for TryFromParsed
impl PartialEq<TryFromParsed> for TryFromParsed
fn eq(&self, other: &TryFromParsed) -> bool
fn ne(&self, other: &TryFromParsed) -> bool
sourceimpl PartialEq<WeekNumber> for WeekNumber
impl PartialEq<WeekNumber> for WeekNumber
fn eq(&self, other: &WeekNumber) -> bool
fn ne(&self, other: &WeekNumber) -> bool
impl PartialEq<Needed> for Needed
impl PartialEq<Needed> for Needed
impl PartialEq<VerboseErrorKind> for VerboseErrorKind
impl PartialEq<VerboseErrorKind> for VerboseErrorKind
sourceimpl<T> PartialEq<TryFromBigIntError<T>> for TryFromBigIntError<T> where
T: PartialEq<T>,
impl<T> PartialEq<TryFromBigIntError<T>> for TryFromBigIntError<T> where
T: PartialEq<T>,
fn eq(&self, other: &TryFromBigIntError<T>) -> bool
fn ne(&self, other: &TryFromBigIntError<T>) -> bool
sourceimpl PartialEq<ParseBigIntError> for ParseBigIntError
impl PartialEq<ParseBigIntError> for ParseBigIntError
fn eq(&self, other: &ParseBigIntError) -> bool
fn ne(&self, other: &ParseBigIntError) -> bool
sourceimpl<A> PartialEq<ExtendedGcd<A>> for ExtendedGcd<A> where
A: PartialEq<A>,
impl<A> PartialEq<ExtendedGcd<A>> for ExtendedGcd<A> where
A: PartialEq<A>,
fn eq(&self, other: &ExtendedGcd<A>) -> bool
fn ne(&self, other: &ExtendedGcd<A>) -> bool
impl PartialEq<Encoding> for Encoding
impl PartialEq<Encoding> for Encoding
impl PartialEq<DecodePartial> for DecodePartial
impl PartialEq<DecodePartial> for DecodePartial
impl PartialEq<DecodeError> for DecodeError
impl PartialEq<DecodeError> for DecodeError
sourceimpl PartialEq<DecodeError> for DecodeError
impl PartialEq<DecodeError> for DecodeError
fn eq(&self, other: &DecodeError) -> bool
fn ne(&self, other: &DecodeError) -> bool
sourceimpl PartialEq<StatusCode> for u16
impl PartialEq<StatusCode> for u16
fn eq(&self, other: &StatusCode) -> bool
sourceimpl PartialEq<HeaderValue> for str
impl PartialEq<HeaderValue> for str
fn eq(&self, other: &HeaderValue) -> bool
sourceimpl<'a> PartialEq<HeaderValue> for &'a str
impl<'a> PartialEq<HeaderValue> for &'a str
fn eq(&self, other: &HeaderValue) -> bool
sourceimpl PartialEq<HeaderValue> for String
impl PartialEq<HeaderValue> for String
fn eq(&self, other: &HeaderValue) -> bool
sourceimpl<'a> PartialEq<PathAndQuery> for &'a str
impl<'a> PartialEq<PathAndQuery> for &'a str
fn eq(&self, other: &PathAndQuery) -> bool
sourceimpl PartialEq<HeaderValue> for [u8]
impl PartialEq<HeaderValue> for [u8]
fn eq(&self, other: &HeaderValue) -> bool
sourceimpl PartialEq<PathAndQuery> for str
impl PartialEq<PathAndQuery> for str
fn eq(&self, other: &PathAndQuery) -> bool
sourceimpl<'a> PartialEq<HeaderName> for &'a str
impl<'a> PartialEq<HeaderName> for &'a str
sourcefn eq(&self, other: &HeaderName) -> bool
fn eq(&self, other: &HeaderName) -> bool
Performs a case-insensitive comparison of the string against the header name
sourceimpl PartialEq<PathAndQuery> for String
impl PartialEq<PathAndQuery> for String
fn eq(&self, other: &PathAndQuery) -> bool
sourceimpl PartialEq<HeaderName> for str
impl PartialEq<HeaderName> for str
sourcefn eq(&self, other: &HeaderName) -> bool
fn eq(&self, other: &HeaderName) -> bool
Performs a case-insensitive comparison of the string against the header name
Examples
use http::header::CONTENT_LENGTH;
assert_eq!(CONTENT_LENGTH, "content-length");
assert_eq!(CONTENT_LENGTH, "Content-Length");
assert_ne!(CONTENT_LENGTH, "content length");
impl PartialEq<AnyDelimiterCodec> for AnyDelimiterCodec
impl PartialEq<AnyDelimiterCodec> for AnyDelimiterCodec
impl PartialEq<BytesCodec> for BytesCodec
impl PartialEq<BytesCodec> for BytesCodec
impl PartialEq<LinesCodec> for LinesCodec
impl PartialEq<LinesCodec> for LinesCodec
sourceimpl PartialEq<Identifier> for Identifier
impl PartialEq<Identifier> for Identifier
fn eq(&self, other: &Identifier) -> bool
sourceimpl PartialEq<LevelFilter> for LevelFilter
impl PartialEq<LevelFilter> for LevelFilter
fn eq(&self, other: &LevelFilter) -> bool
fn ne(&self, other: &LevelFilter) -> bool
sourceimpl PartialEq<LevelFilter> for Level
impl PartialEq<LevelFilter> for Level
fn eq(&self, other: &LevelFilter) -> bool
sourceimpl<K, V1, S1, V2, S2> PartialEq<IndexMap<K, V2, S2>> for IndexMap<K, V1, S1> where
K: Hash + Eq,
V1: PartialEq<V2>,
S1: BuildHasher,
S2: BuildHasher,
impl<K, V1, S1, V2, S2> PartialEq<IndexMap<K, V2, S2>> for IndexMap<K, V1, S1> where
K: Hash + Eq,
V1: PartialEq<V2>,
S1: BuildHasher,
S2: BuildHasher,
sourceimpl<T, S1, S2> PartialEq<IndexSet<T, S2>> for IndexSet<T, S1> where
T: Hash + Eq,
S1: BuildHasher,
S2: BuildHasher,
impl<T, S1, S2> PartialEq<IndexSet<T, S2>> for IndexSet<T, S1> where
T: Hash + Eq,
S1: BuildHasher,
S2: BuildHasher,
impl<K, V, S, A> PartialEq<HashMap<K, V, S, A>> for HashMap<K, V, S, A> where
K: Eq + Hash,
V: PartialEq<V>,
S: BuildHasher,
A: Allocator + Clone,
impl<K, V, S, A> PartialEq<HashMap<K, V, S, A>> for HashMap<K, V, S, A> where
K: Eq + Hash,
V: PartialEq<V>,
S: BuildHasher,
A: Allocator + Clone,
impl PartialEq<TryReserveError> for TryReserveError
impl PartialEq<TryReserveError> for TryReserveError
impl<T, S, A> PartialEq<HashSet<T, S, A>> for HashSet<T, S, A> where
T: Eq + Hash,
S: BuildHasher,
A: Allocator + Clone,
impl<T, S, A> PartialEq<HashSet<T, S, A>> for HashSet<T, S, A> where
T: Eq + Hash,
S: BuildHasher,
A: Allocator + Clone,
sourceimpl PartialEq<FlushCompress> for FlushCompress
impl PartialEq<FlushCompress> for FlushCompress
fn eq(&self, other: &FlushCompress) -> bool
sourceimpl PartialEq<Compression> for Compression
impl PartialEq<Compression> for Compression
fn eq(&self, other: &Compression) -> bool
fn ne(&self, other: &Compression) -> bool
sourceimpl PartialEq<FlushDecompress> for FlushDecompress
impl PartialEq<FlushDecompress> for FlushDecompress
fn eq(&self, other: &FlushDecompress) -> bool
impl PartialEq<CompressionStrategy> for CompressionStrategy
impl PartialEq<CompressionStrategy> for CompressionStrategy
impl PartialEq<StreamResult> for StreamResult
impl PartialEq<StreamResult> for StreamResult
sourceimpl<Specialization, Alloc> PartialEq<AdvHasher<Specialization, Alloc>> for AdvHasher<Specialization, Alloc> where
Specialization: AdvHashSpecialization + Clone,
Alloc: Allocator<u16> + Allocator<u32>,
impl<Specialization, Alloc> PartialEq<AdvHasher<Specialization, Alloc>> for AdvHasher<Specialization, Alloc> where
Specialization: AdvHashSpecialization + Clone,
Alloc: Allocator<u16> + Allocator<u32>,
sourceimpl PartialEq<BrotliEncoderStreamState> for BrotliEncoderStreamState
impl PartialEq<BrotliEncoderStreamState> for BrotliEncoderStreamState
fn eq(&self, other: &BrotliEncoderStreamState) -> bool
sourceimpl<AllocU32> PartialEq<H10Buckets<AllocU32>> for H10Buckets<AllocU32> where
AllocU32: Allocator<u32>,
impl<AllocU32> PartialEq<H10Buckets<AllocU32>> for H10Buckets<AllocU32> where
AllocU32: Allocator<u32>,
fn eq(&self, other: &H10Buckets<AllocU32>) -> bool
sourceimpl PartialEq<BroCatliResult> for BroCatliResult
impl PartialEq<BroCatliResult> for BroCatliResult
fn eq(&self, other: &BroCatliResult) -> bool
sourceimpl<AllocU32, Buckets, Params> PartialEq<H10<AllocU32, Buckets, Params>> for H10<AllocU32, Buckets, Params> where
AllocU32: Allocator<u32>,
Buckets: Allocable<u32, AllocU32> + SliceWrapperMut<u32> + SliceWrapper<u32> + PartialEq<Buckets>,
Params: H10Params,
impl<AllocU32, Buckets, Params> PartialEq<H10<AllocU32, Buckets, Params>> for H10<AllocU32, Buckets, Params> where
AllocU32: Allocator<u32>,
Buckets: Allocable<u32, AllocU32> + SliceWrapperMut<u32> + SliceWrapper<u32> + PartialEq<Buckets>,
Params: H10Params,
sourceimpl PartialEq<BrotliEncoderMode> for BrotliEncoderMode
impl PartialEq<BrotliEncoderMode> for BrotliEncoderMode
fn eq(&self, other: &BrotliEncoderMode) -> bool
sourceimpl PartialEq<BrotliHasherParams> for BrotliHasherParams
impl PartialEq<BrotliHasherParams> for BrotliHasherParams
fn eq(&self, other: &BrotliHasherParams) -> bool
fn ne(&self, other: &BrotliHasherParams) -> bool
sourceimpl PartialEq<BrotliEncoderOperation> for BrotliEncoderOperation
impl PartialEq<BrotliEncoderOperation> for BrotliEncoderOperation
fn eq(&self, other: &BrotliEncoderOperation) -> bool
sourceimpl PartialEq<BrotliEncoderParameter> for BrotliEncoderParameter
impl PartialEq<BrotliEncoderParameter> for BrotliEncoderParameter
fn eq(&self, other: &BrotliEncoderParameter) -> bool
sourceimpl<A> PartialEq<BasicHasher<A>> for BasicHasher<A> where
A: SliceWrapperMut<u32> + SliceWrapper<u32> + BasicHashComputer,
impl<A> PartialEq<BasicHasher<A>> for BasicHasher<A> where
A: SliceWrapperMut<u32> + SliceWrapper<u32> + BasicHashComputer,
fn eq(&self, other: &BasicHasher<A>) -> bool
sourceimpl<Alloc> PartialEq<UnionHasher<Alloc>> for UnionHasher<Alloc> where
Alloc: Allocator<u16> + Allocator<u32>,
impl<Alloc> PartialEq<UnionHasher<Alloc>> for UnionHasher<Alloc> where
Alloc: Allocator<u16> + Allocator<u32>,
fn eq(&self, other: &UnionHasher<Alloc>) -> bool
sourceimpl PartialEq<CodeBlockState> for CodeBlockState
impl PartialEq<CodeBlockState> for CodeBlockState
fn eq(&self, other: &CodeBlockState) -> bool
sourceimpl PartialEq<LiteralPredictionModeNibble> for LiteralPredictionModeNibble
impl PartialEq<LiteralPredictionModeNibble> for LiteralPredictionModeNibble
fn eq(&self, other: &LiteralPredictionModeNibble) -> bool
fn ne(&self, other: &LiteralPredictionModeNibble) -> bool
impl PartialEq<HuffmanCode> for HuffmanCode
impl PartialEq<HuffmanCode> for HuffmanCode
Implementors
impl PartialEq<CachePreferenceError> for CachePreferenceError
impl PartialEq<ClientCachePreference> for ClientCachePreference
impl PartialEq<CompressPreference> for CompressPreference
impl PartialEq<PreferredCompression> for PreferredCompression
impl PartialEq<ServerCachePreference> for ServerCachePreference
impl PartialEq<UriKey> for UriKey
impl PartialEq<Value> for Value
impl PartialEq<BindIpVersion> for BindIpVersion
impl PartialEq<CacheAction> for CacheAction
impl PartialEq<Action> for Action
impl PartialEq<IpAddr> for IpAddr
impl PartialEq<IpAddr> for Ipv4Addr
impl PartialEq<IpAddr> for Ipv6Addr
impl PartialEq<SanitizeError> for SanitizeError
impl PartialEq<SocketAddr> for SocketAddr
impl PartialEq<ErrorKind> for kvarn::prelude::io::ErrorKind
impl PartialEq<SeekFrom> for SeekFrom
impl PartialEq<Ipv6MulticastScope> for Ipv6MulticastScope
impl PartialEq<Shutdown> for Shutdown
impl PartialEq<CacheControlError> for CacheControlError
impl PartialEq<RequestParseStage> for RequestParseStage
impl PartialEq<SearchStep> for SearchStep
impl PartialEq<Ordering> for kvarn::prelude::threading::Ordering
impl PartialEq<Ordering> for kvarn::prelude::cmp::Ordering
impl PartialEq<[u8]> for Bytes
impl PartialEq<[u8]> for BytesMut
impl PartialEq<[u8]> for HeaderValue
impl PartialEq<str> for Bytes
impl PartialEq<str> for BytesMut
impl PartialEq<str> for HeaderName
impl PartialEq<str> for HeaderValue
impl PartialEq<str> for Method
impl PartialEq<str> for Uri
impl PartialEq<str> for Authority
Case-insensitive equality
Examples
let authority: Authority = "HELLO.com".parse().unwrap();
assert_eq!(authority, "hello.coM");
assert_eq!("hello.com", authority);
impl PartialEq<str> for PathAndQuery
impl PartialEq<str> for Scheme
Case-insensitive equality
Examples
let scheme: Scheme = "HTTP".parse().unwrap();
assert_eq!(scheme, *"http");
impl PartialEq<u16> for StatusCode
impl PartialEq<PathQuery> for PathQuery
impl PartialEq<Id> for kvarn::extensions::Id
impl PartialEq<OffsetDateTime> for OffsetDateTime
impl PartialEq<Error> for kvarn::prelude::fmt::Error
impl PartialEq<Mime> for Mime
impl PartialEq<AddrParseError> for AddrParseError
impl PartialEq<Ipv4Addr> for IpAddr
impl PartialEq<Ipv4Addr> for Ipv4Addr
impl PartialEq<Ipv6Addr> for IpAddr
impl PartialEq<Ipv6Addr> for Ipv6Addr
impl PartialEq<SocketAddrV4> for SocketAddrV4
impl PartialEq<SocketAddrV6> for SocketAddrV6
impl PartialEq<CriticalRequestComponents> for CriticalRequestComponents
impl PartialEq<ParseBoolError> for ParseBoolError
impl PartialEq<Utf8Error> for Utf8Error
impl PartialEq<Bytes> for Bytes
impl PartialEq<Bytes> for BytesMut
impl PartialEq<BytesMut> for Bytes
impl PartialEq<BytesMut> for BytesMut
impl PartialEq<Duration> for kvarn::prelude::Duration
impl PartialEq<HeaderName> for HeaderName
impl PartialEq<HeaderValue> for HeaderValue
impl PartialEq<Instant> for kvarn::prelude::Instant
impl PartialEq<Method> for Method
impl PartialEq<Path> for Path
impl PartialEq<PathBuf> for PathBuf
impl PartialEq<StatusCode> for StatusCode
impl PartialEq<Uri> for Uri
impl PartialEq<Version> for Version
impl PartialEq<Authority> for Authority
impl PartialEq<PathAndQuery> for PathAndQuery
impl PartialEq<Scheme> for Scheme
impl PartialEq<String> for Bytes
impl PartialEq<String> for BytesMut
impl PartialEq<String> for HeaderValue
impl PartialEq<String> for Authority
impl PartialEq<String> for PathAndQuery
impl PartialEq<Vec<u8, Global>> for Bytes
impl PartialEq<Vec<u8, Global>> for BytesMut
impl PartialEq<SystemTime> for OffsetDateTime
std
only.