Trait StableHashEq 

pub trait StableHashEq:
    Hash
    + Eq
    + Sealed { }

Sealed trait for types in std that are known to implement Hash and Eq deterministically.

Furthermore, if T: Clone + StableHashEq, then T::clone is deterministic too, in the sense that the behavior with regards to Hash and Eq methods stays consistent between both clones.

This trait is sealed and cannot be implemented outside of the evmap crate.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl StableHashEq for Ordering

impl StableHashEq for Infallible

impl StableHashEq for IpAddr

impl StableHashEq for SocketAddr

impl StableHashEq for Ordering

impl StableHashEq for ErrorKind

impl StableHashEq for bool

impl StableHashEq for char

impl StableHashEq for i8

impl StableHashEq for i16

impl StableHashEq for i32

impl StableHashEq for i64

impl StableHashEq for i128

impl StableHashEq for isize

impl StableHashEq for str

impl StableHashEq for u8

impl StableHashEq for u16

impl StableHashEq for u32

impl StableHashEq for u64

impl StableHashEq for u128

impl StableHashEq for ()

impl StableHashEq for usize

impl StableHashEq for CString

impl StableHashEq for String

impl StableHashEq for TypeId

impl StableHashEq for CStr

impl StableHashEq for Error

impl StableHashEq for PhantomPinned

impl StableHashEq for Ipv4Addr

impl StableHashEq for Ipv6Addr

impl StableHashEq for SocketAddrV4

impl StableHashEq for SocketAddrV6

impl StableHashEq for RangeFull

impl StableHashEq for Duration

impl StableHashEq for OsStr

impl StableHashEq for OsString

impl StableHashEq for FileType

impl StableHashEq for Path

impl StableHashEq for PathBuf

impl StableHashEq for ThreadId

impl StableHashEq for Instant

impl StableHashEq for SystemTime

impl StableHashEq for NonZeroI8

impl StableHashEq for NonZeroI16

impl StableHashEq for NonZeroI32

impl StableHashEq for NonZeroI64

impl StableHashEq for NonZeroI128

impl StableHashEq for NonZeroIsize

impl StableHashEq for NonZeroU8

impl StableHashEq for NonZeroU16

impl StableHashEq for NonZeroU32

impl StableHashEq for NonZeroU64

impl StableHashEq for NonZeroU128

impl StableHashEq for NonZeroUsize

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

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

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

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

impl<'a> StableHashEq for Component<'a>

impl<'a> StableHashEq for Prefix<'a>

impl<'a> StableHashEq for PrefixComponent<'a>

impl<'a, T> StableHashEq for Cow<'a, [T]>

where T: Clone + StableHashEq,

impl<'a, T> StableHashEq for Cow<'a, T>

where T: Clone + StableHashEq,

impl<'a, T> StableHashEq for &'a T

where T: StableHashEq + ?Sized,

impl<'a, T> StableHashEq for &'a mut T

where T: StableHashEq + ?Sized,

impl<A> StableHashEq for (A,)

where A: StableHashEq,

impl<A, B> StableHashEq for (A, B)

where A: StableHashEq, B: StableHashEq,

impl<A, B, C> StableHashEq for (A, B, C)

where A: StableHashEq, B: StableHashEq, C: StableHashEq,

impl<A, B, C, D> StableHashEq for (A, B, C, D)

where A: StableHashEq, B: StableHashEq, C: StableHashEq, D: StableHashEq,

impl<A, B, C, D, E> StableHashEq for (A, B, C, D, E)

where A: StableHashEq, B: StableHashEq, C: StableHashEq, D: StableHashEq, E: StableHashEq,

impl<A, B, C, D, E, F> StableHashEq for (A, B, C, D, E, F)

where A: StableHashEq, B: StableHashEq, C: StableHashEq, D: StableHashEq, E: StableHashEq, F: StableHashEq,

impl<A, B, C, D, E, F, G> StableHashEq for (A, B, C, D, E, F, G)

where A: StableHashEq, B: StableHashEq, C: StableHashEq, D: StableHashEq, E: StableHashEq, F: StableHashEq, G: StableHashEq,

impl<A, B, C, D, E, F, G, H> StableHashEq for (A, B, C, D, E, F, G, H)

where A: StableHashEq, B: StableHashEq, C: StableHashEq, D: StableHashEq, E: StableHashEq, F: StableHashEq, G: StableHashEq, H: StableHashEq,

impl<A, B, C, D, E, F, G, H, I> StableHashEq for (A, B, C, D, E, F, G, H, I)

where A: StableHashEq, B: StableHashEq, C: StableHashEq, D: StableHashEq, E: StableHashEq, F: StableHashEq, G: StableHashEq, H: StableHashEq, I: StableHashEq,

impl<A, B, C, D, E, F, G, H, I, J> StableHashEq for (A, B, C, D, E, F, G, H, I, J)

where A: StableHashEq, B: StableHashEq, C: StableHashEq, D: StableHashEq, E: StableHashEq, F: StableHashEq, G: StableHashEq, H: StableHashEq, I: StableHashEq, J: StableHashEq,

