Trait cron::lib::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: &Self) -> bool {
        self.isbn == other.isbn
    }
}
impl Eq for Book {}

Implementations on Foreign Types

impl Eq for ExitStatus

impl Eq for SystemTime

impl Eq for PathBuf

impl Eq for BacktraceStatus

impl Eq for AddrParseError

impl Eq for SocketAddrV6

impl<'a> Eq for Component<'a>

impl Eq for AccessError

impl Eq for SeekFrom

impl Eq for TryRecvError

impl Eq for OsString

impl Eq for IpAddr

impl Eq for Ipv6Addr

impl Eq for NulError

impl<'a> Eq for Prefix<'a>

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

impl Eq for ErrorKind

impl Eq for Path

impl Eq for Output

impl Eq for FromBytesWithNulError

impl Eq for IntoStringError

impl Eq for Permissions

impl<'_> Eq for Components<'_>

impl Eq for Ipv4Addr

impl Eq for SocketAddrV4

impl<'a> Eq for PrefixComponent<'a>

impl Eq for OsStr

impl Eq for CString

impl Eq for Instant

impl Eq for StripPrefixError

impl Eq for FileType

impl Eq for Shutdown

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

impl Eq for Ipv6MulticastScope

impl Eq for RecvError

impl<T> Eq for Cursor<T> where
    T: Eq, 

impl Eq for VarError

impl Eq for SocketAddr

impl Eq for CStr

impl Eq for RecvTimeoutError

impl Eq for WaitTimeoutResult

impl Eq for ThreadId

impl Eq for CharTryFromError

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

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

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

impl Eq for u8

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

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

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

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

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

impl Eq for NonZeroU8

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

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

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

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

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

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

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, 

impl<T> Eq for Poll<T> where
    T: Eq, 

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

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

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

impl Eq for TypeId

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

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

impl Eq for AllocInit

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, 

impl<const N: usize, T> Eq for [T; N] where
    T: Eq,
    [T; N]: LengthAtMost32, 

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

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, 

impl Eq for i8

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

impl Eq for i16

impl Eq for LayoutErr

impl Eq for ReallocPlacement

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

impl Eq for NonZeroI32

impl Eq for NonZeroI128

impl Eq for Layout

impl<'a> Eq for Utf8LossyChunk<'a>

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

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

impl Eq for Ordering

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

impl Eq for NonZeroU64

impl Eq for ParseFloatError

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

impl Eq for !

impl Eq for u64

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

impl Eq for bool

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

impl Eq for ParseIntError

impl Eq for u32

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

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

impl Eq for TryFromIntError

impl<Ret> Eq for unsafe fn() -> Ret

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

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

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

impl Eq for ()

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

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, 

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, 

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

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

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

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

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

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

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

impl Eq for IntErrorKind

impl Eq for NonZeroU16

impl Eq for u128

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

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

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

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

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

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

impl Eq for Duration

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

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

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, 

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

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

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

impl Eq for NonZeroU128

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

impl Eq for i32

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

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

impl Eq for i64

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

impl Eq for NonZeroI64

impl Eq for NonZeroI16

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

impl Eq for i128

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

impl Eq for ParseCharError

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

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, 

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

impl Eq for isize

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

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

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

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

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

impl Eq for AllocErr

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

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

impl<P> Eq for Pin<P> where
    P: Deref,
    <P as Deref>::Target: Eq, 

impl Eq for PhantomPinned

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

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

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

impl Eq for CpuidResult

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, 

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

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

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

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

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

impl Eq for NonZeroUsize

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

impl Eq for char

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

impl Eq for str

impl Eq for u16

impl Eq for FpCategory

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

impl<Ret> Eq for fn() -> Ret

impl Eq for NonZeroU32

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

impl Eq for NonZeroIsize

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

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

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

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

impl Eq for NonZeroI8

impl Eq for usize

impl<T> Eq for Wrapping<T> where
    T: Eq, 

impl Eq for DecodeUtf16Error

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

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

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

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

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

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

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

impl Eq for PrintFmt

