Trait 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 hash
ed 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)]
.
Required methods
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
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());
Implementors
impl Hash for std::cmp::Ordering
impl Hash for Infallible
impl Hash for ErrorKind
impl Hash for IpAddr
impl Hash for Ipv6MulticastScope
impl Hash for SocketAddr
impl Hash for std::sync::atomic::Ordering
impl Hash for bool
impl Hash for char
impl Hash for i8
impl Hash for i16
impl Hash for i32
impl Hash for i64
impl Hash for i128
impl Hash for isize
impl Hash for !
impl Hash for str
impl Hash for u8
impl Hash for u16
impl Hash for u32
impl Hash for u64
impl Hash for u128
impl Hash for ()
impl Hash for usize
impl Hash for TypeId
impl Hash for CStr
impl Hash for CString
impl Hash for OsStr
impl Hash for OsString
impl Hash for Error
impl Hash for FileType
impl Hash for PhantomPinned
impl Hash for Ipv4Addr
impl Hash for Ipv6Addr
impl Hash for SocketAddrV4
impl Hash for SocketAddrV6
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 Hash for Path
impl Hash for PathBuf
impl Hash for PrefixComponent<'_>
impl Hash for String
impl Hash for ThreadId
impl Hash for Duration
impl Hash for Instant
impl Hash for SystemTime
impl<'a> Hash for Component<'a>
impl<'a> Hash for Prefix<'a>
impl<'a> Hash for Location<'a>
impl<A, B, C, D, E> Hash for (A, B, C, D, E) where
C: Hash,
E: Hash + ?Sized,
B: Hash,
A: Hash,
D: Hash,
impl<A, B, C, D, E, F> Hash for (A, B, C, D, E, F) where
C: Hash,
F: Hash + ?Sized,
E: Hash,
B: Hash,
A: Hash,
D: Hash,
impl<A, B, C, D, E, F, G> Hash for (A, B, C, D, E, F, G) where
C: Hash,
F: Hash,
E: Hash,
B: Hash,
A: Hash,
G: Hash + ?Sized,
D: Hash,
impl<A, B, C, D, E, F, G, H> Hash for (A, B, C, D, E, F, G, H) where
C: Hash,
F: Hash,
E: Hash,
H: Hash + ?Sized,
B: Hash,
A: Hash,
G: Hash,
D: Hash,
impl<A, B, C, D, E, F, G, H, I> Hash for (A, B, C, D, E, F, G, H, I) where
C: Hash,
F: Hash,
I: Hash + ?Sized,
E: Hash,
H: Hash,
B: Hash,
A: Hash,
G: Hash,
D: Hash,
impl<A, B, C, D, E, F, G, H, I, J> Hash for (A, B, C, D, E, F, G, H, I, J) where
C: Hash,
F: Hash,
I: Hash,
E: Hash,
H: Hash,
B: Hash,
A: Hash,
J: Hash + ?Sized,
G: Hash,
D: Hash,
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
C: Hash,
F: Hash,
K: Hash + ?Sized,
I: Hash,
E: Hash,
H: Hash,
B: Hash,
A: Hash,
J: Hash,
G: Hash,
D: Hash,
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
C: Hash,
F: Hash,
K: Hash,
I: Hash,
E: Hash,
H: Hash,
B: Hash,
A: Hash,
J: Hash,
G: Hash,
D: Hash,
L: Hash + ?Sized,
impl<Ret> Hash for fn() -> Ret
impl<Ret> Hash for extern "C" fn() -> Ret
impl<Ret> Hash for unsafe fn() -> Ret
impl<Ret> Hash for unsafe extern "C" fn() -> Ret
impl<Ret, A> Hash for fn(A) -> Ret
impl<Ret, A> Hash for extern "C" fn(A) -> Ret
impl<Ret, A> Hash for extern "C" fn(A, ...) -> Ret
impl<Ret, A> Hash for unsafe fn(A) -> Ret
impl<Ret, A> Hash for unsafe extern "C" fn(A) -> Ret
impl<Ret, A> Hash for unsafe extern "C" fn(A, ...) -> Ret
impl<Ret, A, B> Hash for fn(A, B) -> Ret
impl<Ret, A, B> Hash for extern "C" fn(A, B) -> Ret
impl<Ret, A, B> Hash for extern "C" fn(A, B, ...) -> Ret
impl<Ret, A, B> Hash for unsafe fn(A, B) -> Ret
impl<Ret, A, B> Hash for unsafe extern "C" fn(A, B) -> Ret
impl<Ret, A, B> Hash for unsafe extern "C" fn(A, B, ...) -> Ret
impl<Ret, A, B, C> Hash for fn(A, B, C) -> Ret
impl<Ret, A, B, C> Hash for extern "C" fn(A, B, C) -> Ret
impl<Ret, A, B, C> Hash for extern "C" fn(A, B, C, ...) -> Ret
impl<Ret, A, B, C> Hash for unsafe fn(A, B, C) -> Ret
impl<Ret, A, B, C> Hash for unsafe extern "C" fn(A, B, C) -> Ret
impl<Ret, A, B, C> Hash for unsafe extern "C" fn(A, B, C, ...) -> Ret
impl<Ret, A, B, C, D> Hash for fn(A, B, C, D) -> Ret
impl<Ret, A, B, C, D> Hash for extern "C" fn(A, B, C, D) -> Ret
impl<Ret, A, B, C, D> Hash for extern "C" fn(A, B, C, D, ...) -> Ret
impl<Ret, A, B, C, D> Hash for unsafe fn(A, B, C, D) -> Ret
impl<Ret, A, B, C, D> Hash for unsafe extern "C" fn(A, B, C, D) -> Ret
impl<Ret, A, B, C, D> Hash for unsafe extern "C" fn(A, B, C, D, ...) -> Ret
impl<Ret, A, B, C, D, E> Hash for fn(A, B, C, D, E) -> Ret
impl<Ret, A, B, C, D, E> Hash for extern "C" fn(A, B, C, D, E) -> Ret
impl<Ret, A, B, C, D, E> Hash for extern "C" fn(A, B, C, D, E, ...) -> Ret
impl<Ret, A, B, C, D, E> Hash for unsafe fn(A, B, C, D, E) -> Ret
impl<Ret, A, B, C, D, E> Hash for unsafe extern "C" fn(A, B, C, D, E) -> Ret
impl<Ret, A, B, C, D, E> Hash for unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret
impl<Ret, A, B, C, D, E, F> Hash for fn(A, B, C, D, E, F) -> Ret
impl<Ret, A, B, C, D, E, F> Hash for extern "C" fn(A, B, C, D, E, F) -> Ret
impl<Ret, A, B, C, D, E, F> Hash for extern "C" fn(A, B, C, D, E, F, ...) -> Ret
impl<Ret, A, B, C, D, E, F> Hash for unsafe fn(A, B, C, D, E, F) -> Ret
impl<Ret, A, B, C, D, E, F> Hash for unsafe extern "C" fn(A, B, C, D, E, F) -> Ret
impl<Ret, A, B, C, D, E, F> Hash for unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret
impl<Ret, A, B, C, D, E, F, G> Hash for fn(A, B, C, D, E, F, G) -> Ret
impl<Ret, A, B, C, D, E, F, G> Hash for extern "C" fn(A, B, C, D, E, F, G) -> Ret
impl<Ret, A, B, C, D, E, F, G> Hash for extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret
impl<Ret, A, B, C, D, E, F, G> Hash for unsafe fn(A, B, C, D, E, F, G) -> Ret
impl<Ret, A, B, C, D, E, F, G> Hash for unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret
impl<Ret, A, B, C, D, E, F, G> Hash for unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret
impl<Ret, A, B, C, D, E, F, G, H> Hash for fn(A, B, C, D, E, F, G, H) -> Ret
impl<Ret, A, B, C, D, E, F, G, H> Hash for extern "C" fn(A, B, C, D, E, F, G, H) -> Ret
impl<Ret, A, B, C, D, E, F, G, H> Hash for extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret
impl<Ret, A, B, C, D, E, F, G, H> Hash for unsafe fn(A, B, C, D, E, F, G, H) -> Ret
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
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
impl<Ret, A, B, C, D, E, F, G, H, I> Hash for fn(A, B, C, D, E, F, G, H, I) -> Ret
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
impl<T> Hash for Discriminant<T>
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));
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));
© 2010 The Rust Project Developers
Licensed under the Apache License, Version 2.0 or the MIT license, at your option.
https://doc.rust-lang.org/std/hash/trait.Hash.html