Trait sp_std::hash::Hash

pub trait Hash {
    fn hash<H>(&self, state: &mut H)
    where
        H: Hasher;

    fn hash_slice<H>(data: &[Self], state: &mut H)
    where
        H: Hasher,
    { ... }
}

A hashable type.

Types implementing Hash are able to be hashed with an instance of Hasher.

Implementing Hash

You can derive Hash with #[derive(Hash)] if all fields implement Hash. The resulting hash will be the combination of the values from calling hash on each field.

#[derive(Hash)]
struct Rustacean {
    name: String,
    country: String,
}

If you need more control over how a value is hashed, you can of course implement the Hash trait yourself:

use std::hash::{Hash, Hasher};

struct Person {
    id: u32,
    name: String,
    phone: u64,
}

impl Hash for Person {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.id.hash(state);
        self.phone.hash(state);
    }
}

Hash and Eq

When implementing both Hash and Eq, it is important that the following property holds:

k1 == k2 -> hash(k1) == hash(k2)

In other words, if two keys are equal, their hashes must also be equal. HashMap and HashSet both rely on this behavior.

Thankfully, you won’t need to worry about upholding this property when deriving both Eq and Hash with #[derive(PartialEq, Eq, Hash)].

Prefix collisions

Implementations of hash should ensure that the data they pass to the Hasher are prefix-free. That is, unequal values should cause two different sequences of values to be written, and neither of the two sequences should be a prefix of the other.

For example, the standard implementation of Hash for &str passes an extra 0xFF byte to the Hasher so that the values ("ab", "c") and ("a", "bc") hash differently.

Portability

Due to differences in endianness and type sizes, data fed by Hash to a Hasher should not be considered portable across platforms. Additionally the data passed by most standard library types should not be considered stable between compiler versions.

This means tests shouldn’t probe hard-coded hash values or data fed to a Hasher and instead should check consistency with Eq.

Serialization formats intended to be portable between platforms or compiler versions should either avoid encoding hashes or only rely on Hash and Hasher implementations that provide additional guarantees.

Required methods

fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

Feeds this value into the given Hasher.

Examples

use std::collections::hash_map::DefaultHasher;
use std::hash::{Hash, Hasher};

let mut hasher = DefaultHasher::new();
7920.hash(&mut hasher);
println!("Hash is {:x}!", hasher.finish());

Provided methods

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

This method is meant as a convenience, but its implementation is also explicitly left unspecified. It isn’t guaranteed to be equivalent to repeated calls of hash and implementations of Hash should keep that in mind and call hash themselves if the slice isn’t treated as a whole unit in the PartialEq implementation.

For example, a VecDeque implementation might naïvely call as_slices and then hash_slice on each slice, but this is wrong since the two slices can change with a call to make_contiguous without affecting the PartialEq result. Since these slices aren’t treated as singular units, and instead part of a larger deque, this method cannot be used.

Examples

use std::collections::hash_map::DefaultHasher;
use std::hash::{Hash, Hasher};

let mut hasher = DefaultHasher::new();
let numbers = [6, 28, 496, 8128];
Hash::hash_slice(&numbers, &mut hasher);
println!("Hash is {:x}!", hasher.finish());

Implementations on Foreign Types

impl Hash for Instant

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for Ipv6MulticastScope

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for Path

pub fn hash<H>(&self, h: &mut H) where
    H: Hasher, 

impl Hash for OsString

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

impl<'a> Hash for Prefix<'a>

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for SocketAddrV6

pub fn hash<H>(&self, s: &mut H) where
    H: Hasher, 

impl Hash for ErrorKind

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for Ipv4Addr

pub fn hash<H>(&self, s: &mut H) where
    H: Hasher, 

impl Hash for ThreadId

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for UCred

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for OsStr

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

impl Hash for CStr

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<'a> Hash for Component<'a>

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for SocketAddr

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for Ipv6Addr

pub fn hash<H>(&self, s: &mut H) where
    H: Hasher, 

impl Hash for PathBuf

pub fn hash<H>(&self, h: &mut H) where
    H: Hasher, 

impl Hash for SystemTime

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<'_> Hash for PrefixComponent<'_>

pub fn hash<H>(&self, h: &mut H) where
    H: Hasher, 

impl Hash for SocketAddrV4

pub fn hash<H>(&self, s: &mut H) where
    H: Hasher, 

impl Hash for CString

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for IpAddr

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for FileType

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl Hash for i16

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

pub fn hash_slice<H>(data: &[i16], state: &mut H) where
    H: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<S>(&self, state: &mut S) where
    S: Hasher, 

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Hash for unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<S>(&self, state: &mut S) where
    S: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl Hash for Which

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl Hash for char

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl Hash for u8

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

pub fn hash_slice<H>(data: &[u8], state: &mut H) where
    H: Hasher, 

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Hash for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl<T, const LANES: usize> Hash for Simd<T, LANES> where
    T: SimdElement + Hash,
    LaneCount<LANES>: SupportedLaneCount, 

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl Hash for isize

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

pub fn hash_slice<H>(data: &[isize], state: &mut H) where
    H: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Hash for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<S>(&self, state: &mut S) where
    S: Hasher, 

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

pub fn hash<S>(&self, state: &mut S) where
    S: Hasher, 

impl Hash for !

pub fn hash<H>(&self, &mut H) where
    H: Hasher, 