impl<T, S> Eq for HashSet<T, S> where
    S: BuildHasher,
    T: Eq + Hash, 

impl<K, V, S> Eq for HashMap<K, V, S> where
    K: Eq + Hash,
    S: BuildHasher,
    V: Eq, 

impl Eq for CollectionAllocErr

impl Eq for OutOfRangeError

impl Eq for Tm

impl Eq for Timespec

impl Eq for SteadyTime

impl<A> Eq for ExtendedGcd<A> where
    A: Eq, 

impl Eq for PrintFmt

impl Eq for FileEntryFormat

impl Eq for AttributeSpecification

impl<R> Eq for UnwindTableRow<R> where
    R: Reader + Eq, 

impl<R> Eq for EhFrameHdr<R> where
    R: Reader + Eq, 

impl<T> Eq for DebugLocListsIndex<T> where
    T: Eq, 

impl Eq for ColumnType

impl Eq for Augmentation

impl Eq for DwChildren

impl Eq for DwCfa

impl Eq for DwId

impl Eq for DwLang

impl<T> Eq for DebugAbbrevOffset<T> where
    T: Eq, 

impl<T> Eq for EhFrameOffset<T> where
    T: Eq, 

impl Eq for Range

impl<R, Offset> Eq for CompleteLineProgram<R, Offset> where
    Offset: Eq + ReaderOffset,
    R: Eq + Reader<Offset = Offset>, 

impl<R> Eq for CfaRule<R> where
    R: Reader + Eq, 

impl Eq for DwLns

impl<R, Offset> Eq for LineInstruction<R, Offset> where
    Offset: Eq + ReaderOffset,
    R: Eq + Reader<Offset = Offset>, 

impl<T> Eq for DebugRngListsBase<T> where
    T: Eq, 

impl<T> Eq for DebugAddrIndex<T> where
    T: Eq, 

impl Eq for ValueType

impl<T> Eq for DebugRngListsIndex<T> where
    T: Eq, 

impl Eq for Abbreviation

impl Eq for DwOp

impl Eq for DwMacro

impl Eq for DwVis

impl Eq for BigEndian

impl Eq for Pointer

impl<'input, Endian> Eq for EndianSlice<'input, Endian> where
    Endian: Eq + Endianity, 

impl Eq for LineEncoding

impl Eq for DebugTypeSignature

impl Eq for DwTag

impl<R> Eq for UnwindContext<R> where
    R: Reader + Eq, 

impl Eq for LittleEndian

impl Eq for DwEhPe

impl<R, Offset> Eq for LineProgramHeader<R, Offset> where
    Offset: Eq + ReaderOffset,
    R: Eq + Reader<Offset = Offset>, 

impl Eq for DwDsc

impl<T> Eq for DebugAddrBase<T> where
    T: Eq, 

impl Eq for LineRow

impl Eq for RunTimeEndian

impl Eq for DwInl

impl Eq for DwAt

impl Eq for BaseAddresses

impl Eq for DwLne

impl Eq for ReaderOffsetId

impl<T> Eq for DebugStrOffset<T> where
    T: Eq, 

impl Eq for DwForm

impl<T> Eq for DebugLocListsBase<T> where
    T: Eq, 

impl<T> Eq for DebugMacinfoOffset<T> where
    T: Eq, 

impl<'bases, Section, R> Eq for PartialFrameDescriptionEntry<'bases, Section, R> where
    R: Eq + Reader,
    Section: Eq + UnwindSection<R>,
    <R as Reader>::Offset: Eq,
    <Section as UnwindSection<R>>::Offset: Eq, 

impl<T> Eq for DebugTypesOffset<T> where
    T: Eq, 

impl Eq for DwAte

impl Eq for DwAddr

impl Eq for DwEnd

impl<T> Eq for DebugInfoOffset<T> where
    T: Eq, 

impl Eq for DwDs

impl Eq for DwLnct

impl Eq for Encoding

impl<R> Eq for Attribute<R> where
    R: Reader + Eq, 

impl<R, Offset> Eq for IncompleteLineProgram<R, Offset> where
    Offset: Eq + ReaderOffset,
    R: Eq + Reader<Offset = Offset>, 

