Trait orkhon::prelude::ops::nn::tract_downcast_rs::__std::hash::Hash1.0.0[−][src]

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

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

A hashable type.

Types implementing Hash are able to be hashed 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)].

Required methods

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, [src]

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());
Loading content...

Provided methods

pub fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 1.3.0[src]

Feeds a slice of this type into the given Hasher.

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());
Loading content...

Implementations on Foreign Types

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Hash for fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret[src]

impl<Ret, A, B> Hash for extern "C" fn(A, B) -> Ret[src]

impl<A, B, C> Hash for (A, B, C) where
    C: Hash + ?Sized,
    A: Hash,
    B: Hash, [src]

impl Hash for bool[src]

impl<Ret, A, B, C, D, E, F, G, H> Hash for unsafe fn(A, B, C, D, E, F, G, H) -> Ret[src]

impl Hash for u32[src]

impl<Ret, A, B> Hash for extern "C" fn(A, B, ...) -> Ret[src]

impl<Ret, A, B, C, D, E> Hash for unsafe extern "C" fn(A, B, C, D, E) -> Ret[src]

impl<T> Hash for *mut T where
    T: ?Sized, [src]

impl<Ret, A> Hash for extern "C" fn(A) -> Ret[src]

impl<A, B> Hash for (A, B) where
    A: Hash,
    B: Hash + ?Sized, [src]

impl<Ret, A, B, C, D, E, F> Hash for extern "C" fn(A, B, C, D, E, F, ...) -> Ret[src]

impl Hash for u8[src]

impl Hash for usize[src]

impl<Ret, A, B, C> Hash for fn(A, B, C) -> Ret[src]

impl<Ret, A, B, C, D, E, F, G> Hash for unsafe fn(A, B, C, D, E, F, G) -> Ret[src]

impl<Ret, A, B, C, D, E, F, G> Hash for fn(A, B, C, D, E, F, G) -> Ret[src]

impl<Ret, A, B, C, D, E, F> Hash for unsafe extern "C" fn(A, B, C, D, E, F) -> Ret[src]