impl Hash for i32

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

pub fn hash_slice<H>(data: &[i32], state: &mut H) where
    H: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Hash for fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl<'a> Hash for Location<'a>

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl<'_, T> Hash for &'_ mut T where
    T: Hash + ?Sized, 

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<S>(&self, state: &mut S) where
    S: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl Hash for ()

pub fn hash<H>(&self, _state: &mut H) where
    H: Hasher, 

impl Hash for u32

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

pub fn hash_slice<H>(data: &[u32], state: &mut H) where
    H: Hasher, 

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

pub fn hash<S>(&self, state: &mut S) where
    S: Hasher, 

impl Hash for i64

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

pub fn hash_slice<H>(data: &[i64], state: &mut H) where
    H: Hasher, 

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

pub fn hash<S>(&self, state: &mut S) where
    S: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl<'_, T> Hash for &'_ T where
    T: Hash + ?Sized, 

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

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

pub fn hash<S>(&self, state: &mut S) where
    S: Hasher, 

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

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

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

The hash of an array is the same as that of the corresponding slice, as required by the Borrow implementation.

#![feature(build_hasher_simple_hash_one)]
use std::hash::BuildHasher;

let b = std::collections::hash_map::RandomState::new();
let a: [u8; 3] = [0xa8, 0x3c, 0x09];
let s: &[u8] = &[0xa8, 0x3c, 0x09];
assert_eq!(b.hash_one(a), b.hash_one(s));

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Hash for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl Hash for u128

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

pub fn hash_slice<H>(data: &[u128], state: &mut H) where
    H: Hasher, 

impl Hash for i128

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

pub fn hash_slice<H>(data: &[i128], state: &mut H) where
    H: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl Hash for usize

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

pub fn hash_slice<H>(data: &[usize], state: &mut H) where
    H: Hasher, 

impl Hash for i8

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

pub fn hash_slice<H>(data: &[i8], state: &mut H) where
    H: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl Hash for str

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Hash for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<S>(&self, state: &mut S) where
    S: Hasher, 

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

pub fn hash<S>(&self, state: &mut S) where
    S: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl Hash for Duration

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl Hash for u16

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

pub fn hash_slice<H>(data: &[u16], state: &mut H) where
    H: Hasher, 

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

pub fn hash<S>(&self, state: &mut S) where
    S: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl Hash for bool

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

impl Hash for u64

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

pub fn hash_slice<H>(data: &[u64], state: &mut H) where
    H: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<S>(&self, state: &mut S) where
    S: Hasher, 

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

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Hash for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

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

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

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

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

impl Hash for String

pub fn hash<H>(&self, hasher: &mut H) where
    H: Hasher, 

Implementors

impl Hash for sp_std::cmp::Ordering

impl Hash for Infallible

impl Hash for sp_std::sync::atomic::Ordering

impl Hash for TypeId

impl Hash for Error

impl Hash for PhantomPinned

impl Hash for NonZeroI8

impl Hash for NonZeroI16

impl Hash for NonZeroI32

impl Hash for NonZeroI64

impl Hash for NonZeroI128

impl Hash for NonZeroIsize

impl Hash for NonZeroU8

impl Hash for NonZeroU16

impl Hash for NonZeroU32

impl Hash for NonZeroU64

impl Hash for NonZeroU128

impl Hash for NonZeroUsize

impl Hash for RangeFull

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

impl<Dyn> Hash for DynMetadata<Dyn> where
    Dyn: ?Sized, 

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

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

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

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

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

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

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

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

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

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

impl<T> Hash for Discriminant<T>

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

impl<T> Hash for Saturating<T> where
    T: Hash, 

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

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

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

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

impl<T, A> Hash for Box<T, A> where
    T: Hash + ?Sized,
    A: Allocator, 

impl<T, A> Hash for VecDeque<T, A> where
    T: Hash,
    A: Allocator, 

impl<T, A> Hash for Vec<T, A> where
    T: Hash,
    A: Allocator, 

The hash of a vector is the same as that of the corresponding slice, as required by the core::borrow::Borrow implementation.

#![feature(build_hasher_simple_hash_one)]
use std::hash::BuildHasher;

let b = std::collections::hash_map::RandomState::new();
let v: Vec<u8> = vec![0xa8, 0x3c, 0x09];
let s: &[u8] = &[0xa8, 0x3c, 0x09];
assert_eq!(b.hash_one(v), b.hash_one(s));

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

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

impl Hash for Error

impl Hash for Match

impl<T, const CAP: usize> Hash for ArrayVec<T, CAP> where
    T: Hash, 

impl<const CAP: usize> Hash for ArrayString<CAP>

impl Hash for TaskId

impl Hash for Path

impl Hash for PathBuf

impl<O, V> Hash for BitArray<O, V> where
    O: BitOrder,
    V: BitView, 

impl<R: Hash> Hash for BitIdx<R> where
    R: BitRegister, 

impl<R: Hash> Hash for BitIdxError<R> where
    R: BitRegister, 

impl<R: Hash> Hash for BitTail<R> where
    R: BitRegister, 

impl<R: Hash> Hash for BitPos<R> where
    R: BitRegister, 

impl<R: Hash> Hash for BitSel<R> where
    R: BitRegister, 

impl<R: Hash> Hash for BitMask<R> where
    R: BitRegister, 

