# Trait std::hash::Hash

1.0.0 · source ·

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

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

Expand description

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,
    }

Run

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);
        }
    }

Run

### `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)]`.

Violating this property is a logic error. The behavior resulting from a logic error is not specified, but users of the trait must ensure that such logic errors do not result in undefined behavior. This means that `unsafe` code must not rely on the correctness of these methods.

### Prefix collisions

Implementations of `hash` should ensure that the data they pass to the `Hasher` are prefix-free. That is, values which are not equal 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§

source

#### 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());

Run

## Provided Methods§

1.3.0 · source

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

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());

Run

## Object Safety§

This trait is not object safe.

## Implementors§

source§

### impl Hash for AsciiChar

source§

### impl Hash for std::cmp::Ordering

1.44.0 · source§

### impl Hash for Infallible

source§

### impl Hash for ErrorKind

1.7.0 · source§

### impl Hash for IpAddr

source§

### impl Hash for Ipv6MulticastScope

source§

### impl Hash for SocketAddr

source§

### impl Hash for Which

source§

### impl Hash for std::sync::atomic::Ordering

source§

### impl Hash for bool

source§

### impl Hash for char

source§

### impl Hash for i8

source§

### impl Hash for i16

source§

### impl Hash for i32

source§

### impl Hash for i64

source§

### impl Hash for i128

source§

### impl Hash for isize

1.29.0 · source§

### impl Hash for !

source§

### impl Hash for str

source§

### impl Hash for u8

source§

### impl Hash for u16

source§

### impl Hash for u32

source§

### impl Hash for u64

source§

### impl Hash for u128

source§

### impl Hash for ()

source§

### impl Hash for usize

1.28.0 · source§

### impl Hash for Layout

source§

### impl Hash for TypeId

1.64.0 · source§

### impl Hash for CStr

1.64.0 · source§

### impl Hash for CString

source§

### impl Hash for OsStr

source§

### impl Hash for OsString

source§

### impl Hash for Error

1.1.0 · source§

### impl Hash for FileType

1.33.0 · source§

### impl Hash for PhantomPinned

source§

### impl Hash for Ipv4Addr

source§

### impl Hash for Ipv6Addr

source§

### impl Hash for SocketAddrV4

source§

### impl Hash for SocketAddrV6

1.34.0 · source§

### impl Hash for NonZeroI8

1.34.0 · source§

### impl Hash for NonZeroI16

1.34.0 · source§

### impl Hash for NonZeroI32

1.34.0 · source§

### impl Hash for NonZeroI64

1.34.0 · source§

### impl Hash for NonZeroI128

1.34.0 · source§

### impl Hash for NonZeroIsize

1.28.0 · source§

### impl Hash for NonZeroU8

1.28.0 · source§

### impl Hash for NonZeroU16

1.28.0 · source§

### impl Hash for NonZeroU32

1.28.0 · source§

### impl Hash for NonZeroU64

1.28.0 · source§

### impl Hash for NonZeroU128

1.28.0 · source§

### impl Hash for NonZeroUsize

source§

### impl Hash for RangeFull

source§

### impl Hash for UCred

Available on Unix only.
source§

### impl Hash for Path

source§

### impl Hash for PathBuf

source§

### impl Hash for PrefixComponent<'_>

source§

### impl Hash for Alignment

source§

### impl Hash for String

1.19.0 · source§

### impl Hash for ThreadId

1.3.0 · source§

### impl Hash for Duration

1.8.0 · source§

### impl Hash for Instant

1.8.0 · source§

### impl Hash for SystemTime

source§

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

source§

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

1.10.0 · source§

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

source§

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

1.55.0 · source§

### impl<B, C> Hash for ControlFlow<B, C>where B: Hash, C: Hash,

source§

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

1.4.0 · source§

### impl<F> Hash for Fwhere F: FnPtr,

source§

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

source§

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

1.26.0 · source§

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

source§

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

1.26.0 · source§

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

source§

### impl<K, V, A> Hash for BTreeMap<K, V, A>where K: Hash, V: Hash, A: Allocator + Clone,

1.41.0 · source§

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

1.17.0 · source§

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

source§

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

1.36.0 · source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

### impl<T> Hash for (T₁, T₂, …, Tₙ)where T: Hash + ?Sized,

This trait is implemented for tuples up to twelve items long.

1.19.0 · source§

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

source§

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

1.21.0 · source§

### impl<T> Hash for Discriminant<T>

1.20.0 · source§

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

1.74.0 · source§

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

source§

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

1.25.0 · source§

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

source§

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

source§

### impl<T, A> Hash for BTreeSet<T, A>where T: Hash, A: Allocator + Clone,

source§

### impl<T, A> Hash for LinkedList<T, A>where T: Hash, A: Allocator,

source§

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

source§

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

source§

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

source§

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

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

    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));

Run
source§

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

source§

### 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.

    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));

Run
source§

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

source§

### impl<Y, R> Hash for CoroutineState<Y, R>where Y: Hash, R: Hash,