impl<'bases, Section, R> Eq for CieOrFde<'bases, Section, R> where
    R: Eq + Reader,
    Section: Eq + UnwindSection<R>, 

impl<R, Offset> Eq for CompilationUnitHeader<R, Offset> where
    Offset: Eq + ReaderOffset,
    R: Eq + Reader<Offset = Offset>, 

impl<R, Offset> Eq for UnitHeader<R, Offset> where
    Offset: Eq + ReaderOffset,
    R: Eq + Reader<Offset = Offset>, 

impl<R> Eq for Expression<R> where
    R: Reader + Eq, 

impl<T> Eq for UnitSectionOffset<T> where
    T: Eq, 

impl Eq for SectionBaseAddresses

impl Eq for DwDefaulted

impl<T> Eq for ArangeEntry<T> where
    T: Eq + Copy, 

impl<T> Eq for DebugMacroOffset<T> where
    T: Eq, 

impl<T> Eq for DebugStrOffsetsIndex<T> where
    T: Eq, 

impl Eq for Format

impl<R> Eq for EhFrame<R> where
    R: Reader + Eq, 

impl<R> Eq for LocationListEntry<R> where
    R: Reader + Eq, 

impl<T> Eq for DieReference<T> where
    T: Eq, 

impl Eq for Register

impl<T> Eq for LocationListsOffset<T> where
    T: Eq, 

impl<R, Offset> Eq for FrameDescriptionEntry<R, Offset> where
    Offset: Eq + ReaderOffset,
    R: Eq + Reader<Offset = Offset>, 

impl Eq for DwIdx

impl<R> Eq for RegisterRule<R> where
    R: Reader + Eq, 

impl<R, Offset> Eq for CommonInformationEntry<R, Offset> where
    Offset: Eq + ReaderOffset,
    R: Eq + Reader<Offset = Offset>, 

impl Eq for DwCc

impl Eq for DwAccess

impl<R> Eq for CallFrameInstruction<R> where
    R: Reader + Eq, 

impl Eq for DwOrd

impl<T> Eq for UnitOffset<T> where
    T: Eq, 

impl Eq for Error

impl<T> Eq for DebugLineStrOffset<T> where
    T: Eq, 

impl Eq for DwVirtuality

impl<R> Eq for DebugFrame<R> where
    R: Reader + Eq, 

impl<T> Eq for DebugFrameOffset<T> where
    T: Eq, 

impl<R, Offset> Eq for FileEntry<R, Offset> where
    Offset: Eq + ReaderOffset,
    R: Eq + Reader<Offset = Offset>, 

impl Eq for DwRle

impl Eq for DwUt

impl<T> Eq for DebugLineOffset<T> where
    T: Eq, 

impl Eq for DwLle

impl<T> Eq for RangeListsOffset<T> where
    T: Eq, 

impl<T> Eq for DebugStrOffsetsBase<T> where
    T: Eq, 

impl<R, Offset> Eq for AttributeValue<R, Offset> where
    Offset: Eq + ReaderOffset,
    R: Eq + Reader<Offset = Offset>, 

impl Eq for SectionId

impl<R, Offset> Eq for TypeUnitHeader<R, Offset> where
    Offset: Eq + ReaderOffset,
    R: Eq + Reader<Offset = Offset>, 

impl<R, Offset> Eq for Operation<R, Offset> where
    Offset: Eq + ReaderOffset,
    R: Eq + Reader<Offset = Offset>, 

impl Eq for BinaryFormat

impl Eq for RelocationTarget

impl Eq for SectionFlags

impl<'data> Eq for Bytes<'data>

impl Eq for BigEndian

impl Eq for RelocationEncoding

impl Eq for SymbolIndex

impl Eq for LittleEndian

impl Eq for Error

impl<E> Eq for I32<E> where
    E: Endian + Eq, 

impl Eq for RelocationKind

impl Eq for AddressSize

impl<E> Eq for U32<E> where
    E: Endian + Eq, 