impl Hash for Lsb0

impl Hash for Msb0

impl<M, T> Hash for Address<M, T> where
    M: Mutability,
    T: BitStore, 

impl<T: Hash> Hash for AddressError<T> where
    T: BitStore, 

impl<M, O, T> Hash for BitRef<'_, M, O, T> where
    M: Mutability,
    O: BitOrder,
    T: BitStore, 

impl<M, O, T> Hash for BitPtrRange<M, O, T> where
    M: Mutability,
    O: BitOrder,
    T: BitStore, 

impl<M, O, T> Hash for BitPtr<M, O, T> where
    M: Mutability,
    O: BitOrder,
    T: BitStore, 

impl<T: Hash> Hash for BitPtrError<T> where
    T: BitStore,
    T::Mem: Hash, 

impl<O, T> Hash for BitSlice<O, T> where
    O: BitOrder,
    T: BitStore, 

impl<O, T> Hash for BitBox<O, T> where
    O: BitOrder,
    T: BitStore, 

impl<O, T> Hash for BitVec<O, T> where
    O: BitOrder,
    T: BitStore, 

impl Hash for BStr

impl Hash for BString

impl Hash for BigEndian

impl Hash for LittleEndian

impl Hash for Bytes

impl Hash for BytesMut

impl<T: Hash> Hash for CachePadded<T>

impl<T: Hash> Hash for LocalResult<T>

impl Hash for FixedOffset

impl Hash for NaiveDate

impl Hash for NaiveDateTime

impl Hash for NaiveTime

impl<Tz: TimeZone> Hash for Date<Tz>

impl<Tz: TimeZone> Hash for DateTime<Tz>

impl Hash for Weekday

impl Hash for Month

impl<const S: usize> Hash for Cid<S>

impl Hash for Version

impl Hash for ErrorKind

impl Hash for CvQualifiers

impl<'a> Hash for &'a TemplateParam

impl Hash for Error

impl Hash for DemangleNodeType

impl Hash for AtomicRmwOp

impl Hash for ConstantData

impl Hash for Block

impl Hash for Value

impl Hash for Inst

impl Hash for StackSlot

impl Hash for GlobalValue

impl Hash for Constant

impl Hash for Immediate

impl Hash for JumpTable

impl Hash for FuncRef

impl Hash for SigRef

impl Hash for Heap

impl Hash for Table

impl Hash for AnyEntity

impl Hash for Signature

impl Hash for AbiParam

impl Hash for ArgumentExtension

impl Hash for ArgumentPurpose

impl Hash for Imm64

impl Hash for Uimm64

impl Hash for Uimm32

impl Hash for V128Imm

impl Hash for Offset32

impl Hash for Ieee32

impl Hash for Ieee64

impl Hash for Opcode

impl Hash for LibCall

impl Hash for Endianness

impl Hash for MemFlags

impl Hash for TrapCode

impl Hash for Type

impl Hash for ArgumentLoc

impl Hash for ValueLabel

impl Hash for CallConv

impl Hash for TargetFrontendConfig

impl Hash for Loop

impl Hash for LoweredBlock

impl Hash for MachLabel

impl Hash for Builder

impl Hash for Template

impl Hash for Descriptor

impl Hash for Detail

impl Hash for Regalloc

impl Hash for OptLevel

impl Hash for TlsModel

impl Hash for LibcallCallConv

impl Hash for IntCC

impl Hash for FloatCC

impl<T: Hash + ReservedValue> Hash for PackedOption<T>

impl<K: Hash, V: Hash> Hash for PrimaryMap<K, V> where
    K: EntityRef, 

impl Hash for WasmType

impl Hash for WasmFuncType

impl Hash for FuncIndex

impl Hash for DefinedFuncIndex

impl Hash for DefinedTableIndex

impl Hash for DefinedMemoryIndex

impl Hash for DefinedGlobalIndex

impl Hash for TableIndex

impl Hash for GlobalIndex

impl Hash for MemoryIndex

impl Hash for SignatureIndex

impl Hash for DataIndex

impl Hash for ElemIndex

impl Hash for TypeIndex

impl Hash for ModuleIndex

impl Hash for InstanceIndex

impl Hash for EventIndex

impl Hash for ModuleTypeIndex

impl Hash for InstanceTypeIndex

impl Hash for EntityIndex

impl Hash for Global

impl Hash for GlobalInit

impl Hash for Table

impl Hash for TableElementType

impl Hash for Memory

impl Hash for Event

impl<T: Hash> Hash for CachePadded<T>

impl Hash for Scalar

impl Hash for MontgomeryPoint

impl Hash for CompressedEdwardsY

impl Hash for CompressedRistretto

impl<L: Hash, R: Hash> Hash for Either<L, R>

impl Hash for Target

impl Hash for WriteStyle

impl Hash for Errno

impl<E: Hash> Hash for Compat<E>

impl Hash for WithdrawReasons

impl Hash for FsStats

impl<T: Hash> Hash for AssertAsync<T>

impl Hash for PollNext

impl<T: Hash> Hash for AllowStdIo<T>

impl<T: Hash, N> Hash for GenericArray<T, N> where
    N: ArrayLength<T>, 

impl Hash for Format

impl Hash for Encoding

impl Hash for LineEncoding

impl Hash for Register