impl<Ret, A, B, C, D, E, F, G, H, I> Hash for fn(A, B, C, D, E, F, G, H, I) -> Ret[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L> Hash for (A, B, C, D, E, F, G, H, I, J, K, L) where
    C: Hash,
    I: Hash,
    K: Hash,
    A: Hash,
    E: Hash,
    G: Hash,
    F: Hash,
    B: Hash,
    J: Hash,
    D: Hash,
    L: Hash + ?Sized,
    H: Hash, [src]

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

impl<Ret, A, B, C> Hash for extern "C" fn(A, B, C, ...) -> Ret[src]

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Hash for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret[src]

impl<Ret, A, B, C, D> Hash for unsafe extern "C" fn(A, B, C, D, ...) -> Ret[src]

impl<Ret, A, B, C, D, E, F, G, H> Hash for fn(A, B, C, D, E, F, G, H) -> Ret[src]

impl<Ret, A, B, C, D> Hash for fn(A, B, C, D) -> Ret[src]

impl Hash for str[src]

impl<Ret, A, B, C, D, E, F, G, H, I, J> Hash for extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret[src]

impl<Ret, A, B, C, D, E, F> Hash for unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret[src]

impl<Ret, A, B, C> Hash for extern "C" fn(A, B, C) -> Ret[src]

impl Hash for ()[src]

impl<A, B, C, D, E, F, G> Hash for (A, B, C, D, E, F, G) where
    C: Hash,
    A: Hash,
    E: Hash,
    G: Hash + ?Sized,
    F: Hash,
    B: Hash,
    D: Hash, [src]

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Hash for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret[src]

impl<Ret, A, B, C, D, E, F, G, H, I> Hash for unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret[src]

impl<A, B, C, D> Hash for (A, B, C, D) where
    C: Hash,
    A: Hash,
    B: Hash,
    D: Hash + ?Sized, [src]

impl<Ret, A, B, C, D, E, F> Hash for unsafe fn(A, B, C, D, E, F) -> Ret[src]

impl<A, B, C, D, E, F> Hash for (A, B, C, D, E, F) where
    C: Hash,
    A: Hash,
    E: Hash,
    F: Hash + ?Sized,
    B: Hash,
    D: Hash, [src]

impl Hash for isize[src]

impl<T> Hash for *const T where
    T: ?Sized, [src]

impl<A, B, C, D, E, F, G, H, I> Hash for (A, B, C, D, E, F, G, H, I) where
    C: Hash,
    I: Hash + ?Sized,
    A: Hash,
    E: Hash,
    G: Hash,
    F: Hash,
    B: Hash,
    D: Hash,
    H: Hash, [src]

impl<Ret, A> Hash for unsafe extern "C" fn(A, ...) -> Ret[src]

impl<Ret> Hash for extern "C" fn() -> Ret[src]

impl<Ret, A, B, C, D, E, F, G> Hash for unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret[src]

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Hash for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret[src]

impl<Ret, A, B, C, D> Hash for unsafe fn(A, B, C, D) -> Ret[src]

impl<Ret, A, B, C, D, E, F, G, H, I> Hash for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret[src]

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Hash for unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret[src]

impl<Ret, A, B, C, D, E, F, G> Hash for extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret[src]

impl Hash for ![src]

impl<Ret, A> Hash for unsafe extern "C" fn(A) -> Ret[src]

impl<Ret, A, B, C> Hash for unsafe fn(A, B, C) -> Ret[src]

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Hash for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret[src]

impl<Ret, A, B> Hash for fn(A, B) -> Ret[src]

impl<Ret, A, B, C, D, E> Hash for extern "C" fn(A, B, C, D, E, ...) -> Ret[src]

impl<A, B, C, D, E, F, G, H, I, J, K> Hash for (A, B, C, D, E, F, G, H, I, J, K) where
    C: Hash,
    I: Hash,
    K: Hash + ?Sized,
    A: Hash,
    E: Hash,
    G: Hash,
    F: Hash,
    B: Hash,
    J: Hash,
    D: Hash,
    H: Hash, [src]

impl<Ret, A, B, C, D, E, F> Hash for fn(A, B, C, D, E, F) -> Ret[src]

impl Hash for i32[src]

impl<Ret, A, B, C, D> Hash for extern "C" fn(A, B, C, D) -> Ret[src]

impl<Ret, A> Hash for unsafe fn(A) -> Ret[src]

impl<Ret, A, B> Hash for unsafe extern "C" fn(A, B, ...) -> Ret[src]

impl<Ret, A, B, C, D, E> Hash for unsafe fn(A, B, C, D, E) -> Ret[src]

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Hash for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret[src]

impl<Ret, A, B, C, D, E, F, G, H, I, J> Hash for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret[src]

impl Hash for i128[src]

impl<A> Hash for (A,) where
    A: Hash + ?Sized, [src]

impl<Ret, A, B, C, D, E> Hash for extern "C" fn(A, B, C, D, E) -> Ret[src]

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Hash for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret[src]

impl Hash for i8[src]

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Hash for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret[src]

impl Hash for char[src]

impl<Ret, A, B, C, D> Hash for unsafe extern "C" fn(A, B, C, D) -> Ret[src]

impl<Ret, A, B, C, D, E, F, G, H> Hash for unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret[src]

impl<Ret, A> Hash for fn(A) -> Ret[src]

impl<Ret, A, B, C, D, E, F, G, H, I, J> Hash for unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret[src]

impl<Ret, A, B> Hash for unsafe extern "C" fn(A, B) -> Ret[src]

impl<A, B, C, D, E> Hash for (A, B, C, D, E) where
    C: Hash,
    A: Hash,
    E: Hash + ?Sized,
    B: Hash,
    D: Hash, [src]

impl<Ret, A, B> Hash for unsafe fn(A, B) -> Ret[src]

impl<Ret, A, B, C, D, E, F, G, H, I, J> Hash for extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret[src]

impl Hash for u64[src]

impl<Ret> Hash for unsafe fn() -> Ret[src]

impl<Ret, A, B, C, D, E> Hash for fn(A, B, C, D, E) -> Ret[src]

impl Hash for u128[src]

impl<Ret, A, B, C> Hash for unsafe extern "C" fn(A, B, C) -> Ret[src]

impl<Ret, A, B, C> Hash for unsafe extern "C" fn(A, B, C, ...) -> Ret[src]

impl<Ret> Hash for fn() -> Ret[src]

impl<'_, T> Hash for &'_ T where
    T: Hash + ?Sized, [src]

impl<Ret, A, B, C, D, E, F, G, H, I> Hash for extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret[src]

impl<A, B, C, D, E, F, G, H, I, J> Hash for (A, B, C, D, E, F, G, H, I, J) where
    C: Hash,
    I: Hash,
    A: Hash,
    E: Hash,
    G: Hash,
    F: Hash,
    B: Hash,
    J: Hash + ?Sized,
    D: Hash,
    H: Hash, [src]

impl<Ret, A, B, C, D, E, F, G> Hash for extern "C" fn(A, B, C, D, E, F, G) -> Ret[src]

impl<Ret, A, B, C, D, E> Hash for unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret[src]

impl<Ret, A, B, C, D, E, F, G, H> Hash for extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret[src]

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Hash for unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret[src]

impl<Ret, A, B, C, D, E, F, G, H> Hash for extern "C" fn(A, B, C, D, E, F, G, H) -> Ret[src]

impl<Ret, A, B, C, D, E, F, G, H> Hash for unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret[src]

impl<A, B, C, D, E, F, G, H> Hash for (A, B, C, D, E, F, G, H) where
    C: Hash,
    A: Hash,
    E: Hash,
    G: Hash,
    F: Hash,
    B: Hash,
    D: Hash,
    H: Hash + ?Sized, [src]

impl<Ret> Hash for unsafe extern "C" fn() -> Ret[src]

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Hash for fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret[src]

impl<Ret, A, B, C, D, E, F, G, H, I> Hash for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret[src]

impl Hash for i64[src]

impl<Ret, A, B, C, D> Hash for extern "C" fn(A, B, C, D, ...) -> Ret[src]

impl<Ret, A, B, C, D, E, F, G, H, I> Hash for extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret[src]

impl Hash for i16[src]

impl<Ret, A, B, C, D, E, F, G> Hash for unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret[src]

impl<'_, T> Hash for &'_ mut T where
    T: Hash + ?Sized, [src]

impl<Ret, A> Hash for extern "C" fn(A, ...) -> Ret[src]

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Hash for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret[src]

impl<Ret, A, B, C, D, E, F, G, H, I, J> Hash for fn(A, B, C, D, E, F, G, H, I, J) -> Ret[src]

impl Hash for u16[src]

impl<T, const N: usize> Hash for [T; N] where
    T: Hash, [src]

impl<Ret, A, B, C, D, E, F> Hash for extern "C" fn(A, B, C, D, E, F) -> Ret[src]

impl<Ret, A, B, C, D, E, F, G, H, I, J> Hash for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret[src]

impl<B> Hash for BitSet<B> where
    B: BitBlock, 

impl<B> Hash for BitVec<B> where
    B: BitBlock, [src]

impl<'a> Hash for Metadata<'a>[src]

impl Hash for LevelFilter[src]

impl Hash for Level[src]

impl<'a> Hash for MetadataBuilder<'a>[src]

impl<T> Hash for Complex<T> where
    T: Hash, [src]

impl<T> Hash for CachePadded<T> where
    T: Hash, 

impl Hash for WriteStyle[src]

impl Hash for Target[src]

impl Hash for Duration

impl Hash for Match

Loading content...

Implementors

impl Hash for AxisOp[src]

impl Hash for Cost[src]

impl Hash for DatumType

impl Hash for TDim

impl Hash for Validation[src]

impl Hash for ConcatSlice[src]

impl Hash for PadMode[src]

impl Hash for KernelFormat[src]

impl Hash for PaddingSpec[src]

impl Hash for DataFormat[src]

impl Hash for Reducer[src]

impl Hash for orkhon::prelude::ops::nn::tract_downcast_rs::__std::cmp::Ordering[src]

impl Hash for Infallible1.44.0[src]

impl Hash for ErrorKind[src]

impl Hash for IpAddr1.7.0[src]

impl Hash for Ipv6MulticastScope[src]

impl Hash for SocketAddr[src]

impl Hash for orkhon::prelude::ops::nn::tract_downcast_rs::__std::sync::atomic::Ordering[src]

impl Hash for FusedSpec

impl Hash for MatrixStoreSpec

impl Hash for SliceOrIndex[src]

impl Hash for QParamsInputKind[src]

impl Hash for InputMapping[src]

impl Hash for StateInitializer[src]

impl Hash for AxisInfo[src]

impl Hash for Blob

impl Hash for InletId[src]

impl Hash for OutletId[src]

impl Hash for ShapeFact[src]

impl Hash for Symbol

impl Hash for Tensor

impl Hash for TypedFact[src]

impl Hash for ConstantOfShape[src]

impl Hash for FiniteReshape[src]

impl Hash for Gather[src]

impl Hash for MultiBroadcastTo[src]

impl Hash for OneHot[src]

impl Hash for Pad[src]

impl Hash for orkhon::prelude::ops::array::Slice[src]

impl Hash for Tile[src]

impl Hash for TypedConcat[src]

impl Hash for MergeOpUnicast[src]

impl Hash for TypedBinOp[src]

impl Hash for UnaryOp[src]

impl Hash for Cast[src]

impl Hash for Im2Col[src]

impl Hash for ConvUnary[src]

impl Hash for MaxPool[src]

impl Hash for Patch[src]

impl Hash for PatchSpec[src]

impl Hash for PoolSpec[src]

impl Hash for SumPool[src]

impl Hash for Dummy[src]

impl Hash for ElementWiseOp[src]

impl Hash for Identity[src]

impl Hash for Const[src]

impl Hash for And[src]

impl Hash for Equals[src]

impl Hash for Greater[src]

impl Hash for GreaterEqual[src]

impl Hash for Iff[src]

impl Hash for Lesser[src]

impl Hash for LesserEqual[src]

impl Hash for Not[src]

impl Hash for NotEquals[src]

impl Hash for Or[src]

impl Hash for Xor[src]

impl Hash for Abs[src]

impl Hash for Acos[src]

impl Hash for Acosh[src]

impl Hash for Add[src]

impl Hash for Asin[src]

impl Hash for Asinh[src]

impl Hash for Atan[src]

impl Hash for Atanh[src]

impl Hash for Ceil[src]

impl Hash for Cos[src]

impl Hash for Cosh[src]

impl Hash for Div[src]

impl Hash for Exp[src]

impl Hash for FlippedPow[src]

impl Hash for FlippedShiftLeft[src]

impl Hash for FlippedShiftRight[src]

impl Hash for Floor[src]

impl Hash for Ln[src]

impl Hash for Max[src]

impl Hash for Min[src]

impl Hash for Mul[src]

impl Hash for Neg[src]

impl Hash for Pow[src]

impl Hash for Recip[src]

impl Hash for Rem[src]

impl Hash for Round[src]

impl Hash for RoundHalfToEven[src]

impl Hash for Rsqrt[src]

impl Hash for ShiftLeft[src]

impl Hash for ShiftRight[src]

impl Hash for Sign[src]

impl Hash for Sin[src]

impl Hash for Sinh[src]

impl Hash for Sqrt[src]

impl Hash for Square[src]

impl Hash for Sub[src]

impl Hash for Tan[src]

impl Hash for Tanh[src]

impl Hash for LirMatMulUnary[src]

impl Hash for MatMatMulPack[src]

impl Hash for MatMul[src]

impl Hash for MatMulUnary[src]

impl Hash for Reduce[src]

impl Hash for Sigmoid[src]

impl Hash for Error[src]

impl Hash for TypeId[src]

impl Hash for CStr[src]

impl Hash for CString[src]

impl Hash for OsStr[src]

impl Hash for OsString[src]

impl Hash for FileType1.1.0[src]

impl Hash for PhantomPinned1.33.0[src]

impl Hash for Ipv4Addr[src]

impl Hash for Ipv6Addr[src]

impl Hash for SocketAddrV4[src]

impl Hash for SocketAddrV6[src]

impl Hash for NonZeroI81.34.0[src]

impl Hash for NonZeroI161.34.0[src]

impl Hash for NonZeroI321.34.0[src]

impl Hash for NonZeroI641.34.0[src]

impl Hash for NonZeroI1281.34.0[src]

impl Hash for NonZeroIsize1.34.0[src]

impl Hash for NonZeroU81.28.0[src]

impl Hash for NonZeroU161.28.0[src]

impl Hash for NonZeroU321.28.0[src]

impl Hash for NonZeroU641.28.0[src]

impl Hash for NonZeroU1281.28.0[src]

impl Hash for NonZeroUsize1.28.0[src]

impl Hash for RangeFull[src]

impl Hash for NoneError[src]

impl Hash for UCred[src]

impl Hash for Path[src]

impl Hash for PathBuf[src]

impl Hash for Box<dyn ElementWiseMiniOp + 'static, Global>[src]

impl Hash for Box<dyn TypedOp + 'static, Global>[src]

impl Hash for Box<dyn BinMiniOp + 'static, Global>[src]

impl Hash for String[src]

impl Hash for ThreadId1.19.0[src]

impl Hash for orkhon::prelude::ops::nn::tract_downcast_rs::__std::time::Duration1.3.0[src]

impl Hash for Instant1.8.0[src]

impl Hash for SystemTime1.8.0[src]

impl Hash for Packer

impl Hash for Axis[src]

impl Hash for IxDynImpl[src]

impl Hash for orkhon::prelude::ops::nn::tract_ndarray::Slice[src]

impl Hash for DequantizeLinearF32[src]

impl Hash for LookupTable[src]

impl Hash for QParams[src]

impl Hash for QuantizeLinearI8[src]

impl Hash for QuantizeLinearU8[src]

impl Hash for LirScan[src]

impl Hash for Scan[src]

impl Hash for TypedSource[src]

impl Hash for Downsample[src]

impl Hash for UnimplementedOp[src]

impl<'_> Hash for PrefixComponent<'_>[src]

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

impl<'a> Hash for Component<'a>[src]

impl<'a> Hash for Prefix<'a>[src]

impl<'a> Hash for Location<'a>1.10.0[src]

impl<'a, S, D> Hash for ArrayBase<S, D> where
    S: Data,
    D: Dimension,
    <S as RawData>::Elem: Hash, [src]

impl<A> Hash for SmallVec<A> where
    A: Array,
    <A as Array>::Item: Hash, [src]

impl<A> Hash for VecDeque<A> where
    A: Hash, [src]

impl<A, B> Hash for EitherOrBoth<A, B> where
    A: Hash,
    B: Hash, [src]

impl<D, S> Hash for BaseDataShape<D, S> where
    S: Hash + AsRef<[D]> + Debug,
    D: Hash + DimLike, [src]

impl<F> Hash for Outlet<F> where
    F: Fact + Hash, [src]

impl<F> Hash for OutputMapping<F> where
    F: Clone + Hash, [src]

impl<F, O> Hash for Graph<F, O> where
    F: Fact + Hash + Clone + 'static,
    O: Debug + Display + AsRef<dyn Op + 'static> + AsMut<dyn Op + 'static> + Clone + 'static + Hash, [src]

impl<F, O> Hash for Node<F, O> where
    F: Fact + Hash,
    O: Hash, [src]

impl<F, O, M> Hash for SimplePlan<F, O, M> where
    F: Fact + Hash + Clone + 'static,
    O: Debug + Display + AsRef<dyn Op + 'static> + AsMut<dyn Op + 'static> + Clone + 'static + Hash,
    M: Borrow<Graph<F, O>> + Hash, [src]

impl<I> Hash for Dim<I> where
    I: Hash + ?Sized, [src]

impl<Idx> Hash for Range<Idx> where
    Idx: Hash, [src]

impl<Idx> Hash for RangeFrom<Idx> where
    Idx: Hash, [src]

impl<Idx> Hash for RangeInclusive<Idx> where
    Idx: Hash, 1.26.0[src]

impl<Idx> Hash for RangeTo<Idx> where
    Idx: Hash, [src]

impl<Idx> Hash for RangeToInclusive<Idx> where
    Idx: Hash, 1.26.0[src]

impl<K, V> Hash for BTreeMap<K, V> where
    K: Hash,
    V: Hash, [src]

impl<L, R> Hash for Either<L, R> where
    R: Hash,
    L: Hash, [src]

impl<P> Hash for Pin<P> where
    P: Deref,
    <P as Deref>::Target: Hash, 1.41.0[src]

impl<T> Hash for Bound<T> where
    T: Hash, 1.17.0[src]

impl<T> Hash for Option<T> where
    T: Hash, [src]

impl<T> Hash for Poll<T> where
    T: Hash, 1.36.0[src]

impl<T> Hash for Arc<T> where
    T: Hash + ?Sized, [src]

impl<T> Hash for PhantomData<T> where
    T: ?Sized, [src]

impl<T> Hash for Rc<T> where
    T: Hash + ?Sized, [src]

impl<T> Hash for Reverse<T> where
    T: Hash, 1.19.0[src]

impl<T> Hash for BTreeSet<T> where
    T: Hash, [src]

impl<T> Hash for LinkedList<T> where
    T: Hash, [src]

impl<T> Hash for Discriminant<T>1.21.0[src]

impl<T> Hash for ManuallyDrop<T> where
    T: Hash + ?Sized, 1.20.0[src]

impl<T> Hash for Wrapping<T> where
    T: Hash, [src]

impl<T> Hash for NonNull<T> where
    T: ?Sized, 1.25.0[src]

impl<T, A> Hash for Box<T, A> where
    T: Hash + ?Sized,
    A: Allocator, [src]

impl<T, A> Hash for Vec<T, A> where
    T: Hash,
    A: Allocator, [src]

impl<T, E> Hash for Result<T, E> where
    T: Hash,
    E: Hash, [src]

impl<Y, R> Hash for GeneratorState<Y, R> where
    R: Hash,
    Y: Hash, [src]

Loading content...