impl<A, B, C, D, E, F, G, H, I, J, K> StableHashEq for (A, B, C, D, E, F, G, H, I, J, K)

where A: StableHashEq, B: StableHashEq, C: StableHashEq, D: StableHashEq, E: StableHashEq, F: StableHashEq, G: StableHashEq, H: StableHashEq, I: StableHashEq, J: StableHashEq, K: StableHashEq,

impl<A, B, C, D, E, F, G, H, I, J, K, L> StableHashEq for (A, B, C, D, E, F, G, H, I, J, K, L)

where A: StableHashEq, B: StableHashEq, C: StableHashEq, D: StableHashEq, E: StableHashEq, F: StableHashEq, G: StableHashEq, H: StableHashEq, I: StableHashEq, J: StableHashEq, K: StableHashEq, L: StableHashEq,

impl<Idx> StableHashEq for Range<Idx>

where Idx: StableHashEq,

impl<Idx> StableHashEq for RangeFrom<Idx>

where Idx: StableHashEq,

impl<Idx> StableHashEq for RangeInclusive<Idx>

where Idx: StableHashEq,

impl<Idx> StableHashEq for RangeTo<Idx>

where Idx: StableHashEq,

impl<Idx> StableHashEq for RangeToInclusive<Idx>

where Idx: StableHashEq,

impl<K, V> StableHashEq for BTreeMap<K, V>

where K: StableHashEq, V: StableHashEq,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<T> StableHashEq for Bound<T>

where T: StableHashEq,

impl<T> StableHashEq for Option<T>

where T: StableHashEq,

impl<T> StableHashEq for Poll<T>

where T: StableHashEq,

impl<T> StableHashEq for [T; 0]

where T: StableHashEq,

impl<T> StableHashEq for [T; 1]

where T: StableHashEq,

impl<T> StableHashEq for [T; 2]

where T: StableHashEq,

impl<T> StableHashEq for [T; 3]

where T: StableHashEq,

impl<T> StableHashEq for [T; 4]

where T: StableHashEq,

impl<T> StableHashEq for [T; 5]

where T: StableHashEq,

impl<T> StableHashEq for [T; 6]

where T: StableHashEq,

impl<T> StableHashEq for [T; 7]

where T: StableHashEq,

impl<T> StableHashEq for [T; 8]

where T: StableHashEq,

impl<T> StableHashEq for [T; 9]

where T: StableHashEq,

impl<T> StableHashEq for [T; 10]

where T: StableHashEq,

impl<T> StableHashEq for [T; 11]

where T: StableHashEq,

impl<T> StableHashEq for [T; 12]

where T: StableHashEq,

impl<T> StableHashEq for [T; 13]

where T: StableHashEq,

impl<T> StableHashEq for [T; 14]

where T: StableHashEq,

impl<T> StableHashEq for [T; 15]

where T: StableHashEq,

impl<T> StableHashEq for [T; 16]

where T: StableHashEq,

impl<T> StableHashEq for [T; 17]

where T: StableHashEq,

impl<T> StableHashEq for [T; 18]

where T: StableHashEq,

impl<T> StableHashEq for [T; 19]

where T: StableHashEq,

impl<T> StableHashEq for [T; 20]

where T: StableHashEq,

impl<T> StableHashEq for [T; 21]

where T: StableHashEq,

impl<T> StableHashEq for [T; 22]

where T: StableHashEq,

impl<T> StableHashEq for [T; 23]

where T: StableHashEq,

impl<T> StableHashEq for [T; 24]

where T: StableHashEq,

impl<T> StableHashEq for [T; 25]

where T: StableHashEq,

impl<T> StableHashEq for [T; 26]

where T: StableHashEq,

impl<T> StableHashEq for [T; 27]

where T: StableHashEq,

impl<T> StableHashEq for [T; 28]

where T: StableHashEq,

impl<T> StableHashEq for [T; 29]

where T: StableHashEq,

impl<T> StableHashEq for [T; 30]

where T: StableHashEq,

impl<T> StableHashEq for [T; 31]

where T: StableHashEq,

impl<T> StableHashEq for [T; 32]

where T: StableHashEq,

impl<T> StableHashEq for [T]

where T: StableHashEq,

impl<T> StableHashEq for Box<T>

where T: StableHashEq + ?Sized,

impl<T> StableHashEq for BTreeSet<T>

where T: StableHashEq,

impl<T> StableHashEq for LinkedList<T>

where T: StableHashEq,

impl<T> StableHashEq for VecDeque<T>

where T: StableHashEq,

impl<T> StableHashEq for Rc<T>

where T: StableHashEq + ?Sized,

impl<T> StableHashEq for Arc<T>

where T: StableHashEq + ?Sized,

impl<T> StableHashEq for Vec<T>

where T: StableHashEq,

impl<T> StableHashEq for Reverse<T>

where T: StableHashEq,

impl<T> StableHashEq for ManuallyDrop<T>

where T: StableHashEq,

impl<T> StableHashEq for Discriminant<T>

impl<T> StableHashEq for Wrapping<T>

where T: StableHashEq,

impl<T, E> StableHashEq for Result<T, E>

where T: StableHashEq, E: StableHashEq,

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

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

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

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

Implementors