impl<T: Hash> Hash for DebugAbbrevOffset<T>

impl<T: Hash> Hash for DebugInfoOffset<T>

impl<T: Hash> Hash for LocationListsOffset<T>

impl<T: Hash> Hash for DebugMacinfoOffset<T>

impl<T: Hash> Hash for DebugMacroOffset<T>

impl<T: Hash> Hash for RawRangeListsOffset<T>

impl<T: Hash> Hash for RangeListsOffset<T>

impl<T: Hash> Hash for DebugTypesOffset<T>

impl Hash for DebugTypeSignature

impl<T: Hash> Hash for DebugFrameOffset<T>

impl<T: Hash> Hash for EhFrameOffset<T>

impl<T: Hash> Hash for UnitSectionOffset<T>

impl Hash for SectionId

impl Hash for DwoId

impl Hash for DwUt

impl Hash for DwCfa

impl Hash for DwChildren

impl Hash for DwTag

impl Hash for DwAt

impl Hash for DwForm

impl Hash for DwAte

impl Hash for DwLle

impl Hash for DwDs

impl Hash for DwEnd

impl Hash for DwAccess

impl Hash for DwVis

impl Hash for DwVirtuality

impl Hash for DwLang

impl Hash for DwAddr

impl Hash for DwId

impl Hash for DwCc

impl Hash for DwInl

impl Hash for DwOrd

impl Hash for DwDsc

impl Hash for DwIdx

impl Hash for DwDefaulted

impl Hash for DwLns

impl Hash for DwLne

impl Hash for DwLnct

impl Hash for DwMacro

impl Hash for DwRle

impl Hash for DwOp

impl Hash for DwEhPe

impl Hash for RunTimeEndian

impl Hash for LittleEndian

impl Hash for BigEndian

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

impl<R: Hash + Reader> Hash for LocationListEntry<R>

impl<R: Hash + Reader> Hash for Expression<R>

impl Hash for Range

impl<T: Hash> Hash for UnitOffset<T>

impl Hash for Glob

impl Hash for StreamId

impl Hash for HeaderName

impl Hash for HeaderValue

impl Hash for Method

impl Hash for StatusCode

impl Hash for Authority

impl Hash for Scheme

impl Hash for Uri

impl Hash for Version

impl Hash for Duration

impl Hash for Name

impl Hash for IfEvent

impl Hash for IpNetwork

impl Hash for Ipv4Network

impl Hash for Ipv6MulticastScope

impl Hash for Ipv6Network

impl Hash for IpAddrRange

impl Hash for Ipv4AddrRange

impl Hash for Ipv6AddrRange

impl Hash for IpNet

impl Hash for Ipv4Net

impl Hash for Ipv6Net

impl Hash for IpSubnets

impl Hash for Ipv4Subnets

impl Hash for Ipv6Subnets

impl<A: Hash, B: Hash> Hash for EitherOrBoth<A, B>

impl Hash for Id

impl Hash for Version

impl Hash for RandomStringIdProvider

impl Hash for SubscriptionId

impl Hash for OriginProtocol

impl Hash for Origin

impl Hash for Port

impl Hash for Host

impl Hash for PeerId

impl Hash for ListenerId

impl Hash for ConnectionId

impl Hash for Endpoint

impl Hash for ConnectedPoint

impl Hash for FloodsubRpc

impl Hash for FloodsubMessage

impl Hash for FloodsubSubscription

impl Hash for FloodsubSubscriptionAction

impl Hash for Topic

impl Hash for TopicHash

impl Hash for MessageId

impl Hash for FastMessageId

impl Hash for RawGossipsubMessage

impl Hash for GossipsubMessage

impl Hash for GossipsubRpc

impl<T> Hash for Key<T>

impl Hash for KadConnectionType

impl Hash for Key

impl Hash for ProviderRecord

impl Hash for QueryId

impl Hash for RequestId

impl Hash for AddressScore

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

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

impl<'k> Hash for Key<'k>

impl Hash for Level

impl Hash for LevelFilter

impl<'a> Hash for Metadata<'a>

impl<'a> Hash for MetadataBuilder<'a>

impl Hash for ByteSlice

impl Hash for ByteVec

impl Hash for Type

impl Hash for Tag

impl Hash for CompressionStrategy

impl Hash for TDEFLFlush

impl Hash for TDEFLStatus

impl Hash for CompressionLevel

impl Hash for TINFLStatus

impl Hash for MZFlush

impl Hash for MZStatus

impl Hash for MZError

impl Hash for DataFormat

impl Hash for StreamResult

impl Hash for Token

impl<const S: usize> Hash for Multihash<S>

impl<T: Hash + Scalar> Hash for X<T>

impl<T: Hash + Scalar> Hash for XY<T>

impl<T: Hash + Scalar> Hash for XYZ<T>

impl<T: Hash + Scalar> Hash for XYZW<T>

impl<T: Hash + Scalar> Hash for XYZWA<T>

impl<T: Hash + Scalar> Hash for XYZWAB<T>

impl<T: Hash + Scalar> Hash for IJKW<T>

impl<T: Hash + Scalar> Hash for M2x2<T>

impl<T: Hash + Scalar> Hash for M2x3<T>

impl<T: Hash + Scalar> Hash for M2x4<T>

impl<T: Hash + Scalar> Hash for M2x5<T>

