Trait flashmap::TrustedHashEq

pub unsafe trait TrustedHashEq: Hash + Eq { }

A marker trait asserting that a type has a deterministic Hash and Eq implementation.

This trait is implemented for all standard library types which have deterministic Hash and Eq implementations.

Safety

A deterministic Hash implementation guarantees that if a value is held constant, then the hash of the value will also remain constant if the initial state of the provided hasher is also held constant, and the hasher is itself deterministic.

A deterministic Eq implementation guarantees that if a value is held constant, then the result of comparing it to another constant will not change.

Implementations on Foreign Types

impl TrustedHashEq for Ordering

impl TrustedHashEq for Infallible

impl TrustedHashEq for ErrorKind

impl TrustedHashEq for IpAddr

impl TrustedHashEq for SocketAddr

impl TrustedHashEq for Ordering

impl TrustedHashEq for bool

impl TrustedHashEq for char

impl TrustedHashEq for i8

impl TrustedHashEq for i16

impl TrustedHashEq for i32

impl TrustedHashEq for i64

impl TrustedHashEq for i128

impl TrustedHashEq for isize

impl TrustedHashEq for str

impl TrustedHashEq for u8

impl TrustedHashEq for u16

impl TrustedHashEq for u32

impl TrustedHashEq for u64

impl TrustedHashEq for u128

impl TrustedHashEq for ()

impl TrustedHashEq for usize

impl TrustedHashEq for TypeId

impl TrustedHashEq for CStr

impl TrustedHashEq for CString

impl TrustedHashEq for OsStr

impl TrustedHashEq for OsString

impl TrustedHashEq for Error

impl TrustedHashEq for FileType

impl TrustedHashEq for PhantomPinned

impl TrustedHashEq for Ipv4Addr

impl TrustedHashEq for Ipv6Addr

impl TrustedHashEq for SocketAddrV4

impl TrustedHashEq for SocketAddrV6

impl TrustedHashEq for NonZeroI8

impl TrustedHashEq for NonZeroI16

impl TrustedHashEq for NonZeroI32

impl TrustedHashEq for NonZeroI64

impl TrustedHashEq for NonZeroI128

impl TrustedHashEq for NonZeroIsize

impl TrustedHashEq for NonZeroU8

impl TrustedHashEq for NonZeroU16

impl TrustedHashEq for NonZeroU32

impl TrustedHashEq for NonZeroU64

impl TrustedHashEq for NonZeroU128

impl TrustedHashEq for NonZeroUsize

impl TrustedHashEq for RangeFull

impl TrustedHashEq for Path

impl TrustedHashEq for PathBuf

impl TrustedHashEq for String

impl TrustedHashEq for ThreadId

impl TrustedHashEq for Duration

impl TrustedHashEq for Instant

impl TrustedHashEq for SystemTime

impl<'a> TrustedHashEq for PrefixComponent<'a>

impl<'a> TrustedHashEq for Cow<'a, str>

impl<'a> TrustedHashEq for Cow<'a, CStr>

impl<'a> TrustedHashEq for Cow<'a, OsStr>

impl<'a> TrustedHashEq for Cow<'a, Path>

impl<'a, T> TrustedHashEq for Cow<'a, [T]> where
    T: Clone + TrustedHashEq, 

impl<'a, T> TrustedHashEq for Cow<'a, T> where
    T: Clone + TrustedHashEq, 

impl<'a, T: ?Sized> TrustedHashEq for &'a T where
    T: TrustedHashEq, 

impl<'a, T: ?Sized> TrustedHashEq for &'a mut T where
    T: TrustedHashEq, 

impl<'a> TrustedHashEq for Component<'a>

impl<'a> TrustedHashEq for Prefix<'a>

impl<T> TrustedHashEq for VecDeque<T> where
    T: TrustedHashEq, 

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

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

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

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

impl<A, B, C, D, E: ?Sized> TrustedHashEq for (A, B, C, D, E) where
    A: TrustedHashEq,
    B: TrustedHashEq,
    C: TrustedHashEq,
    D: TrustedHashEq,
    E: TrustedHashEq, 

impl<A, B, C, D, E, F: ?Sized> TrustedHashEq for (A, B, C, D, E, F) where
    A: TrustedHashEq,
    B: TrustedHashEq,
    C: TrustedHashEq,
    D: TrustedHashEq,
    E: TrustedHashEq,
    F: TrustedHashEq, 

impl<A, B, C, D, E, F, G: ?Sized> TrustedHashEq for (A, B, C, D, E, F, G) where
    A: TrustedHashEq,
    B: TrustedHashEq,
    C: TrustedHashEq,
    D: TrustedHashEq,
    E: TrustedHashEq,
    F: TrustedHashEq,
    G: TrustedHashEq, 

impl<A, B, C, D, E, F, G, H: ?Sized> TrustedHashEq for (A, B, C, D, E, F, G, H) where
    A: TrustedHashEq,
    B: TrustedHashEq,
    C: TrustedHashEq,
    D: TrustedHashEq,
    E: TrustedHashEq,
    F: TrustedHashEq,
    G: TrustedHashEq,
    H: TrustedHashEq, 

