1.0.0[−][src]Trait uefi_std::cmp::Eq

pub trait Eq: PartialEq<Self> { }

Trait for equality comparisons which are equivalence relations.

This means, that in addition to a == b and a != b being strict inverses, the equality must be (for all a, b and c):

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

This property cannot be checked by the compiler, and therefore Eq implies PartialEq, and has no extra methods.

Derivable

This trait can be used with #[derive]. When derived, because Eq has no extra methods, it is only informing the compiler that this is an equivalence relation rather than a partial equivalence relation. Note that the derive strategy requires all fields are Eq, which isn't always desired.

How can I implement Eq?

If you cannot use the derive strategy, specify that your type implements Eq, which has no methods:

enum BookFormat { Paperback, Hardback, Ebook }
struct Book {
    isbn: i32,
    format: BookFormat,
}
impl PartialEq for Book {
    fn eq(&self, other: &Book) -> bool {
        self.isbn == other.isbn
    }
}
impl Eq for Book {}

Implementations on Foreign Types

impl Eq for TryFromIntError[src]

impl Eq for NonZeroIsize[src]

impl Eq for NonZeroU16[src]

impl<'a> Eq for Utf8LossyChunk<'a>[src]

impl Eq for NonZeroI16[src]

impl Eq for NonZeroI128[src]

impl Eq for CannotReallocInPlace[src]

impl Eq for Ordering[src]

impl Eq for NonZeroI64[src]

impl Eq for NonZeroI8[src]

impl Eq for ParseIntError[src]

impl Eq for Duration[src]

impl Eq for NonZeroU8[src]

impl<T> Eq for Wrapping<T> where
    T: Eq, [src]

impl Eq for NonZeroU32[src]

impl<T> Eq for Poll<T> where
    T: Eq, [src]

impl Eq for Layout[src]

impl Eq for NonZeroUsize[src]

impl Eq for NonZeroU128[src]

impl Eq for FpCategory[src]

impl Eq for NonZeroI32[src]

impl Eq for NonZeroU64[src]

impl Eq for IntErrorKind[src]

impl Eq for LayoutErr[src]

impl Eq for AllocErr[src]

impl Eq for ParseFloatError[src]

impl<T> Eq for Arc<T> where
    T: Eq + ?Sized, [src]

impl Eq for Guid

impl Eq for PhysicalAddress

impl Eq for GuidKind

impl Eq for Event

impl Eq for Error

impl Eq for VirtualAddress

impl Eq for HiiHandle

impl Eq for Handle

impl Eq for MemoryType

impl Eq for Status

Loading content...

Implementors

impl Eq for ![src]

impl Eq for ()[src]

impl Eq for uefi_std::cmp::Ordering[src]

impl Eq for CollectionAllocErr[src]

impl Eq for Infallible[src]

impl Eq for SearchStep[src]

impl Eq for TypeId[src]

impl Eq for CpuidResult[src]

impl Eq for CharTryFromError[src]

impl Eq for DecodeUtf16Error[src]

impl Eq for ParseCharError[src]

impl Eq for UnicodeVersion[src]

impl Eq for uefi_std::fmt::Error[src]

impl Eq for PhantomPinned[src]

impl Eq for RangeFull[src]

impl Eq for NoneError[src]

impl Eq for ParseBoolError[src]

impl Eq for Utf8Error[src]

impl Eq for String[src]

impl Eq for bool[src]

impl Eq for char[src]

impl Eq for i8[src]

impl Eq for i16[src]

impl Eq for i32[src]

impl Eq for i64[src]

impl Eq for i128[src]

impl Eq for isize[src]

impl Eq for str[src]

impl Eq for u8[src]

impl Eq for u16[src]

impl Eq for u32[src]

impl Eq for u64[src]

impl Eq for u128[src]

impl Eq for usize[src]

impl<'_, A> Eq for &'_ A where
    A: Eq + ?Sized, [src]

impl<'_, A> Eq for &'_ mut A where
    A: Eq + ?Sized, [src]

impl<'_, B> Eq for Cow<'_, B> where
    B: Eq + ToOwned + ?Sized, [src]

impl<A> Eq for (A,) where
    A: Eq + ?Sized, [src]

impl<A> Eq for VecDeque<A> where
    A: Eq, [src]

impl<A, B> Eq for (A, B) where
    A: Eq,
    B: Eq + ?Sized, [src]