impl<T: Hash + Scalar> Hash for M2x6<T>

impl<T: Hash + Scalar> Hash for M3x2<T>

impl<T: Hash + Scalar> Hash for M3x3<T>

impl<T: Hash + Scalar> Hash for M3x4<T>

impl<T: Hash + Scalar> Hash for M3x5<T>

impl<T: Hash + Scalar> Hash for M3x6<T>

impl<T: Hash + Scalar> Hash for M4x2<T>

impl<T: Hash + Scalar> Hash for M4x3<T>

impl<T: Hash + Scalar> Hash for M4x4<T>

impl<T: Hash + Scalar> Hash for M4x5<T>

impl<T: Hash + Scalar> Hash for M4x6<T>

impl<T: Hash + Scalar> Hash for M5x2<T>

impl<T: Hash + Scalar> Hash for M5x3<T>

impl<T: Hash + Scalar> Hash for M5x4<T>

impl<T: Hash + Scalar> Hash for M5x5<T>

impl<T: Hash + Scalar> Hash for M5x6<T>

impl<T: Hash + Scalar> Hash for M6x2<T>

impl<T: Hash + Scalar> Hash for M6x3<T>

impl<T: Hash + Scalar> Hash for M6x4<T>

impl<T: Hash + Scalar> Hash for M6x5<T>

impl<T: Hash + Scalar> Hash for M6x6<T>

impl<const R: usize> Hash for Const<R>

impl<T: Hash, const R: usize, const C: usize> Hash for ArrayStorage<T, R, C>

impl<T, R, C, S> Hash for Matrix<T, R, C, S> where
    T: Scalar + Hash,
    R: Dim,
    C: Dim,
    S: Storage<T, R, C>, 

impl<T: Hash> Hash for Unit<T>

impl<T: Scalar + Hash, const D: usize> Hash for Point<T, D>

impl<T: Scalar + Hash, const D: usize> Hash for Rotation<T, D> where
    <DefaultAllocator as Allocator<T, Const<D>, Const<D>>>::Buffer: Hash, 

impl<T: Scalar + Hash> Hash for Quaternion<T>

impl<T: Scalar + Hash, const D: usize> Hash for Translation<T, D> where
    Owned<T, Const<D>>: Hash, 

impl<T: Scalar + Hash, R: Hash, const D: usize> Hash for Isometry<T, R, D> where
    Owned<T, Const<D>>: Hash, 

impl<T: Scalar + Hash, R: Hash, const D: usize> Hash for Similarity<T, R, D> where
    Owned<T, Const<D>>: Hash, 

impl Hash for TGeneral

impl Hash for TProjective

impl Hash for TAffine

impl Hash for Sign

impl Hash for BigInt

impl Hash for BigUint

impl<T: Hash> Hash for Complex<T>

impl<T: Clone + Integer + Hash> Hash for Ratio<T>

impl Hash for Architecture

impl Hash for AddressSize

impl Hash for BinaryFormat

impl Hash for SectionKind

impl Hash for ComdatKind

impl Hash for SymbolKind

impl Hash for SymbolScope

impl Hash for RelocationKind

impl Hash for RelocationEncoding

impl Hash for FileFlags

impl Hash for SectionFlags

impl<Section: Hash> Hash for SymbolFlags<Section>

impl Hash for Endianness

impl Hash for LittleEndian

impl Hash for BigEndian

impl<E: Hash + Endian> Hash for U16Bytes<E>

impl<E: Hash + Endian> Hash for U32Bytes<E>

impl<E: Hash + Endian> Hash for U64Bytes<E>

impl<E: Hash + Endian> Hash for I16Bytes<E>

impl<E: Hash + Endian> Hash for I32Bytes<E>

impl<E: Hash + Endian> Hash for I64Bytes<E>

impl Hash for ArchiveKind

impl Hash for FileKind

impl Hash for SectionIndex

impl Hash for SymbolIndex

impl Hash for SymbolSection

impl<'data> Hash for SymbolMapName<'data>

impl<'data> Hash for ObjectMapEntry<'data>

impl Hash for RelocationTarget

impl Hash for CompressionFormat

impl Hash for CompressedFileRange

impl<'data> Hash for CompressedData<'data>

impl<O, T: ?Sized> Hash for OwningRef<O, T> where
    T: Hash, 

impl<O, T: ?Sized> Hash for OwningRefMut<O, T> where
    T: Hash, 

impl Hash for Multiaddr

impl Hash for Type

impl Hash for ValueType

impl Hash for BlockType

impl Hash for FunctionType

impl Hash for Instruction

impl Hash for BrTableData

impl Hash for Sender

impl<R: Hash> Hash for Error<R>

impl<R: Hash> Hash for ErrorVariant<R>

impl Hash for InputLocation

impl Hash for LineColLocation

impl<'i, R: Hash> Hash for Pair<'i, R>

impl<'i, R: Hash> Hash for Pairs<'i, R>

impl<'i> Hash for Position<'i>

impl<'i> Hash for Span<'i>

impl<'i, R: Hash> Hash for Token<'i, R>

impl Hash for Rule

impl Hash for U128

impl Hash for U256

impl Hash for U512

impl Hash for H128

impl Hash for H160

impl Hash for H256

impl Hash for H512

impl Hash for Ident

impl Hash for MetricType

impl Hash for InstructionType

