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.
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)].
fn hash<H>(&self, state: &mut H) where
H: Hasher, Feeds this value into the given Hasher.
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()); fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, Feeds a slice of this type into the given Hasher.
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()); impl<T> Hash for NonZero<T> where
T: Zeroable + Hash,
[src]
fn hash<__HT>(&self, __arg_0: &mut __HT) where
__HT: Hasher,
[src]
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
impl<T> Hash for Rc<T> where
T: Hash + ?Sized,
impl<T> Hash for Arc<T> where
T: Hash + ?Sized,
impl<T> Hash for BTreeSet<T> where
T: Hash,
impl<K, V> Hash for BTreeMap<K, V> where
K: Hash,
V: Hash,
impl<A> Hash for VecDeque<A> where
A: Hash,
impl Hash for String
impl<T> Hash for Box<T> where
T: Hash + ?Sized,
impl<'a, B> Hash for Cow<'a, B> where
B: Hash + ToOwned + ?Sized,
impl<T> Hash for LinkedList<T> where
T: Hash,
impl<T> Hash for Vec<T> where
T: Hash,
impl<T> Hash for Bound<T> where
T: Hash,
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,
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> Hash for unsafe extern "C" fn(A, ...) -> Ret
impl Hash for usize
impl<T> Hash for *mut T where
T: ?Sized,
impl<Ret, A> Hash for unsafe extern "C" fn(A) -> Ret
impl<Ret, A, B, C> Hash for unsafe fn(A, B, C) -> Ret
impl<Ret, A, B, C, D, E, F> Hash for unsafe extern "C" fn(A, B, C, D, E, F) -> Ret
impl Hash for TypeId
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, F, G, H, I, J, K> Hash for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
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,
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 Hash for str
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<T> Hash for [T; 29] where
T: Hash,
impl<Ret> Hash for unsafe extern "C" fn() -> Ret
impl<Ret, A, B, C, D> Hash for extern "C" fn(A, B, C, D, ...) -> Ret
impl<T> Hash for [T; 26] where
T: Hash,
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<T> Hash for PhantomData<T> where
T: ?Sized,
impl<T> Hash for Discriminant<T>
impl Hash for u64
impl<T> Hash for [T; 23] where
T: Hash,
impl<Ret, A> Hash for extern "C" fn(A, ...) -> Ret
impl<Ret, A, B, C, D, E> Hash for extern "C" fn(A, B, C, D, E, ...) -> Ret
impl<Ret> Hash for fn() -> Ret
impl<'a, T> Hash for &'a mut T where
T: Hash + ?Sized,
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,
impl<T> Hash for [T; 12] where
T: Hash,
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 Hash for i16
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> Hash for unsafe fn(A) -> Ret
impl Hash for ()
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> Hash for fn(A) -> Ret
impl<T, E> Hash for Result<T, E> where
E: Hash,
T: Hash,
impl Hash for u128
impl Hash for isize
impl<A, B, C> Hash for (A, B, C) where
A: Hash,
B: Hash,
C: Hash + ?Sized,
impl<Ret, A, B, C, D, E, F, G, H> Hash for fn(A, B, C, D, E, F, G, H) -> Ret
impl<Idx> Hash for RangeFrom<Idx> where
Idx: Hash,
impl<A> Hash for (A,) where
A: Hash + ?Sized,
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<T> Hash for [T; 16] where
T: Hash,
impl<T> Hash for Option<T> where
T: Hash,
impl<Ret, A, B, C> Hash for unsafe extern "C" fn(A, B, C, ...) -> Ret
impl Hash for bool
impl<T> Hash for [T; 5] where
T: Hash,
impl<T> Hash for [T; 11] where
T: Hash,
impl<Idx> Hash for RangeTo<Idx> where
Idx: Hash,
impl<A, B, C, D> Hash for (A, B, C, D) where
A: Hash,
B: Hash,
C: Hash,
D: Hash + ?Sized,
impl<T> Hash for [T; 1] where
T: Hash,
impl<Ret, A, B, C, D, E, F, G> Hash for extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret
impl<T> Hash for [T; 25] where
T: Hash,
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> Hash for fn(A, B) -> Ret
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,
impl<Ret, A, B, C, D> Hash for extern "C" fn(A, B, C, D) -> 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> Hash for unsafe extern "C" fn(A, B, C, D, E) -> Ret
impl<Ret, A, B, C, D> Hash for fn(A, B, C, D) -> 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 unsafe fn(A, B, C, D, E, F, G, H) -> Ret
impl<T> Hash for [T; 10] where
T: Hash,
impl<T> Hash for [T; 21] where
T: Hash,
impl<Ret, A, B, C> Hash for fn(A, B, C) -> Ret
impl Hash for u16
impl<Ret, A, B, C> Hash for unsafe extern "C" fn(A, B, C) -> Ret
impl<Ret, A> Hash for extern "C" fn(A) -> Ret
impl<T> Hash for [T; 15] where
T: Hash,
impl<T> Hash for [T; 28] where
T: Hash,
impl Hash for Error
impl Hash for RangeFull
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,
impl<T> Hash for [T; 14] where
T: Hash,
impl Hash for char
impl<T> Hash for [T; 2] where
T: 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
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,
impl<T> Hash for [T; 17] where
T: Hash,
impl Hash for i64
impl<Ret, A, B> Hash for unsafe extern "C" fn(A, B) -> 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, I, J> Hash for extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret
impl<T> Hash for [T; 22] where
T: Hash,
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> Hash for extern "C" fn(A, B, C, D, E, F) -> Ret
impl<T> Hash for [T; 18] where
T: Hash,
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<T> Hash for *const T where
T: ?Sized,
impl<T> Hash for [T; 6] where
T: Hash,
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> Hash for fn(A, B, C, D, E) -> 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<T> Hash for [T; 7] where
T: Hash,
impl<T> Hash for [T; 19] where
T: Hash,
impl<T> Hash for [T; 9] where
T: Hash,
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> Hash for unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret
impl<T> Hash for [T; 20] where
T: Hash,
impl<T> Hash for ManuallyDrop<T> where
T: Hash,
impl<Ret> Hash for extern "C" fn() -> 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<T> Hash for [T; 24] where
T: Hash,
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> Hash for extern "C" fn(A, B, C) -> Ret
impl<Ret> Hash for unsafe fn() -> Ret
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,
impl Hash for i128
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 extern "C" fn(A, B, C, D, E, F, G) -> 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 Hash for i32
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 Hash for Ordering
impl Hash for Infallible
impl<T> Hash for [T; 4] where
T: Hash,
impl<Ret, A, B, C, D, E, F, G> Hash for unsafe fn(A, B, C, D, E, F, G) -> Ret
impl Hash for NoneError
impl<T> Hash for [T; 8] where
T: Hash,
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 extern "C" fn(A, B, C, D, E, F, ...) -> Ret
impl<T> Hash for [T; 13] where
T: Hash,
impl Hash for u32
impl<Ret, A, B, C, D, E, F> Hash for fn(A, B, C, D, E, F) -> Ret
impl<T> Hash for [T; 31] where
T: Hash,
impl<T> Hash for [T; 0] where
T: Hash,
impl<Ret, A, B> Hash for unsafe fn(A, B) -> Ret
impl<T> Hash for Wrapping<T> where
T: Hash,
impl<Ret, A, B, C> Hash for extern "C" fn(A, B, C, ...) -> 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 Hash for u8
impl<'a, T> Hash for &'a T where
T: Hash + ?Sized,
impl<Idx> Hash for Range<Idx> where
Idx: Hash,
impl<A, B> Hash for (A, B) where
A: Hash,
B: Hash + ?Sized,
impl<Ret, A, B, C, D> Hash for unsafe extern "C" fn(A, B, C, D, ...) -> 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> Hash for extern "C" fn(A, B) -> Ret
impl<Ret, A, B, C, D, E> Hash for unsafe fn(A, B, C, D, E) -> Ret
impl<T> Hash for [T; 30] where
T: Hash,
impl<T> Hash for [T] where
T: Hash,
impl<Ret, A, B> Hash for unsafe extern "C" fn(A, B, ...) -> Ret
impl Hash for i8
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,
impl<Ret, A, B, C, D> Hash for unsafe fn(A, B, C, D) -> 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 [T; 3] where
T: Hash,
impl<Idx> Hash for RangeInclusive<Idx> where
Idx: Hash,
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> 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> Hash for unsafe extern "C" fn(A, B, C, D) -> Ret
impl<T> Hash for [T; 32] where
T: Hash,
impl<Y, R> Hash for GeneratorState<Y, R> where
R: Hash,
Y: Hash,
impl<Ret, A, B> Hash for extern "C" fn(A, B, ...) -> 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<T> Hash for [T; 27] where
T: Hash,
impl<Idx> Hash for RangeToInclusive<Idx> where
Idx: Hash,
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 Hash for ThreadId
impl Hash for CString
impl Hash for CStr
impl Hash for OsString
impl Hash for OsStr
impl Hash for FileType
impl Hash for ErrorKind
impl Hash for IpAddr
impl Hash for Ipv6MulticastScope
impl Hash for Ipv4Addr
impl Hash for Ipv6Addr
impl Hash for SocketAddr
impl Hash for SocketAddrV4
impl Hash for SocketAddrV6
impl<'a> Hash for Prefix<'a>
impl<'a> Hash for PrefixComponent<'a>
impl<'a> Hash for Component<'a>
impl Hash for PathBuf
impl Hash for Path
impl Hash for Duration
© 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