impl<A, B, C> Eq for (A, B, C) where
    A: Eq,
    B: Eq,
    C: Eq + ?Sized, [src]

impl<A, B, C, D> Eq for (A, B, C, D) where
    A: Eq,
    B: Eq,
    C: Eq,
    D: Eq + ?Sized, [src]

impl<A, B, C, D, E> Eq for (A, B, C, D, E) where
    A: Eq,
    B: Eq,
    C: Eq,
    D: Eq,
    E: Eq + ?Sized, [src]

impl<A, B, C, D, E, F> Eq for (A, B, C, D, E, F) where
    A: Eq,
    B: Eq,
    C: Eq,
    D: Eq,
    E: Eq,
    F: Eq + ?Sized, [src]

impl<A, B, C, D, E, F, G> Eq for (A, B, C, D, E, F, G) where
    A: Eq,
    B: Eq,
    C: Eq,
    D: Eq,
    E: Eq,
    F: Eq,
    G: Eq + ?Sized, [src]

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

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

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

impl<A, B, C, D, E, F, G, H, I, J, K> Eq for (A, B, C, D, E, F, G, H, I, J, K) where
    A: Eq,
    B: Eq,
    C: Eq,
    D: Eq,
    E: Eq,
    F: Eq,
    G: Eq,
    H: Eq,
    I: Eq,
    J: Eq,
    K: Eq + ?Sized, [src]

impl<A, B, C, D, E, F, G, H, I, J, K, L> Eq for (A, B, C, D, E, F, G, H, I, J, K, L) where
    A: Eq,
    B: Eq,
    C: Eq,
    D: Eq,
    E: Eq,
    F: Eq,
    G: Eq,
    H: Eq,
    I: Eq,
    J: Eq,
    K: Eq,
    L: Eq + ?Sized, [src]

impl<H> Eq for BuildHasherDefault<H>[src]

impl<Idx> Eq for Range<Idx> where
    Idx: Eq, [src]

impl<Idx> Eq for RangeFrom<Idx> where
    Idx: Eq, [src]

impl<Idx> Eq for RangeInclusive<Idx> where
    Idx: Eq, [src]

impl<Idx> Eq for RangeTo<Idx> where
    Idx: Eq, [src]

impl<Idx> Eq for RangeToInclusive<Idx> where
    Idx: Eq, [src]

impl<K, V> Eq for BTreeMap<K, V> where
    K: Eq,
    V: Eq, [src]

impl<P> Eq for Pin<P> where
    P: Eq, [src]

impl<Ret> Eq for extern "C" fn() -> Ret[src]

impl<Ret> Eq for fn() -> Ret[src]

impl<Ret> Eq for unsafe extern "C" fn() -> Ret[src]

impl<Ret> Eq for unsafe fn() -> Ret[src]

impl<Ret, A> Eq for extern "C" fn(A) -> Ret[src]

impl<Ret, A> Eq for extern "C" fn(A, VaList) -> Ret[src]

impl<Ret, A> Eq for fn(A) -> Ret[src]

impl<Ret, A> Eq for unsafe extern "C" fn(A) -> Ret[src]

impl<Ret, A> Eq for unsafe extern "C" fn(A, VaList) -> Ret[src]

impl<Ret, A> Eq for unsafe fn(A) -> Ret[src]

impl<Ret, A, B> Eq for extern "C" fn(A, B) -> Ret[src]

impl<Ret, A, B> Eq for extern "C" fn(A, B, VaList) -> Ret[src]

impl<Ret, A, B> Eq for fn(A, B) -> Ret[src]

impl<Ret, A, B> Eq for unsafe extern "C" fn(A, B) -> Ret[src]

impl<Ret, A, B> Eq for unsafe extern "C" fn(A, B, VaList) -> Ret[src]

impl<Ret, A, B> Eq for unsafe fn(A, B) -> Ret[src]

impl<Ret, A, B, C> Eq for extern "C" fn(A, B, C) -> Ret[src]

impl<Ret, A, B, C> Eq for extern "C" fn(A, B, C, VaList) -> Ret[src]

impl<Ret, A, B, C> Eq for fn(A, B, C) -> Ret[src]

impl<Ret, A, B, C> Eq for unsafe extern "C" fn(A, B, C) -> Ret[src]

impl<Ret, A, B, C> Eq for unsafe extern "C" fn(A, B, C, VaList) -> Ret[src]

impl<Ret, A, B, C> Eq for unsafe fn(A, B, C) -> Ret[src]