impl Hash for InstIx

impl Hash for BlockIx

impl Hash for Reg

impl Hash for RealReg

impl Hash for VirtualReg

impl<R: Hash + WritableBase> Hash for Writable<R>

impl Hash for SpillSlot

impl Hash for Protection

impl<Header: Hash + HeaderT> Hash for RemoteCallRequest<Header> where
    Header::Hash: Hash, 

impl<Header: Hash + HeaderT> Hash for RemoteHeaderRequest<Header> where
    Header::Hash: Hash,
    Header::Number: Hash, 

impl<Header: Hash + HeaderT> Hash for RemoteReadRequest<Header> where
    Header::Hash: Hash, 

impl<Header: Hash + HeaderT> Hash for RemoteReadChildRequest<Header> where
    Header::Hash: Hash, 

impl<Header: Hash + HeaderT> Hash for RemoteBodyRequest<Header>

impl<T: Hash> Hash for SlotDuration<T>

impl Hash for WasmExecutionMethod

impl Hash for ProtocolId

impl Hash for SetId

impl Hash for IncomingIndex

impl Hash for TelemetryEndpoints

impl Hash for RistrettoBoth

impl Hash for PublicKey

impl Hash for VRFOutput

impl Hash for VRFInOut

impl Hash for ChainCode

impl<K: Hash> Hash for ExtendedKey<K>

impl Hash for ECQVCertPublic

impl Hash for MultiSignatureStage

impl Hash for SignatureError

impl Hash for Number

impl Hash for SigId

impl<A: Array> Hash for SmallVec<A> where
    A::Item: Hash, 

impl Hash for OpCode

impl<'a> Hash for Incoming<'a>

impl Hash for Data

impl Hash for Public

impl Hash for Signature

impl Hash for Public

impl Hash for Signature

impl Hash for Public

impl Hash for Signature

impl Hash for DeriveJunction

impl Hash for AccountId32

impl Hash for Dummy

impl Hash for KeyTypeId

impl Hash for CryptoTypeId

impl Hash for CryptoTypePublicPair

impl Hash for Public

impl Hash for Signature

impl Hash for Public

impl Hash for Signature

impl Hash for Public

impl Hash for Signature

impl Hash for HttpRequestId

impl Hash for OffchainOverlayedChange

impl Hash for Bytes

impl Hash for Keyring

impl Hash for Keyring

impl Hash for UintAuthorityId

impl Hash for TestSignature

impl<AccountId: Hash, AccountIndex: Hash> Hash for MultiAddress<AccountId, AccountIndex>

impl Hash for StorageKey

impl Hash for TrackedStorageKey

impl Hash for PrefixedStorageKey

impl Hash for StorageData

impl Hash for ChildInfo

impl Hash for ChildTrieParentKeyId

impl Hash for ParseError

impl Hash for Underscore

impl Hash for Abstract

impl Hash for As

impl Hash for Async

impl Hash for Auto

impl Hash for Await

impl Hash for Become

impl Hash for Box

impl Hash for Break

impl Hash for Const

impl Hash for Continue

impl Hash for Crate

impl Hash for Default

impl Hash for Do

impl Hash for Dyn

impl Hash for Else

impl Hash for Enum

impl Hash for Extern

impl Hash for Final

impl Hash for Fn

impl Hash for For

impl Hash for If

impl Hash for Impl

impl Hash for In

impl Hash for Let

impl Hash for Loop

impl Hash for Macro

impl Hash for Match

impl Hash for Mod

impl Hash for Move

impl Hash for Mut

impl Hash for Override

impl Hash for Priv

impl Hash for Pub

impl Hash for Ref

impl Hash for Return

impl Hash for SelfType

impl Hash for SelfValue

impl Hash for Static

impl Hash for Struct

impl Hash for Super

impl Hash for Trait

impl Hash for Try

impl Hash for Type

impl Hash for Typeof

impl Hash for Union

impl Hash for Unsafe

impl Hash for Unsized

impl Hash for Use

impl Hash for Virtual

impl Hash for Where

impl Hash for While

impl Hash for Yield

impl Hash for Add

impl Hash for AddEq

impl Hash for And

impl Hash for AndAnd

impl Hash for AndEq

impl Hash for At

impl Hash for Bang

impl Hash for Caret

impl Hash for CaretEq

impl Hash for Colon

impl Hash for Colon2

impl Hash for Comma

impl Hash for Div

impl Hash for DivEq

impl Hash for Dollar

impl Hash for Dot

impl Hash for Dot2

impl Hash for Dot3

impl Hash for DotDotEq

impl Hash for Eq

impl Hash for EqEq

impl Hash for Ge

impl Hash for Gt

impl Hash for Le

impl Hash for Lt

impl Hash for MulEq

impl Hash for Ne

impl Hash for Or

impl Hash for OrEq

impl Hash for OrOr

impl Hash for Pound

impl Hash for Question

impl Hash for RArrow

impl Hash for LArrow

impl Hash for Rem

impl Hash for RemEq

impl Hash for FatArrow

impl Hash for Semi

impl Hash for Shl

impl Hash for ShlEq

impl Hash for Shr

impl Hash for ShrEq

impl Hash for Star

impl Hash for Sub

impl Hash for SubEq

impl Hash for Tilde

impl Hash for Brace

impl Hash for Bracket

impl Hash for Paren

