Trait Hash

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 { ... }
}

See core::hash::Hash for details

Required Methods

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

Provided Methods

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl Hash for bool

fn hash<H>(&self, state: &mut H)

where H: Hasher,

impl Hash for char

fn hash<H>(&self, state: &mut H)

where H: Hasher,

impl Hash for i8

fn hash<H>(&self, state: &mut H)

where H: Hasher,

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

where H: Hasher,

impl Hash for i16

fn hash<H>(&self, state: &mut H)

where H: Hasher,

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

where H: Hasher,

impl Hash for i32

fn hash<H>(&self, state: &mut H)

where H: Hasher,

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

where H: Hasher,

impl Hash for i64

fn hash<H>(&self, state: &mut H)

where H: Hasher,

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

where H: Hasher,

impl Hash for isize

fn hash<H>(&self, state: &mut H)

where H: Hasher,

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

where H: Hasher,

impl Hash for str

fn hash<H>(&self, state: &mut H)

where H: Hasher,

impl Hash for u8

fn hash<H>(&self, state: &mut H)

where H: Hasher,

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

where H: Hasher,

impl Hash for u16

fn hash<H>(&self, state: &mut H)

where H: Hasher,

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

where H: Hasher,

impl Hash for u32

fn hash<H>(&self, state: &mut H)

where H: Hasher,

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

where H: Hasher,

impl Hash for u64

fn hash<H>(&self, state: &mut H)

where H: Hasher,

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

where H: Hasher,

impl Hash for ()

fn hash<H: Hasher>(&self, _state: &mut H)

impl Hash for usize

fn hash<H>(&self, state: &mut H)

where H: Hasher,

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

where H: Hasher,

impl<'a, T: ?Sized + Hash> Hash for &'a T

fn hash<H: Hasher>(&self, state: &mut H)

impl<'a, T: ?Sized + Hash> Hash for &'a mut T

fn hash<H: Hasher>(&self, state: &mut H)

impl<A> Hash for (A,)

where A: ?Sized + Hash,

fn hash<S: Hasher>(&self, state: &mut S)

impl<A: Hash, B> Hash for (A, B)

where B: ?Sized + Hash,

fn hash<S: Hasher>(&self, state: &mut S)

impl<A: Hash, B: Hash, C> Hash for (A, B, C)

where C: ?Sized + Hash,

fn hash<S: Hasher>(&self, state: &mut S)

impl<A: Hash, B: Hash, C: Hash, D> Hash for (A, B, C, D)

where D: ?Sized + Hash,

fn hash<S: Hasher>(&self, state: &mut S)

impl<A: Hash, B: Hash, C: Hash, D: Hash, E> Hash for (A, B, C, D, E)

where E: ?Sized + Hash,

fn hash<S: Hasher>(&self, state: &mut S)

impl<A: Hash, B: Hash, C: Hash, D: Hash, E: Hash, F> Hash for (A, B, C, D, E, F)

where F: ?Sized + Hash,

fn hash<S: Hasher>(&self, state: &mut S)

impl<A: Hash, B: Hash, C: Hash, D: Hash, E: Hash, F: Hash, G> Hash for (A, B, C, D, E, F, G)

where G: ?Sized + Hash,

fn hash<S: Hasher>(&self, state: &mut S)

impl<A: Hash, B: Hash, C: Hash, D: Hash, E: Hash, F: Hash, G: Hash, H> Hash for (A, B, C, D, E, F, G, H)

where H: ?Sized + Hash,

fn hash<S: Hasher>(&self, state: &mut S)

impl<A: Hash, B: Hash, C: Hash, D: Hash, E: Hash, F: Hash, G: Hash, H: Hash, I> Hash for (A, B, C, D, E, F, G, H, I)

where I: ?Sized + Hash,

fn hash<S: Hasher>(&self, state: &mut S)

impl<A: Hash, B: Hash, C: Hash, D: Hash, E: Hash, F: Hash, G: Hash, H: Hash, I: Hash, J> Hash for (A, B, C, D, E, F, G, H, I, J)

where J: ?Sized + Hash,

fn hash<S: Hasher>(&self, state: &mut S)

impl<A: Hash, B: Hash, C: Hash, D: Hash, E: Hash, F: Hash, G: Hash, H: Hash, I: Hash, J: Hash, K> Hash for (A, B, C, D, E, F, G, H, I, J, K)

where K: ?Sized + Hash,

fn hash<S: Hasher>(&self, state: &mut S)

impl<A: Hash, B: Hash, C: Hash, D: Hash, E: Hash, F: Hash, G: Hash, H: Hash, I: Hash, J: Hash, K: Hash, L> Hash for (A, B, C, D, E, F, G, H, I, J, K, L)

where L: ?Sized + Hash,

fn hash<S: Hasher>(&self, state: &mut S)

impl<T> Hash for [T; 0]

where T: Hash,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

impl<T> Hash for [T; 1]

where T: Hash,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

impl<T> Hash for [T; 2]

where T: Hash,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

impl<T> Hash for [T; 3]

where T: Hash,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

impl<T> Hash for [T; 4]

where T: Hash,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

impl<T> Hash for [T; 5]

where T: Hash,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

impl<T> Hash for [T; 6]

where T: Hash,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

impl<T> Hash for [T; 7]

where T: Hash,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

impl<T> Hash for [T; 8]

where T: Hash,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

impl<T> Hash for [T; 9]

where T: Hash,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

impl<T> Hash for [T; 10]

where T: Hash,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

impl<T> Hash for [T; 11]

where T: Hash,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

impl<T> Hash for [T; 12]

where T: Hash,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

impl<T> Hash for [T; 13]

where T: Hash,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

impl<T> Hash for [T; 14]

where T: Hash,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

impl<T> Hash for [T; 15]

where T: Hash,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

impl<T> Hash for [T; 16]

where T: Hash,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

impl<T> Hash for [T; 17]

where T: Hash,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

impl<T> Hash for [T; 18]

where T: Hash,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

impl<T> Hash for [T; 19]

where T: Hash,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

impl<T> Hash for [T; 20]

where T: Hash,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

impl<T> Hash for [T; 21]

where T: Hash,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

impl<T> Hash for [T; 22]

where T: Hash,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

impl<T> Hash for [T; 23]

where T: Hash,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

impl<T> Hash for [T; 24]

where T: Hash,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

impl<T> Hash for [T; 25]

where T: Hash,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

impl<T> Hash for [T; 26]

where T: Hash,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

impl<T> Hash for [T; 27]

where T: Hash,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

impl<T> Hash for [T; 28]

where T: Hash,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

impl<T> Hash for [T; 29]

where T: Hash,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

impl<T> Hash for [T; 30]

where T: Hash,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

impl<T> Hash for [T; 31]

where T: Hash,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

impl<T> Hash for [T; 32]

where T: Hash,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

impl<T> Hash for [T]

where T: Hash,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Implementors