impl<Ret, A, B, C, D> Eq for extern "C" fn(A, B, C, D) -> Ret[src]

impl<Ret, A, B, C, D> Eq for extern "C" fn(A, B, C, D, VaList) -> Ret[src]

impl<Ret, A, B, C, D> Eq for fn(A, B, C, D) -> Ret[src]

impl<Ret, A, B, C, D> Eq for unsafe extern "C" fn(A, B, C, D) -> Ret[src]

impl<Ret, A, B, C, D> Eq for unsafe extern "C" fn(A, B, C, D, VaList) -> Ret[src]

impl<Ret, A, B, C, D> Eq for unsafe fn(A, B, C, D) -> Ret[src]

impl<Ret, A, B, C, D, E> Eq for extern "C" fn(A, B, C, D, E) -> Ret[src]

impl<Ret, A, B, C, D, E> Eq for extern "C" fn(A, B, C, D, E, VaList) -> Ret[src]

impl<Ret, A, B, C, D, E> Eq for fn(A, B, C, D, E) -> Ret[src]

impl<Ret, A, B, C, D, E> Eq for unsafe extern "C" fn(A, B, C, D, E) -> Ret[src]

impl<Ret, A, B, C, D, E> Eq for unsafe extern "C" fn(A, B, C, D, E, VaList) -> Ret[src]

impl<Ret, A, B, C, D, E> Eq for unsafe fn(A, B, C, D, E) -> Ret[src]

impl<Ret, A, B, C, D, E, F> Eq for extern "C" fn(A, B, C, D, E, F) -> Ret[src]

impl<Ret, A, B, C, D, E, F> Eq for extern "C" fn(A, B, C, D, E, F, VaList) -> Ret[src]

impl<Ret, A, B, C, D, E, F> Eq for fn(A, B, C, D, E, F) -> Ret[src]

impl<Ret, A, B, C, D, E, F> Eq for unsafe extern "C" fn(A, B, C, D, E, F) -> Ret[src]

impl<Ret, A, B, C, D, E, F> Eq for unsafe extern "C" fn(A, B, C, D, E, F, VaList) -> Ret[src]

impl<Ret, A, B, C, D, E, F> Eq for unsafe fn(A, B, C, D, E, F) -> Ret[src]

impl<Ret, A, B, C, D, E, F, G> Eq for extern "C" fn(A, B, C, D, E, F, G) -> Ret[src]

impl<Ret, A, B, C, D, E, F, G> Eq for extern "C" fn(A, B, C, D, E, F, G, VaList) -> Ret[src]

impl<Ret, A, B, C, D, E, F, G> Eq for fn(A, B, C, D, E, F, G) -> Ret[src]

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

impl<Ret, A, B, C, D, E, F, G> Eq for unsafe extern "C" fn(A, B, C, D, E, F, G, VaList) -> Ret[src]

impl<Ret, A, B, C, D, E, F, G> Eq for unsafe fn(A, B, C, D, E, F, G) -> Ret[src]

impl<Ret, A, B, C, D, E, F, G, H> Eq for extern "C" fn(A, B, C, D, E, F, G, H) -> Ret[src]

impl<Ret, A, B, C, D, E, F, G, H> Eq for extern "C" fn(A, B, C, D, E, F, G, H, VaList) -> Ret[src]

impl<Ret, A, B, C, D, E, F, G, H> Eq for fn(A, B, C, D, E, F, G, H) -> Ret[src]

impl<Ret, A, B, C, D, E, F, G, H> Eq 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> Eq for unsafe extern "C" fn(A, B, C, D, E, F, G, H, VaList) -> Ret[src]

impl<Ret, A, B, C, D, E, F, G, H> Eq for unsafe fn(A, B, C, D, E, F, G, H) -> Ret[src]

impl<Ret, A, B, C, D, E, F, G, H, I> Eq 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> Eq for extern "C" fn(A, B, C, D, E, F, G, H, I, VaList) -> Ret[src]

impl<Ret, A, B, C, D, E, F, G, H, I> Eq for fn(A, B, C, D, E, F, G, H, I) -> Ret[src]

impl<Ret, A, B, C, D, E, F, G, H, I> Eq 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> Eq for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, VaList) -> Ret[src]

impl<Ret, A, B, C, D, E, F, G, H, I> Eq 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> Eq 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> Eq for extern "C" fn(A, B, C, D, E, F, G, H, I, J, VaList) -> Ret[src]