impl Hash for Group

impl Hash for Member

impl Hash for Index

impl<'a> Hash for ImplGenerics<'a>

impl<'a> Hash for TypeGenerics<'a>

impl<'a> Hash for Turbofish<'a>

impl Hash for Lifetime

impl Hash for LitStr

impl Hash for LitByteStr

impl Hash for LitByte

impl Hash for LitChar

impl Hash for LitInt

impl Hash for LitFloat

impl<T, P> Hash for Punctuated<T, P> where
    T: Hash,
    P: Hash, 

impl Hash for Abi

impl Hash for AngleBracketedGenericArguments

impl Hash for Arm

impl Hash for AttrStyle

impl Hash for Attribute

impl Hash for BareFnArg

impl Hash for BinOp

impl Hash for Binding

impl Hash for Block

impl Hash for BoundLifetimes

impl Hash for ConstParam

impl Hash for Constraint

impl Hash for Data

impl Hash for DataEnum

impl Hash for DataStruct

impl Hash for DataUnion

impl Hash for DeriveInput

impl Hash for Expr

impl Hash for ExprArray

impl Hash for ExprAssign

impl Hash for ExprAssignOp

impl Hash for ExprAsync

impl Hash for ExprAwait

impl Hash for ExprBinary

impl Hash for ExprBlock

impl Hash for ExprBox

impl Hash for ExprBreak

impl Hash for ExprCall

impl Hash for ExprCast

impl Hash for ExprClosure

impl Hash for ExprContinue

impl Hash for ExprField

impl Hash for ExprForLoop

impl Hash for ExprGroup

impl Hash for ExprIf

impl Hash for ExprIndex

impl Hash for ExprLet

impl Hash for ExprLit

impl Hash for ExprLoop

impl Hash for ExprMacro

impl Hash for ExprMatch

impl Hash for ExprMethodCall

impl Hash for ExprParen

impl Hash for ExprPath

impl Hash for ExprRange

impl Hash for ExprReference

impl Hash for ExprRepeat

impl Hash for ExprReturn

impl Hash for ExprStruct

impl Hash for ExprTry

impl Hash for ExprTryBlock

impl Hash for ExprTuple

impl Hash for ExprType

impl Hash for ExprUnary

impl Hash for ExprUnsafe

impl Hash for ExprWhile

impl Hash for ExprYield

impl Hash for Field

impl Hash for FieldPat

impl Hash for FieldValue

impl Hash for Fields

impl Hash for FieldsNamed

impl Hash for FieldsUnnamed

impl Hash for File

impl Hash for FnArg

impl Hash for ForeignItem

impl Hash for ForeignItemFn

impl Hash for ForeignItemMacro

impl Hash for ForeignItemStatic

impl Hash for ForeignItemType

impl Hash for GenericArgument

impl Hash for GenericMethodArgument

impl Hash for GenericParam

impl Hash for Generics

impl Hash for ImplItem

impl Hash for ImplItemConst

impl Hash for ImplItemMacro

impl Hash for ImplItemMethod

impl Hash for ImplItemType

impl Hash for Item

impl Hash for ItemConst

impl Hash for ItemEnum

impl Hash for ItemExternCrate

impl Hash for ItemFn

impl Hash for ItemForeignMod

impl Hash for ItemImpl

impl Hash for ItemMacro

impl Hash for ItemMacro2

impl Hash for ItemMod

impl Hash for ItemStatic

impl Hash for ItemStruct

impl Hash for ItemTrait

impl Hash for ItemTraitAlias

impl Hash for ItemType

impl Hash for ItemUnion

impl Hash for ItemUse

impl Hash for Label

impl Hash for LifetimeDef

impl Hash for Lit

impl Hash for LitBool

impl Hash for Local

impl Hash for Macro

impl Hash for MacroDelimiter

impl Hash for Meta

impl Hash for MetaList

impl Hash for MetaNameValue

impl Hash for MethodTurbofish

impl Hash for NestedMeta

impl Hash for ParenthesizedGenericArguments

impl Hash for Pat

impl Hash for PatBox

impl Hash for PatIdent

impl Hash for PatLit

impl Hash for PatMacro

impl Hash for PatOr

impl Hash for PatPath

impl Hash for PatRange

impl Hash for PatReference

impl Hash for PatRest

impl Hash for PatSlice

impl Hash for PatStruct

impl Hash for PatTuple

impl Hash for PatTupleStruct

impl Hash for PatType

impl Hash for PatWild

impl Hash for Path

impl Hash for PathArguments

impl Hash for PathSegment

impl Hash for PredicateEq

impl Hash for PredicateLifetime

impl Hash for PredicateType

impl Hash for QSelf

impl Hash for RangeLimits

impl Hash for Receiver

impl Hash for ReturnType

impl Hash for Signature

impl Hash for Stmt

impl Hash for TraitBound

impl Hash for TraitBoundModifier

impl Hash for TraitItem

impl Hash for TraitItemConst

impl Hash for TraitItemMacro

impl Hash for TraitItemMethod

impl Hash for TraitItemType

impl Hash for Type

impl Hash for TypeArray

impl Hash for TypeBareFn

impl Hash for TypeGroup

impl Hash for TypeImplTrait

impl Hash for TypeInfer

impl Hash for TypeMacro

impl Hash for TypeNever

