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.

Object Safety

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