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

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

.

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)where
H: Hasher,
Self: Sized,

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

## Implementors§

### impl Hash for log::Level

### impl Hash for log::LevelFilter

### impl Hash for AsciiChar

### impl Hash for tracing::stdlib::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 Which

### impl Hash for tracing::stdlib::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 Identifier

### impl Hash for Field

### impl Hash for tracing::level_filters::LevelFilter

### impl Hash for Id

### impl Hash for Inner

### impl Hash for tracing::Level

### impl Hash for Span

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

### 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<'a> Hash for Component<'a>

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

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

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

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

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

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

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

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

### 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, A> Hash for BTreeMap<K, V, A>where K: Hash, V: Hash, A: Allocator + Clone,

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

### 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 *const Twhere T: ?Sized,

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

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

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

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

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

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>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, A> Hash for Box<T, A>where T: Hash + ?Sized, A: Allocator,

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

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

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

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

### impl<T, A> Hash for Arc<T, A>where T: Hash + ?Sized, 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.

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