impl Eq for FileFlags

impl<E> Eq for U32Bytes<E> where
    E: Endian + Eq, 

impl Eq for SymbolSection

impl<E> Eq for U64<E> where
    E: Endian + Eq, 

impl<'data> Eq for CompressedData<'data>

impl Eq for CompressionFormat

impl<E> Eq for U16Bytes<E> where
    E: Endian + Eq, 

impl Eq for Architecture

impl<E> Eq for I16<E> where
    E: Endian + Eq, 

impl<E> Eq for U16<E> where
    E: Endian + Eq, 

impl Eq for SymbolKind

impl<E> Eq for I64<E> where
    E: Endian + Eq, 

impl Eq for SectionIndex

impl Eq for SymbolScope

impl Eq for SectionKind

impl Eq for Endianness

impl<E> Eq for U64Bytes<E> where
    E: Endian + Eq, 

impl<Section> Eq for SymbolFlags<Section> where
    Section: Eq, 

Loading content...

Implementors

impl Eq for cron::Endianness

impl Eq for Needed

impl Eq for SecondsFormat

impl Eq for Weekday

impl Eq for Fixed

impl Eq for Numeric

impl Eq for Pad

impl Eq for cron::lib::std::cmp::Ordering

impl Eq for TryReserveError

impl Eq for Infallible

impl Eq for SearchStep

impl Eq for InternalFixed

impl Eq for InternalNumeric

impl Eq for cron::lib::std::fmt::Error

impl Eq for RangeFull

impl Eq for NoneError

impl Eq for ParseBoolError

impl Eq for Utf8Error

impl Eq for FromUtf8Error

impl Eq for String

impl Eq for cron::Duration

impl Eq for FixedOffset

impl Eq for IsoWeek

impl Eq for NaiveDate

impl Eq for NaiveDateTime

impl Eq for NaiveTime

impl Eq for ParseError

impl Eq for Utc

impl<'a> Eq for Item<'a>

impl<'a> Eq for CompleteByteSlice<'a>

impl<'a> Eq for CompleteStr<'a>

impl<A> Eq for VecDeque<A> where
    A: Eq, 

impl<E> Eq for cron::ErrorKind<E> where
    E: Eq, 

impl<H> Eq for BuildHasherDefault<H>

impl<Idx> Eq for cron::lib::std::ops::Range<Idx> where
    Idx: Eq, 

impl<Idx> Eq for RangeFrom<Idx> where
    Idx: Eq, 

impl<Idx> Eq for RangeInclusive<Idx> where
    Idx: Eq, 

impl<Idx> Eq for RangeTo<Idx> where
    Idx: Eq, 

impl<Idx> Eq for RangeToInclusive<Idx> where
    Idx: Eq, 

impl<K, V> Eq for BTreeMap<K, V> where
    K: Eq,
    V: Eq, 

impl<K, V, S> Eq for cron::lib::std::collections::HashMap<K, V, S> where
    K: Eq + Hash,
    S: BuildHasher,
    V: Eq, 

impl<T> Eq for LocalResult<T> where
    T: Eq, 

impl<T> Eq for Bound<T> where
    T: Eq, 

impl<T> Eq for Option<T> where
    T: Eq, 

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

impl<T> Eq for Reverse<T> where
    T: Eq, 

impl<T> Eq for BTreeSet<T> where
    T: Eq, 

impl<T> Eq for LinkedList<T> where
    T: Eq, 

impl<T> Eq for Discriminant<T>

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

impl<T> Eq for Vec<T> where
    T: Eq, 

impl<T, E> Eq for Result<T, E> where
    E: Eq,
    T: Eq, 

impl<T, S> Eq for cron::lib::std::collections::HashSet<T, S> where
    S: BuildHasher,
    T: Eq + Hash, 

impl<Tz> Eq for Date<Tz> where
    Tz: TimeZone, 

impl<Tz> Eq for DateTime<Tz> where
    Tz: TimeZone, 

impl<Y, R> Eq for GeneratorState<Y, R> where
    R: Eq,
    Y: Eq, 

Loading content...