impl<Ret, A, B, C, D, E, F, G, H, I, J> Eq 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> Eq 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> Eq for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, VaList) -> Ret[src]

impl<Ret, A, B, C, D, E, F, G, H, I, J> Eq 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, K> Eq 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> Eq for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, VaList) -> Ret[src]

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Eq 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> Eq 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> Eq for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, VaList) -> Ret[src]

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Eq 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, L> Eq 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> Eq for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, VaList) -> Ret[src]

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Eq 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> Eq 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> Eq for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, VaList) -> Ret[src]

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Eq for unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret[src]

impl<T> Eq for *const T where
    T: ?Sized, [src]

impl<T> Eq for *mut T where
    T: ?Sized, [src]

impl<T> Eq for Bound<T> where
    T: Eq, [src]

impl<T> Eq for Option<T> where
    T: Eq, [src]

impl<T> Eq for Box<T> where
    T: Eq + ?Sized, [src]

impl<T> Eq for Cell<T> where
    T: Copy + Eq, [src]

impl<T> Eq for RefCell<T> where
    T: Eq + ?Sized, [src]

impl<T> Eq for Reverse<T> where
    T: Eq, [src]

impl<T> Eq for BTreeSet<T> where
    T: Eq, [src]

impl<T> Eq for LinkedList<T> where
    T: Eq, [src]

impl<T> Eq for PhantomData<T> where
    T: ?Sized, [src]

impl<T> Eq for Discriminant<T>[src]

impl<T> Eq for ManuallyDrop<T> where
    T: Eq + ?Sized, [src]

impl<T> Eq for NonNull<T> where
    T: ?Sized, [src]

impl<T> Eq for Rc<T> where
    T: Eq + ?Sized, [src]

impl<T> Eq for Vec<T> where
    T: Eq, [src]

impl<T> Eq for [T; 0] where
    T: Eq, [src]

impl<T> Eq for [T; 1] where
    T: Eq, [src]

impl<T> Eq for [T; 2] where
    T: Eq, [src]

impl<T> Eq for [T; 3] where
    T: Eq, [src]

impl<T> Eq for [T; 4] where
    T: Eq, [src]

impl<T> Eq for [T; 5] where
    T: Eq, [src]

impl<T> Eq for [T; 6] where
    T: Eq, [src]

impl<T> Eq for [T; 7] where
    T: Eq, [src]

impl<T> Eq for [T; 8] where
    T: Eq, [src]

impl<T> Eq for [T; 9] where
    T: Eq, [src]

impl<T> Eq for [T; 10] where
    T: Eq, [src]

impl<T> Eq for [T; 11] where
    T: Eq, [src]

impl<T> Eq for [T; 12] where
    T: Eq, [src]

impl<T> Eq for [T; 13] where
    T: Eq, [src]

impl<T> Eq for [T; 14] where
    T: Eq, [src]

impl<T> Eq for [T; 15] where
    T: Eq, [src]

impl<T> Eq for [T; 16] where
    T: Eq, [src]

impl<T> Eq for [T; 17] where
    T: Eq, [src]

impl<T> Eq for [T; 18] where
    T: Eq, [src]

impl<T> Eq for [T; 19] where
    T: Eq, [src]

impl<T> Eq for [T; 20] where
    T: Eq, [src]

impl<T> Eq for [T; 21] where
    T: Eq, [src]

impl<T> Eq for [T; 22] where
    T: Eq, [src]

impl<T> Eq for [T; 23] where
    T: Eq, [src]

impl<T> Eq for [T; 24] where
    T: Eq, [src]

impl<T> Eq for [T; 25] where
    T: Eq, [src]

impl<T> Eq for [T; 26] where
    T: Eq, [src]

impl<T> Eq for [T; 27] where
    T: Eq, [src]

impl<T> Eq for [T; 28] where
    T: Eq, [src]

impl<T> Eq for [T; 29] where
    T: Eq, [src]

impl<T> Eq for [T; 30] where
    T: Eq, [src]

impl<T> Eq for [T; 31] where
    T: Eq, [src]

impl<T> Eq for [T; 32] where
    T: Eq, [src]

impl<T> Eq for [T] where
    T: Eq, [src]

impl<T, E> Eq for Result<T, E> where
    E: Eq,
    T: Eq, [src]

impl<Y, R> Eq for GeneratorState<Y, R> where
    R: Eq,
    Y: Eq, [src]

Loading content...