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

RunIf 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§

## Provided Methods§

1.3.0 · source#### fn hash_slice<H>(data: &[Self], state: &mut H)

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

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::hash::{DefaultHasher, 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§

**not**object safe.

## Implementors§

### impl Hash for AsciiChar

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

### impl Hash for SectionId

### impl Hash for RunTimeEndian

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

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

### impl Hash for UCred

**Unix**only.

### impl Hash for Path

### impl Hash for PathBuf

### impl Hash for PrefixComponent<'_>

### impl Hash for Alignment

### impl Hash for String

### impl Hash for ThreadId

### impl Hash for Duration

### impl Hash for Instant

### impl Hash for SystemTime

### impl Hash for DebugTypeSignature

### impl Hash for DwoId

### impl Hash for Encoding

### impl Hash for LineEncoding

### impl Hash for Register

### impl Hash for DwAccess

### impl Hash for DwAddr

### impl Hash for DwAt

### impl Hash for DwAte

### impl Hash for DwCc

### impl Hash for DwCfa

### impl Hash for DwChildren

### impl Hash for DwDefaulted

### impl Hash for DwDs

### impl Hash for DwDsc

### impl Hash for DwEhPe

### impl Hash for DwEnd

### impl Hash for DwForm

### impl Hash for DwId

### impl Hash for DwIdx

### impl Hash for DwInl

### impl Hash for DwLang

### impl Hash for DwLle

### impl Hash for DwLnct

### impl Hash for DwLne

### impl Hash for DwLns

### impl Hash for DwMacro

### impl Hash for DwOp

### impl Hash for DwOrd

### impl Hash for DwRle

### impl Hash for DwSect

### impl Hash for DwSectV2

### impl Hash for DwTag

### impl Hash for DwUt

### impl Hash for DwVirtuality

### impl Hash for DwVis

### impl Hash for BigEndian

### impl Hash for LittleEndian

### impl Hash for gimli::read::rnglists::Range

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

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

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

### impl<'input, Endian> Hash for EndianSlice<'input, Endian>

### impl<B> Hash for Cow<'_, B>

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

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

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

### impl<Idx> Hash for std::ops::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, A> Hash for BTreeMap<K, V, A>

### impl<Ptr> Hash for Pin<Ptr>

### impl<R> Hash for LocationListEntry<R>

### impl<R> Hash for Expression<R>

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

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

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

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

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

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

### impl<T> Hash for &T

### impl<T> Hash for &mut T

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

### impl<T> Hash for (T₁, T₂, …, Tₙ)

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

### impl<T> Hash for Reverse<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>

### impl<T> Hash for NonZero<T>where
T: ZeroablePrimitive + Hash,

### 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 DebugAbbrevOffset<T>where
T: Hash,

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

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

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

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

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

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

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

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

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

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

### impl<T, A> Hash for Box<T, A>

### impl<T, A> Hash for BTreeSet<T, A>

### impl<T, A> Hash for LinkedList<T, A>

### impl<T, A> Hash for VecDeque<T, A>

### impl<T, A> Hash for Rc<T, A>

### impl<T, A> Hash for Arc<T, A>

### impl<T, A> Hash for Vec<T, A>

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::hash::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### impl<T, E> Hash for Result<T, E>

### 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::hash::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