impl Hash for TypeParam

impl Hash for TypeParamBound

impl Hash for TypeParen

impl Hash for TypePath

impl Hash for TypePtr

impl Hash for TypeReference

impl Hash for TypeSlice

impl Hash for TypeTraitObject

impl Hash for TypeTuple

impl Hash for UnOp

impl Hash for UseGlob

impl Hash for UseGroup

impl Hash for UseName

impl Hash for UsePath

impl Hash for UseRename

impl Hash for UseTree

impl Hash for Variadic

impl Hash for Variant

impl Hash for VisCrate

impl Hash for VisPublic

impl Hash for VisRestricted

impl Hash for Visibility

impl Hash for WhereClause

impl Hash for WherePredicate

impl Hash for AddBounds

impl Hash for BindStyle

impl<'a> Hash for BindingInfo<'a>

impl<'a> Hash for VariantAst<'a>

impl<'a> Hash for VariantInfo<'a>

impl<'a> Hash for Structure<'a>

impl Hash for Size

impl Hash for CDataModel

impl Hash for Architecture

impl Hash for ArmArchitecture

impl Hash for Aarch64Architecture

impl Hash for Riscv32Architecture

impl Hash for Riscv64Architecture

impl Hash for X86_32Architecture

impl Hash for Mips32Architecture

impl Hash for Mips64Architecture

impl Hash for CustomVendor

impl Hash for Vendor

impl Hash for OperatingSystem

impl Hash for Environment

impl Hash for BinaryFormat

impl Hash for Endianness

impl Hash for PointerWidth

impl Hash for CallingConvention

impl Hash for Triple

impl Hash for Duration

impl Hash for Timespec

impl Hash for Tm

impl<A: Array> Hash for ArrayVec<A> where
    A::Item: Hash, 

impl<'s, T> Hash for SliceVec<'s, T> where
    T: Hash, 

impl<A: Array> Hash for TinyVec<A> where
    A::Item: Hash, 

impl Hash for Instant

impl Hash for BytesCodec

impl Hash for LinesCodec

impl<T: Hash> Hash for AllowStdIo<T>

impl Hash for UCred

impl Hash for BytesCodec

impl Hash for LinesCodec

impl<T: Hash> Hash for Spanned<T>

impl Hash for Span

impl Hash for Identifier

impl Hash for Field

impl Hash for Id

impl Hash for B0

impl Hash for B1

impl<U: Hash + Unsigned + NonZero> Hash for PInt<U>

impl<U: Hash + Unsigned + NonZero> Hash for NInt<U>

impl Hash for Z0

impl Hash for UTerm

impl<U: Hash, B: Hash> Hash for UInt<U, B>

impl Hash for ATerm

impl<V: Hash, A: Hash> Hash for TArr<V, A>

impl Hash for Greater

impl Hash for Less

impl Hash for Equal

impl Hash for FromStrRadixErrKind

impl<S: AsRef<str>> Hash for Ascii<S>

impl<S: AsRef<str>> Hash for UniCase<S>

impl<S: Hash> Hash for Host<S>

impl Hash for Origin

impl Hash for OpaqueOrigin

impl Hash for Url

impl<V: Hash> Hash for VecMap<V>

impl Hash for ImportModule

impl Hash for Range

impl<'a> Hash for BinaryReader<'a>

impl Hash for Type

impl Hash for FuncType

impl Hash for Ieee32

impl Hash for Ieee64

impl Hash for V128

impl Hash for WasmFeatures

impl Hash for TrapCode

impl Hash for Mutability

impl Hash for Limits

impl Hash for ValType

impl Hash for FuncType

impl Hash for GlobalType

impl Hash for TableType

impl Hash for MemoryType

impl Hash for TableElements

impl Hash for MemoryStyle

impl Hash for MemoryPlan

impl Hash for TableStyle

impl Hash for TablePlan

impl Hash for Tunables

impl Hash for CompilationStrategy

impl Hash for Compiler

impl Hash for InstanceHandle

impl Hash for VMSharedSignatureIndex

impl Hash for Span

impl<'a> Hash for Id<'a>

impl Hash for Index<'_>

impl Hash for ExportKind

impl<'a> Hash for ValType<'a>

impl<'a> Hash for HeapType<'a>

impl<'a> Hash for RefType<'a>

impl<'a> Hash for StorageType<'a>

impl<'a> Hash for GlobalType<'a>

impl Hash for Limits

impl Hash for Limits64

impl<'a> Hash for TableType<'a>

impl Hash for MemoryType

impl Hash for DNSName

impl Hash for PublicKey

impl Hash for StreamId

impl Hash for Packet

impl Hash for Mode

impl Hash for ZSTD_strategy

impl Hash for ZSTD_cParameter

impl Hash for ZSTD_ResetDirective

impl Hash for ZSTD_dParameter

impl Hash for ZSTD_EndDirective

impl Hash for ZSTD_dictContentType_e

impl Hash for ZSTD_dictLoadMethod_e

impl Hash for ZSTD_format_e

impl Hash for ZSTD_forceIgnoreChecksum_e

impl Hash for ZSTD_dictAttachPref_e

impl Hash for ZSTD_literalCompressionMode_e

impl Hash for ZSTD_sequenceFormat_e

impl Hash for ZSTD_frameType_e

impl Hash for ZSTD_nextInputType_e