Trait ockam_core::lib::cmp::PartialEq 1.0.0[−][src]
pub trait PartialEq<Rhs = Self> where
Rhs: ?Sized, { #[must_use] fn eq(&self, other: &Rhs) -> bool; #[must_use] fn ne(&self, other: &Rhs) -> bool { ... } }
Expand description
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
Provided methods
Implementations on Foreign Types
impl PartialEq<RawWakerVTable> for RawWakerVTable
[src]
impl PartialEq<RawWakerVTable> for RawWakerVTable
[src]pub fn eq(&self, other: &RawWakerVTable) -> bool
[src]
pub fn ne(&self, other: &RawWakerVTable) -> 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<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, 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> 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<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, 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, 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, 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, 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> 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> 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> 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> 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<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<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<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<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<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<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, 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 PartialEq<AllocError> for AllocError
[src]
impl PartialEq<AllocError> for AllocError
[src]pub fn eq(&self, other: &AllocError) -> bool
[src]
impl<Ret, A, B, C, D, E, F> PartialEq<unsafe fn(A, B, C, D, E, F) -> Ret> for unsafe fn(A, B, C, D, E, F) -> Ret
[src]
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<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]
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]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, 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, 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>,
A: PartialEq<A>,
E: PartialEq<E>,
B: PartialEq<B>,
F: PartialEq<F>,
I: PartialEq<I>,
H: PartialEq<H>,
D: PartialEq<D>,
G: PartialEq<G>,
J: PartialEq<J> + ?Sized,
[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>,
A: PartialEq<A>,
E: PartialEq<E>,
B: PartialEq<B>,
F: PartialEq<F>,
I: PartialEq<I>,
H: PartialEq<H>,
D: PartialEq<D>,
G: PartialEq<G>,
J: PartialEq<J> + ?Sized,
[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> 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> PartialEq<extern "C" fn(A, B, C, D, ...) -> Ret> for extern "C" fn(A, B, C, D, ...) -> 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<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> 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> 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<fn(A, B, C, D, E, F, G, H) -> Ret> for fn(A, B, C, D, E, F, G, H) -> Ret
[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>,
A: PartialEq<A>,
E: PartialEq<E>,
B: PartialEq<B>,
F: PartialEq<F>,
D: PartialEq<D>,
G: PartialEq<G> + ?Sized,
[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>,
A: PartialEq<A>,
E: PartialEq<E>,
B: PartialEq<B>,
F: PartialEq<F>,
D: PartialEq<D>,
G: PartialEq<G> + ?Sized,
[src]impl<H> PartialEq<BuildHasherDefault<H>> for BuildHasherDefault<H>
[src]
impl<H> PartialEq<BuildHasherDefault<H>> for BuildHasherDefault<H>
[src]pub fn eq(&self, _other: &BuildHasherDefault<H>) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret
[src]
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 PartialEq<CpuidResult> for CpuidResult
[src]
impl PartialEq<CpuidResult> for CpuidResult
[src]pub fn eq(&self, other: &CpuidResult) -> bool
[src]
pub fn ne(&self, other: &CpuidResult) -> bool
[src]
impl<Dyn> PartialEq<DynMetadata<Dyn>> for DynMetadata<Dyn> where
Dyn: ?Sized,
[src]
impl<Dyn> PartialEq<DynMetadata<Dyn>> for DynMetadata<Dyn> where
Dyn: ?Sized,
[src]pub fn eq(&self, other: &DynMetadata<Dyn>) -> 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<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<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 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> PartialEq<unsafe extern "C" fn(A, B) -> Ret> for unsafe extern "C" fn(A, B) -> Ret
[src]
impl<Ret, A, B> PartialEq<unsafe extern "C" fn(A, B) -> Ret> for unsafe extern "C" fn(A, B) -> Ret
[src]impl<Idx> PartialEq<RangeInclusive<Idx>> for RangeInclusive<Idx> where
Idx: PartialEq<Idx>,
[src]
impl<Idx> PartialEq<RangeInclusive<Idx>> for RangeInclusive<Idx> where
Idx: PartialEq<Idx>,
[src]pub fn eq(&self, other: &RangeInclusive<Idx>) -> bool
[src]
pub fn ne(&self, other: &RangeInclusive<Idx>) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
[src]
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]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<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<Ret, A> PartialEq<unsafe extern "C" fn(A, ...) -> Ret> for unsafe extern "C" fn(A, ...) -> 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> PartialEq<extern "C" fn(A, B, C, ...) -> Ret> for extern "C" fn(A, B, C, ...) -> 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<Idx> PartialEq<RangeToInclusive<Idx>> for RangeToInclusive<Idx> where
Idx: PartialEq<Idx>,
[src]
impl<Idx> PartialEq<RangeToInclusive<Idx>> for RangeToInclusive<Idx> where
Idx: PartialEq<Idx>,
[src]pub fn eq(&self, other: &RangeToInclusive<Idx>) -> bool
[src]
pub fn ne(&self, other: &RangeToInclusive<Idx>) -> bool
[src]
impl<Ret, A, B, C, D, E, F> PartialEq<extern "C" fn(A, B, C, D, E, F) -> Ret> for extern "C" fn(A, B, C, D, E, F) -> Ret
[src]
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<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<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<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, 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> PartialEq<unsafe extern "C" fn(A, B, C, ...) -> Ret> for unsafe extern "C" fn(A, B, C, ...) -> Ret
[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, 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<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<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, 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, 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<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<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]
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]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<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<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> 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<Y, R> PartialEq<GeneratorState<Y, R>> for GeneratorState<Y, R> where
R: PartialEq<R>,
Y: PartialEq<Y>,
[src]
impl<Y, R> PartialEq<GeneratorState<Y, R>> for GeneratorState<Y, R> where
R: PartialEq<R>,
Y: PartialEq<Y>,
[src]pub fn eq(&self, other: &GeneratorState<Y, R>) -> bool
[src]
pub fn ne(&self, other: &GeneratorState<Y, R>) -> bool
[src]
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, 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 PartialEq<LayoutError> for LayoutError
[src]
impl PartialEq<LayoutError> for LayoutError
[src]pub fn eq(&self, other: &LayoutError) -> bool
[src]
pub fn ne(&self, other: &LayoutError) -> bool
[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]
impl<P, Q> PartialEq<Pin<Q>> for Pin<P> where
P: Deref,
Q: Deref,
<P as Deref>::Target: PartialEq<<Q as Deref>::Target>,
[src]impl PartialEq<CharTryFromError> for CharTryFromError
[src]
impl PartialEq<CharTryFromError> for CharTryFromError
[src]pub fn eq(&self, other: &CharTryFromError) -> bool
[src]
pub fn ne(&self, other: &CharTryFromError) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialEq<unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
[src]
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<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, 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<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>,
A: PartialEq<A>,
E: PartialEq<E>,
K: PartialEq<K>,
B: PartialEq<B>,
F: PartialEq<F>,
I: PartialEq<I>,
H: PartialEq<H>,
D: PartialEq<D>,
G: PartialEq<G>,
J: PartialEq<J>,
L: PartialEq<L> + ?Sized,
[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>,
A: PartialEq<A>,
E: PartialEq<E>,
K: PartialEq<K>,
B: PartialEq<B>,
F: PartialEq<F>,
I: PartialEq<I>,
H: PartialEq<H>,
D: PartialEq<D>,
G: PartialEq<G>,
J: PartialEq<J>,
L: PartialEq<L> + ?Sized,
[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 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> PartialEq<unsafe extern "C" fn(A, B, C, D) -> Ret> for unsafe extern "C" fn(A, B, C, D) -> 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 PartialEq<DecodeUtf16Error> for DecodeUtf16Error
[src]
impl PartialEq<DecodeUtf16Error> for DecodeUtf16Error
[src]pub fn eq(&self, other: &DecodeUtf16Error) -> bool
[src]
pub fn ne(&self, other: &DecodeUtf16Error) -> bool
[src]
impl<Ret, 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<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<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, 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, 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]
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]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<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<B, C> PartialEq<ControlFlow<B, C>> for ControlFlow<B, C> where
C: PartialEq<C>,
B: PartialEq<B>,
[src]
impl<B, C> PartialEq<ControlFlow<B, C>> for ControlFlow<B, C> where
C: PartialEq<C>,
B: PartialEq<B>,
[src]pub fn eq(&self, other: &ControlFlow<B, C>) -> bool
[src]
pub fn ne(&self, other: &ControlFlow<B, C>) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret
[src]
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, C> PartialEq<(A, B, C)> for (A, B, C) where
C: PartialEq<C> + ?Sized,
A: PartialEq<A>,
B: PartialEq<B>,
[src]
impl<A, B, C> PartialEq<(A, B, C)> for (A, B, C) where
C: PartialEq<C> + ?Sized,
A: PartialEq<A>,
B: PartialEq<B>,
[src]impl<'_, '_, A, B> PartialEq<&'_ mut B> for &'_ mut A where
A: PartialEq<B> + ?Sized,
B: ?Sized,
[src]
impl<'_, '_, A, B> PartialEq<&'_ mut B> for &'_ mut A where
A: PartialEq<B> + ?Sized,
B: ?Sized,
[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, 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<extern "C" fn(A, B, C, D, E, F, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, ...) -> 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<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>,
A: PartialEq<A>,
E: PartialEq<E>,
B: PartialEq<B>,
F: PartialEq<F>,
H: PartialEq<H> + ?Sized,
D: PartialEq<D>,
G: PartialEq<G>,
[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>,
A: PartialEq<A>,
E: PartialEq<E>,
B: PartialEq<B>,
F: PartialEq<F>,
H: PartialEq<H> + ?Sized,
D: PartialEq<D>,
G: PartialEq<G>,
[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>,
A: PartialEq<A>,
E: PartialEq<E>,
K: PartialEq<K> + ?Sized,
B: PartialEq<B>,
F: PartialEq<F>,
I: PartialEq<I>,
H: PartialEq<H>,
D: PartialEq<D>,
G: PartialEq<G>,
J: PartialEq<J>,
[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>,
A: PartialEq<A>,
E: PartialEq<E>,
K: PartialEq<K> + ?Sized,
B: PartialEq<B>,
F: PartialEq<F>,
I: PartialEq<I>,
H: PartialEq<H>,
D: PartialEq<D>,
G: PartialEq<G>,
J: PartialEq<J>,
[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> 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> 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, 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<A, B, C, D, E> PartialEq<(A, B, C, D, E)> for (A, B, C, D, E) where
C: PartialEq<C>,
A: PartialEq<A>,
E: PartialEq<E> + ?Sized,
B: PartialEq<B>,
D: PartialEq<D>,
[src]
impl<A, B, C, D, E> PartialEq<(A, B, C, D, E)> for (A, B, C, D, E) where
C: PartialEq<C>,
A: PartialEq<A>,
E: PartialEq<E> + ?Sized,
B: PartialEq<B>,
D: PartialEq<D>,
[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<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, 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>,
A: PartialEq<A>,
E: PartialEq<E>,
B: PartialEq<B>,
F: PartialEq<F>,
I: PartialEq<I> + ?Sized,
H: PartialEq<H>,
D: PartialEq<D>,
G: PartialEq<G>,
[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>,
A: PartialEq<A>,
E: PartialEq<E>,
B: PartialEq<B>,
F: PartialEq<F>,
I: PartialEq<I> + ?Sized,
H: PartialEq<H>,
D: PartialEq<D>,
G: PartialEq<G>,
[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, 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<'a> PartialEq<Utf8LossyChunk<'a>> for Utf8LossyChunk<'a>
[src]
impl<'a> PartialEq<Utf8LossyChunk<'a>> for Utf8LossyChunk<'a>
[src]pub fn eq(&self, other: &Utf8LossyChunk<'a>) -> bool
[src]
pub fn ne(&self, other: &Utf8LossyChunk<'a>) -> bool
[src]
impl PartialEq<ParseCharError> for ParseCharError
[src]
impl PartialEq<ParseCharError> for ParseCharError
[src]pub fn eq(&self, other: &ParseCharError) -> bool
[src]
pub fn ne(&self, other: &ParseCharError) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G> PartialEq<extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret
[src]
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, 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, 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, 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> 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> PartialEq<unsafe extern "C" fn(A, B, ...) -> Ret> for unsafe extern "C" fn(A, B, ...) -> Ret
[src]
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, 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<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<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]
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]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>,
A: PartialEq<A>,
E: PartialEq<E>,
B: PartialEq<B>,
F: PartialEq<F> + ?Sized,
D: PartialEq<D>,
[src]
impl<A, B, C, D, E, F> PartialEq<(A, B, C, D, E, F)> for (A, B, C, D, E, F) where
C: PartialEq<C>,
A: PartialEq<A>,
E: PartialEq<E>,
B: PartialEq<B>,
F: PartialEq<F> + ?Sized,
D: PartialEq<D>,
[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> PartialEq<unsafe extern "C" fn(A, B, C) -> Ret> for unsafe extern "C" fn(A, B, C) -> Ret
[src]impl<'a> PartialEq<Components<'a>> for Components<'a>
[src]
impl<'a> PartialEq<Components<'a>> for Components<'a>
[src]pub fn eq(&self, other: &Components<'a>) -> bool
[src]
impl PartialEq<StripPrefixError> for StripPrefixError
[src]
impl PartialEq<StripPrefixError> for StripPrefixError
[src]pub fn eq(&self, other: &StripPrefixError) -> bool
[src]
pub fn ne(&self, other: &StripPrefixError) -> bool
[src]
impl PartialEq<ExitStatus> for ExitStatus
[src]
impl PartialEq<ExitStatus> for ExitStatus
[src]impl PartialEq<Permissions> for Permissions
[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<AccessError> for AccessError
[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<TryRecvError> for TryRecvError
[src]
impl PartialEq<TryRecvError> for TryRecvError
[src]pub fn eq(&self, other: &TryRecvError) -> bool
[src]
impl PartialEq<FromVecWithNulError> for FromVecWithNulError
[src]
impl PartialEq<FromVecWithNulError> for FromVecWithNulError
[src]pub fn eq(&self, other: &FromVecWithNulError) -> bool
[src]
pub fn ne(&self, other: &FromVecWithNulError) -> bool
[src]
impl PartialEq<BacktraceStatus> for BacktraceStatus
[src]
impl PartialEq<BacktraceStatus> for BacktraceStatus
[src]pub fn eq(&self, other: &BacktraceStatus) -> bool
[src]
impl<K, V, S> PartialEq<HashMap<K, V, S>> for HashMap<K, V, S> where
S: BuildHasher,
K: Eq + Hash,
V: PartialEq<V>,
[src]
impl<K, V, S> PartialEq<HashMap<K, V, S>> for HashMap<K, V, S> where
S: BuildHasher,
K: Eq + Hash,
V: PartialEq<V>,
[src]impl<'a> PartialEq<PrefixComponent<'a>> for PrefixComponent<'a>
[src]
impl<'a> PartialEq<PrefixComponent<'a>> for PrefixComponent<'a>
[src]pub fn eq(&self, other: &PrefixComponent<'a>) -> bool
[src]
impl PartialEq<IntoStringError> for IntoStringError
[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<ExitStatusError> for ExitStatusError
[src]
impl PartialEq<ExitStatusError> for ExitStatusError
[src]pub fn eq(&self, other: &ExitStatusError) -> bool
[src]
pub fn ne(&self, other: &ExitStatusError) -> bool
[src]
impl PartialEq<FromBytesWithNulError> for FromBytesWithNulError
[src]
impl PartialEq<FromBytesWithNulError> for FromBytesWithNulError
[src]pub fn eq(&self, other: &FromBytesWithNulError) -> bool
[src]
pub fn ne(&self, other: &FromBytesWithNulError) -> bool
[src]
impl<T> PartialEq<SyncOnceCell<T>> for SyncOnceCell<T> where
T: PartialEq<T>,
[src]
impl<T> PartialEq<SyncOnceCell<T>> for SyncOnceCell<T> where
T: PartialEq<T>,
[src]pub fn eq(&self, other: &SyncOnceCell<T>) -> bool
[src]
impl PartialEq<WaitTimeoutResult> for WaitTimeoutResult
[src]
impl PartialEq<WaitTimeoutResult> for WaitTimeoutResult
[src]pub fn eq(&self, other: &WaitTimeoutResult) -> bool
[src]
pub fn ne(&self, other: &WaitTimeoutResult) -> bool
[src]
impl<T> PartialEq<TrySendError<T>> for TrySendError<T> where
T: PartialEq<T>,
[src]
impl<T> PartialEq<TrySendError<T>> for TrySendError<T> where
T: PartialEq<T>,
[src]pub fn eq(&self, other: &TrySendError<T>) -> bool
[src]
pub fn ne(&self, other: &TrySendError<T>) -> bool
[src]
impl PartialEq<SystemTime> for SystemTime
[src]
impl PartialEq<SystemTime> for SystemTime
[src]impl PartialEq<RecvTimeoutError> for RecvTimeoutError
[src]
impl PartialEq<RecvTimeoutError> for RecvTimeoutError
[src]pub fn eq(&self, other: &RecvTimeoutError) -> bool
[src]
impl PartialEq<TryReserveError> for TryReserveError
[src]
impl PartialEq<TryReserveError> for TryReserveError
[src]pub fn eq(&self, other: &TryReserveError) -> bool
[src]
pub fn ne(&self, other: &TryReserveError) -> bool
[src]
impl<T> PartialEq<Arc<T>> for Arc<T> where
T: PartialEq<T> + ?Sized,
[src]
impl<T> PartialEq<Arc<T>> for Arc<T> where
T: PartialEq<T> + ?Sized,
[src]pub fn eq(&self, other: &Arc<T>) -> bool
[src]
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]
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 PartialEq<FromUtf8Error> for FromUtf8Error
[src]
impl PartialEq<FromUtf8Error> for FromUtf8Error
[src]pub fn eq(&self, other: &FromUtf8Error) -> bool
[src]
pub fn ne(&self, other: &FromUtf8Error) -> bool
[src]
impl<T> PartialEq<Rc<T>> for Rc<T> where
T: PartialEq<T> + ?Sized,
[src]
impl<T> PartialEq<Rc<T>> for Rc<T> where
T: PartialEq<T> + ?Sized,
[src]pub fn eq(&self, other: &Rc<T>) -> bool
[src]
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]
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 PartialEq<_Unwind_Reason_Code> for _Unwind_Reason_Code
impl PartialEq<_Unwind_Reason_Code> for _Unwind_Reason_Code
impl PartialEq<TryReserveError> for TryReserveError
[src]
impl PartialEq<TryReserveError> for TryReserveError
[src]pub fn eq(&self, other: &TryReserveError) -> bool
[src]
pub fn ne(&self, other: &TryReserveError) -> bool
[src]
impl<'a> PartialEq<Unexpected<'a>> for Unexpected<'a>
[src]
impl<'a> PartialEq<Unexpected<'a>> for Unexpected<'a>
[src]pub fn eq(&self, other: &Unexpected<'a>) -> bool
[src]
pub fn ne(&self, other: &Unexpected<'a>) -> bool
[src]
impl PartialEq<FromHexError> for FromHexError
[src]
impl PartialEq<FromHexError> for FromHexError
[src]pub fn eq(&self, other: &FromHexError) -> bool
[src]
pub fn ne(&self, other: &FromHexError) -> bool
[src]
impl PartialEq<BernoulliError> for BernoulliError
[src]
impl PartialEq<BernoulliError> for BernoulliError
[src]pub fn eq(&self, other: &BernoulliError) -> bool
[src]
impl PartialEq<WeightedError> for WeightedError
[src]
impl PartialEq<WeightedError> for WeightedError
[src]pub fn eq(&self, other: &WeightedError) -> bool
[src]
impl PartialEq<ChaCha8Rng> for ChaCha8Rng
[src]
impl PartialEq<ChaCha8Rng> for ChaCha8Rng
[src]pub fn eq(&self, rhs: &ChaCha8Rng) -> bool
[src]
impl PartialEq<ChaCha8Core> for ChaCha8Core
[src]
impl PartialEq<ChaCha8Core> for ChaCha8Core
[src]pub fn eq(&self, other: &ChaCha8Core) -> bool
[src]
pub fn ne(&self, other: &ChaCha8Core) -> bool
[src]
impl PartialEq<ChaCha20Core> for ChaCha20Core
[src]
impl PartialEq<ChaCha20Core> for ChaCha20Core
[src]pub fn eq(&self, other: &ChaCha20Core) -> bool
[src]
pub fn ne(&self, other: &ChaCha20Core) -> bool
[src]
impl PartialEq<ChaCha12Rng> for ChaCha12Rng
[src]
impl PartialEq<ChaCha12Rng> for ChaCha12Rng
[src]pub fn eq(&self, rhs: &ChaCha12Rng) -> bool
[src]
impl PartialEq<ChaCha12Core> for ChaCha12Core
[src]
impl PartialEq<ChaCha12Core> for ChaCha12Core
[src]pub fn eq(&self, other: &ChaCha12Core) -> bool
[src]
pub fn ne(&self, other: &ChaCha12Core) -> bool
[src]
impl PartialEq<ChaCha20Rng> for ChaCha20Rng
[src]
impl PartialEq<ChaCha20Rng> for ChaCha20Rng
[src]pub fn eq(&self, rhs: &ChaCha20Rng) -> bool
[src]
Implementors
impl PartialEq<RouterMessage> for RouterMessage
[src]
impl PartialEq<RouterMessage> for RouterMessage
[src]impl PartialEq<Infallible> for Infallible
1.34.0[src]
impl PartialEq<Infallible> for Infallible
1.34.0[src]pub fn eq(&self, &Infallible) -> bool
[src]
impl PartialEq<Ipv6MulticastScope> for Ipv6MulticastScope
[src]
impl PartialEq<Ipv6MulticastScope> for Ipv6MulticastScope
[src]pub fn eq(&self, other: &Ipv6MulticastScope) -> bool
[src]
impl PartialEq<SocketAddr> for SocketAddr
[src]
impl PartialEq<SocketAddr> for SocketAddr
[src]impl PartialEq<FpCategory> for FpCategory
[src]
impl PartialEq<FpCategory> for FpCategory
[src]pub fn eq(&self, other: &FpCategory) -> bool
[src]
impl PartialEq<IntErrorKind> for IntErrorKind
[src]
impl PartialEq<IntErrorKind> for IntErrorKind
[src]pub fn eq(&self, other: &IntErrorKind) -> bool
[src]
impl PartialEq<SearchStep> for SearchStep
[src]
impl PartialEq<SearchStep> for SearchStep
[src]impl PartialEq<AddressSet> for AddressSet
[src]
impl PartialEq<AddressSet> for AddressSet
[src]impl PartialEq<ProtocolId> for ProtocolId
[src]
impl PartialEq<ProtocolId> for ProtocolId
[src]impl PartialEq<TransportMessage> for TransportMessage
[src]
impl PartialEq<TransportMessage> for TransportMessage
[src]fn eq(&self, other: &TransportMessage) -> bool
[src]
fn ne(&self, other: &TransportMessage) -> bool
[src]
impl PartialEq<PhantomPinned> for PhantomPinned
1.33.0[src]
impl PartialEq<PhantomPinned> for PhantomPinned
1.33.0[src]pub fn eq(&self, other: &PhantomPinned) -> bool
[src]
impl PartialEq<AddrParseError> for AddrParseError
[src]
impl PartialEq<AddrParseError> for AddrParseError
[src]pub fn eq(&self, other: &AddrParseError) -> bool
[src]
pub fn ne(&self, other: &AddrParseError) -> bool
[src]
impl PartialEq<SocketAddrV4> for SocketAddrV4
[src]
impl PartialEq<SocketAddrV4> for SocketAddrV4
[src]pub fn eq(&self, other: &SocketAddrV4) -> bool
[src]
impl PartialEq<SocketAddrV6> for SocketAddrV6
[src]
impl PartialEq<SocketAddrV6> for SocketAddrV6
[src]pub fn eq(&self, other: &SocketAddrV6) -> bool
[src]
impl PartialEq<NonZeroI16> for NonZeroI16
1.34.0[src]
impl PartialEq<NonZeroI16> for NonZeroI16
1.34.0[src]impl PartialEq<NonZeroI32> for NonZeroI32
1.34.0[src]
impl PartialEq<NonZeroI32> for NonZeroI32
1.34.0[src]impl PartialEq<NonZeroI64> for NonZeroI64
1.34.0[src]
impl PartialEq<NonZeroI64> for NonZeroI64
1.34.0[src]impl PartialEq<NonZeroI128> for NonZeroI128
1.34.0[src]
impl PartialEq<NonZeroI128> for NonZeroI128
1.34.0[src]pub fn eq(&self, other: &NonZeroI128) -> bool
[src]
pub fn ne(&self, other: &NonZeroI128) -> bool
[src]
impl PartialEq<NonZeroIsize> for NonZeroIsize
1.34.0[src]
impl PartialEq<NonZeroIsize> for NonZeroIsize
1.34.0[src]pub fn eq(&self, other: &NonZeroIsize) -> bool
[src]
pub fn ne(&self, other: &NonZeroIsize) -> bool
[src]
impl PartialEq<NonZeroU16> for NonZeroU16
1.28.0[src]
impl PartialEq<NonZeroU16> for NonZeroU16
1.28.0[src]impl PartialEq<NonZeroU32> for NonZeroU32
1.28.0[src]
impl PartialEq<NonZeroU32> for NonZeroU32
1.28.0[src]impl PartialEq<NonZeroU64> for NonZeroU64
1.28.0[src]
impl PartialEq<NonZeroU64> for NonZeroU64
1.28.0[src]impl PartialEq<NonZeroU128> for NonZeroU128
1.28.0[src]
impl PartialEq<NonZeroU128> for NonZeroU128
1.28.0[src]pub fn eq(&self, other: &NonZeroU128) -> bool
[src]
pub fn ne(&self, other: &NonZeroU128) -> bool
[src]
impl PartialEq<NonZeroUsize> for NonZeroUsize
1.28.0[src]
impl PartialEq<NonZeroUsize> for NonZeroUsize
1.28.0[src]pub fn eq(&self, other: &NonZeroUsize) -> bool
[src]
pub fn ne(&self, other: &NonZeroUsize) -> bool
[src]
impl PartialEq<ParseFloatError> for ParseFloatError
[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<ParseIntError> for ParseIntError
[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<TryFromIntError> for TryFromIntError
1.34.0[src]
impl PartialEq<TryFromIntError> for TryFromIntError
1.34.0[src]pub fn eq(&self, other: &TryFromIntError) -> bool
[src]
pub fn ne(&self, other: &TryFromIntError) -> bool
[src]
impl PartialEq<ParseBoolError> for ParseBoolError
[src]
impl PartialEq<ParseBoolError> for ParseBoolError
[src]pub fn eq(&self, other: &ParseBoolError) -> bool
[src]
pub fn ne(&self, other: &ParseBoolError) -> bool
[src]
impl<'_, A, B> PartialEq<&'_ mut [B]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'_, A, B> PartialEq<&'_ mut [B]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]impl<'_, A, B, const N: usize> PartialEq<&'_ [B; N]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'_, A, B, const N: usize> PartialEq<&'_ [B; N]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]impl<'_, A, B, const N: usize> PartialEq<&'_ mut [B; N]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'_, A, B, const N: usize> PartialEq<&'_ mut [B; N]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]impl<'_, T, U, A> PartialEq<Vec<U, A>> for Cow<'_, [T]> where
T: PartialEq<U> + Clone,
A: Allocator,
[src]
impl<'_, T, U, A> PartialEq<Vec<U, A>> for Cow<'_, [T]> where
T: PartialEq<U> + Clone,
A: Allocator,
[src]impl<'_, T, U, A, const N: usize> PartialEq<&'_ [U; N]> for Vec<T, A> where
T: PartialEq<U>,
A: Allocator,
[src]
impl<'_, T, U, A, const N: usize> PartialEq<&'_ [U; N]> for Vec<T, A> where
T: PartialEq<U>,
A: Allocator,
[src]impl<'a, 'b, B, C> PartialEq<Cow<'b, C>> for Cow<'a, B> where
C: ToOwned + ?Sized,
B: PartialEq<C> + ToOwned + ?Sized,
[src]
impl<'a, 'b, B, C> PartialEq<Cow<'b, C>> for Cow<'a, B> where
C: ToOwned + ?Sized,
B: PartialEq<C> + ToOwned + ?Sized,
[src]impl<K, V> PartialEq<BTreeMap<K, V>> for BTreeMap<K, V> where
K: PartialEq<K>,
V: PartialEq<V>,
[src]
impl<K, V> PartialEq<BTreeMap<K, V>> for BTreeMap<K, V> where
K: PartialEq<K>,
V: PartialEq<V>,
[src]impl<K, V, S, A> PartialEq<HashMap<K, V, S, A>> for ockam_core::lib::HashMap<K, V, S, A> where
S: BuildHasher,
A: Allocator + Clone,
K: Eq + Hash,
V: PartialEq<V>,
[src]
impl<K, V, S, A> PartialEq<HashMap<K, V, S, A>> for ockam_core::lib::HashMap<K, V, S, A> where
S: BuildHasher,
A: Allocator + Clone,
K: Eq + Hash,
V: PartialEq<V>,
[src]impl<T> PartialEq<Discriminant<T>> for Discriminant<T>
1.21.0[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]
impl<T> PartialEq<ManuallyDrop<T>> for ManuallyDrop<T> where
T: PartialEq<T> + ?Sized,
1.20.0[src]pub fn eq(&self, other: &ManuallyDrop<T>) -> bool
[src]
pub fn ne(&self, other: &ManuallyDrop<T>) -> bool
[src]
impl<T> PartialEq<LinkedList<T>> for LinkedList<T> where
T: PartialEq<T>,
[src]
impl<T> PartialEq<LinkedList<T>> for LinkedList<T> where
T: PartialEq<T>,
[src]pub fn eq(&self, other: &LinkedList<T>) -> bool
[src]
pub fn ne(&self, other: &LinkedList<T>) -> bool
[src]
impl<T> PartialEq<PhantomData<T>> for PhantomData<T> where
T: ?Sized,
[src]
impl<T> PartialEq<PhantomData<T>> for PhantomData<T> where
T: ?Sized,
[src]pub fn eq(&self, _other: &PhantomData<T>) -> bool
[src]
impl<T, S, A> PartialEq<HashSet<T, S, A>> for ockam_core::lib::HashSet<T, S, A> where
T: Eq + Hash,
S: BuildHasher,
A: Allocator + Clone,
[src]
impl<T, S, A> PartialEq<HashSet<T, S, A>> for ockam_core::lib::HashSet<T, S, A> where
T: Eq + Hash,
S: BuildHasher,
A: Allocator + Clone,
[src]