impl<A, B, C, D, E, F, G, H, I: ?Sized> TrustedHashEq for (A, B, C, D, E, F, G, H, I) where
    A: TrustedHashEq,
    B: TrustedHashEq,
    C: TrustedHashEq,
    D: TrustedHashEq,
    E: TrustedHashEq,
    F: TrustedHashEq,
    G: TrustedHashEq,
    H: TrustedHashEq,
    I: TrustedHashEq, 

impl<A, B, C, D, E, F, G, H, I, J: ?Sized> TrustedHashEq for (A, B, C, D, E, F, G, H, I, J) where
    A: TrustedHashEq,
    B: TrustedHashEq,
    C: TrustedHashEq,
    D: TrustedHashEq,
    E: TrustedHashEq,
    F: TrustedHashEq,
    G: TrustedHashEq,
    H: TrustedHashEq,
    I: TrustedHashEq,
    J: TrustedHashEq, 

impl<A, B, C, D, E, F, G, H, I, J, K: ?Sized> TrustedHashEq for (A, B, C, D, E, F, G, H, I, J, K) where
    A: TrustedHashEq,
    B: TrustedHashEq,
    C: TrustedHashEq,
    D: TrustedHashEq,
    E: TrustedHashEq,
    F: TrustedHashEq,
    G: TrustedHashEq,
    H: TrustedHashEq,
    I: TrustedHashEq,
    J: TrustedHashEq,
    K: TrustedHashEq, 

impl<A, B, C, D, E, F, G, H, I, J, K, L: ?Sized> TrustedHashEq for (A, B, C, D, E, F, G, H, I, J, K, L) where
    A: TrustedHashEq,
    B: TrustedHashEq,
    C: TrustedHashEq,
    D: TrustedHashEq,
    E: TrustedHashEq,
    F: TrustedHashEq,
    G: TrustedHashEq,
    H: TrustedHashEq,
    I: TrustedHashEq,
    J: TrustedHashEq,
    K: TrustedHashEq,
    L: TrustedHashEq, 

impl<Idx> TrustedHashEq for Range<Idx> where
    Idx: TrustedHashEq, 

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

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

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

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

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

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

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

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

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

impl<Ret, A> TrustedHashEq for fn(_: A) -> Ret

impl<Ret, A> TrustedHashEq for extern "C" fn(_: A) -> Ret

impl<Ret, A> TrustedHashEq for extern "C" fn(_: A, ...) -> Ret

impl<Ret, A> TrustedHashEq for unsafe fn(_: A) -> Ret

impl<Ret, A> TrustedHashEq for unsafe extern "C" fn(_: A) -> Ret

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

impl<Ret, A, B> TrustedHashEq for fn(_: A, _: B) -> Ret

impl<Ret, A, B> TrustedHashEq for extern "C" fn(_: A, _: B) -> Ret

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

impl<Ret, A, B> TrustedHashEq for unsafe fn(_: A, _: B) -> Ret

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

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

impl<Ret, A, B, C> TrustedHashEq for fn(_: A, _: B, _: C) -> Ret

impl<Ret, A, B, C> TrustedHashEq for extern "C" fn(_: A, _: B, _: C) -> Ret

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

impl<Ret, A, B, C> TrustedHashEq for unsafe fn(_: A, _: B, _: C) -> Ret

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

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

impl<Ret, A, B, C, D> TrustedHashEq for fn(_: A, _: B, _: C, _: D) -> Ret

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

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

impl<Ret, A, B, C, D> TrustedHashEq for unsafe fn(_: A, _: B, _: C, _: D) -> Ret

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

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

impl<Ret, A, B, C, D, E> TrustedHashEq for fn(_: A, _: B, _: C, _: D, _: E) -> Ret

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<Ret, A, B, C, D, E, F, G, H, I> TrustedHashEq 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> TrustedHashEq 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> TrustedHashEq for unsafe fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I> TrustedHashEq 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> TrustedHashEq 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> TrustedHashEq 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> TrustedHashEq 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> TrustedHashEq 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> TrustedHashEq 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> TrustedHashEq 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> TrustedHashEq 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, K> TrustedHashEq 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> TrustedHashEq 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> TrustedHashEq 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> TrustedHashEq 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> TrustedHashEq 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> TrustedHashEq 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, L> TrustedHashEq 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> TrustedHashEq 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> TrustedHashEq 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> TrustedHashEq 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> TrustedHashEq 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> TrustedHashEq for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L, ...) -> Ret

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

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

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

impl<T: ?Sized> TrustedHashEq for *const T

impl<T: ?Sized> TrustedHashEq for *mut T

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

impl<T: ?Sized> TrustedHashEq for Box<T> where
    T: TrustedHashEq, 

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

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

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

impl<T: ?Sized> TrustedHashEq for PhantomData<T>

impl<T> TrustedHashEq for Discriminant<T>

impl<T> TrustedHashEq for ManuallyDrop<T> where
    T: TrustedHashEq, 

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

impl<T: ?Sized> TrustedHashEq for NonNull<T>

impl<T: ?Sized> TrustedHashEq for Rc<T> where
    T: TrustedHashEq, 

impl<T: ?Sized> TrustedHashEq for Arc<T> where
    T: TrustedHashEq, 

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

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

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

Implementors