Trait tract_core::internal::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<'a> Hash for Prefix<'a>`[src]

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

`impl Hash for ThreadId`[src]

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

`impl Hash for Path`[src]

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

`impl Hash for OsString`[src]

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

`impl Hash for IpAddr`[src]

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

`impl Hash for SocketAddr`[src]

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

`impl Hash for SocketAddrV4`[src]

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

`impl Hash for Ipv6MulticastScope`[src]

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

`impl Hash for OsStr`[src]

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

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

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

`impl Hash for SocketAddrV6`[src]

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

`impl Hash for CString`[src]

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

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

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

`impl Hash for UCred`[src]

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

`impl Hash for ErrorKind`[src]

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

`impl Hash for Instant`[src]

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

`impl Hash for CStr`[src]

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

`impl Hash for PathBuf`[src]

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

`impl Hash for Ipv4Addr`[src]

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

`impl Hash for SystemTime`[src]

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

`impl Hash for FileType`[src]

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

`impl Hash for Ipv6Addr`[src]

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

`impl Hash for Duration`[src]

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

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

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

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

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

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

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

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

`pub fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [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]

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

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

`pub fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [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]

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

`impl Hash for NonZeroI8`[src]

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

`impl Hash for NonZeroU128`[src]

`pub fn hash<H>(&self, state: &mut H) where __H: Hasher,` [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]

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

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

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

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

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

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

`pub fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [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]

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

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

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

`impl Hash for NonZeroI16`[src]

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

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

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

`impl Hash for NonZeroI64`[src]

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

`impl Hash for NonZeroI32`[src]

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

`impl Hash for !`[src]

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

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

`pub fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [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]

`pub fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [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]

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

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

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

`impl Hash for u128`[src]

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

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

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

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

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

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

`impl Hash for TypeId`[src]

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

`impl Hash for ()`[src]

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

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

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

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

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

`impl Hash for i128`[src]

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

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

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

`pub fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [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]

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

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

`pub fn hash<H>(&self, state: &mut H) where H: Hasher,` [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]

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

`impl Hash for Ordering`[src]

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

`impl Hash for i16`[src]

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

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

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

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

`impl Hash for bool`[src]

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

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

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

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

`pub fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [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]

`pub fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [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]

`pub fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [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]

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

`impl Hash for NonZeroU16`[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`pub fn hash<H>(&self, state: &mut H) where __H: Hasher,` [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]

`pub fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [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]

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

`impl Hash for RangeFull`[src]

`pub fn hash<H>(&self, state: &mut H) where __H: Hasher,` [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]

`pub fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [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]

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

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

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

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

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

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

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

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

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

`impl Hash for str`[src]

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

`impl Hash for Infallible`[src]

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

`impl<Dyn> Hash for DynMetadata<Dyn> where Dyn: ?Sized,` [src]

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

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

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

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

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

`impl Hash for u16`[src]

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

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

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

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

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

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

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

`pub fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [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]

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

`impl Hash for isize`[src]

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

`pub fn hash_slice<H>(data: &[isize], state: &mut H) where H: Hasher,` [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]

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

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

`pub fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [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, H: Hash, D: Hash, F: Hash, A: Hash, B: Hash, E: Hash, K: Hash, I: Hash, G: Hash, L: Hash + ?Sized, J: Hash,` [src]

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

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

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

`impl Hash for NonZeroI128`[src]

`pub fn hash<H>(&self, state: &mut H) where __H: Hasher,` [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]

`pub fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [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]

`pub fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [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]

`pub fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [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]

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

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

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

`impl Hash for char`[src]

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

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

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

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

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

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

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

`impl Hash for NoneError`[src]

`pub fn hash<H>(&self, state: &mut H) where __H: Hasher,` [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, H: Hash, D: Hash, F: Hash, A: Hash, B: Hash, E: Hash, I: Hash + ?Sized, G: Hash,` [src]

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

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

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

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

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

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

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

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

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

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

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

`impl Hash for i8`[src]

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

`pub fn hash_slice<H>(data: &[i8], state: &mut H) where H: Hasher,` [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]

`pub fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [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]

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

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

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

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

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

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

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

`impl Hash for u64`[src]

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

`pub fn hash_slice<H>(data: &[u64], state: &mut H) where H: Hasher,` [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]

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

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

`pub fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [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, H: Hash, D: Hash, F: Hash, A: Hash, B: Hash, E: Hash, K: Hash + ?Sized, I: Hash, G: Hash, J: Hash,` [src]

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

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

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

`impl Hash for Ordering`[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`impl Hash for NonZeroUsize`[src]

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

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

`pub fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [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]

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

`impl Hash for PhantomPinned`[src]

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

`impl Hash for usize`[src]

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

`pub fn hash_slice<H>(data: &[usize], state: &mut H) where H: Hasher,` [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]

`pub fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [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]

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

`impl Hash for NonZeroU32`[src]

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

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

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

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

`pub fn hash<S>(&self, state: &mut S) where S: Hasher,` [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]

`pub fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [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, H: Hash, D: Hash, F: Hash, A: Hash, B: Hash, E: Hash, I: Hash, G: Hash, J: Hash + ?Sized,` [src]

`pub fn hash<S>(&self, state: &mut S) where S: Hasher,` [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]

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

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

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

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

`pub fn hash<H>(&self, state: &mut H) where __H: Hasher,` [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]

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

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

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

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

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

`impl Hash for u8`[src]

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

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

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

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

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

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

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

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

`impl Hash for i64`[src]

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

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

`impl Hash for NonZeroIsize`[src]

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

`impl Hash for NonZeroU8`[src]

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

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

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

`impl Hash for NonZeroU64`[src]

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

`impl Hash for u32`[src]

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

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

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

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

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

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

`impl Hash for i32`[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`impl Hash for Level`[src]

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

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

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

`impl Hash for LevelFilter`[src]

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

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

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

`impl Hash for Packer`[src]

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

`impl Hash for MatrixStoreSpec`[src]

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

Loading content...

Implementors

`impl Hash for DatumType`[src]

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

`impl Hash for TDim`[src]

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

`impl Hash for SliceOrIndex`[src]

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

`impl Hash for ConcatSlice`[src]

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

`impl Hash for PadMode`[src]

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

`impl Hash for AxisOp`[src]

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

`impl Hash for KernelFormat`[src]

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

`impl Hash for PaddingSpec`[src]

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

`impl Hash for AttrOrInput`[src]

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

`impl Hash for Cost`[src]

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

`impl Hash for Validation`[src]

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

`impl Hash for ProtoFusedSpec`[src]

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

`impl Hash for DataFormat`[src]

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

`impl Hash for Reducer`[src]

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

`impl Hash for InputMapping`[src]

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

`impl Hash for StateInitializer`[src]

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

`impl Hash for Blob`[src]

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

`impl Hash for Symbol`[src]

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

`impl Hash for Tensor`[src]

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

`impl Hash for Axis`[src]

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

`impl Hash for IxDynImpl`[src]

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

`impl Hash for tract_core::internal::tract_ndarray::Slice`[src]

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

`impl Hash for Error`[src]

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

`impl Hash for Box<dyn BinMiniOp>`[src]

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

`impl Hash for Box<dyn ElementWiseMiniOp>`[src]

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

`impl Hash for Box<dyn TypedOp>`[src]

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

`impl Hash for String`[src]

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

`impl Hash for Dims`[src]

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

`impl Hash for InletId`[src]

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

`impl Hash for OutletId`[src]

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

`impl Hash for ShapeFact`[src]

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

`impl Hash for TypedFact`[src]

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

`impl Hash for ConstantOfShape`[src]

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

`impl Hash for FiniteReshape`[src]

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

`impl Hash for Gather`[src]

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

`impl Hash for MultiBroadcastTo`[src]

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

`impl Hash for OneHot`[src]

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

`impl Hash for Pad`[src]

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

`impl Hash for tract_core::ops::array::Slice`[src]

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

`impl Hash for Tile`[src]

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

`impl Hash for TypedConcat`[src]

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

`impl Hash for MergeOpUnicast`[src]

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

`impl Hash for TypedBinOp`[src]

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

`impl Hash for UnaryOp`[src]

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

`impl Hash for Cast`[src]

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

`impl Hash for ConvUnary`[src]

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

`impl Hash for Im2Col`[src]

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

`impl Hash for PoolSpec`[src]

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

`impl Hash for MaxPool`[src]

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

`impl Hash for Patch`[src]

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

`impl Hash for PatchSpec`[src]

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

`impl Hash for SumPool`[src]

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

`impl Hash for Downsample`[src]

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

`impl Hash for Dummy`[src]

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

`impl Hash for ElementWiseOp`[src]

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

`impl Hash for Identity`[src]

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

`impl Hash for AxisInfo`[src]

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

`impl Hash for Const`[src]

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

`impl Hash for And`[src]

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

`impl Hash for Equals`[src]

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

`impl Hash for Greater`[src]

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

`impl Hash for GreaterEqual`[src]

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

`impl Hash for Iff`[src]

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

`impl Hash for Lesser`[src]

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

`impl Hash for LesserEqual`[src]

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

`impl Hash for Not`[src]

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

`impl Hash for NotEquals`[src]

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

`impl Hash for Or`[src]

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

`impl Hash for Xor`[src]

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

`impl Hash for Abs`[src]

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

`impl Hash for Acos`[src]

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

`impl Hash for Acosh`[src]

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

`impl Hash for Add`[src]

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

`impl Hash for Asin`[src]

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

`impl Hash for Asinh`[src]

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

`impl Hash for Atan`[src]

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

`impl Hash for Atanh`[src]

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

`impl Hash for Ceil`[src]

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

`impl Hash for Cos`[src]

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

`impl Hash for Cosh`[src]

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

`impl Hash for Div`[src]

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

`impl Hash for Exp`[src]

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

`impl Hash for FlippedPow`[src]

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

`impl Hash for FlippedShiftLeft`[src]

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

`impl Hash for FlippedShiftRight`[src]

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

`impl Hash for Floor`[src]

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

`impl Hash for Ln`[src]

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

`impl Hash for Max`[src]

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

`impl Hash for Min`[src]

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

`impl Hash for Mul`[src]

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

`impl Hash for Neg`[src]

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

`impl Hash for Pow`[src]

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

`impl Hash for Recip`[src]

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

`impl Hash for Rem`[src]

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

`impl Hash for Round`[src]

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

`impl Hash for RoundHalfToEven`[src]

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

`impl Hash for Rsqrt`[src]

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

`impl Hash for ShiftLeft`[src]

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

`impl Hash for ShiftRight`[src]

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

`impl Hash for Sign`[src]

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

`impl Hash for Sin`[src]

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

`impl Hash for Sinh`[src]

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

`impl Hash for Sqrt`[src]

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

`impl Hash for Square`[src]

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

`impl Hash for Sub`[src]

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

`impl Hash for Tan`[src]

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

`impl Hash for Tanh`[src]

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

`impl Hash for LirMatMulUnary`[src]

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

`impl Hash for MatMul`[src]

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

`impl Hash for QMatMul`[src]

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

`impl Hash for QParams`[src]

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

`impl Hash for MatMulUnary`[src]

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

`impl Hash for MatMatMulPack`[src]

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

`impl Hash for Reduce`[src]

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

`impl Hash for Sigmoid`[src]

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

`impl Hash for DequantizeLinearF32`[src]

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

`impl Hash for LookupTable`[src]

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

`impl Hash for QuantizeLinearI8`[src]

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

`impl Hash for QuantizeLinearU8`[src]

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

`impl Hash for Scale`[src]

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

`impl Hash for LirScan`[src]

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

`impl Hash for Scan`[src]

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

`impl Hash for TypedSource`[src]

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

`impl Hash for UnimplementedOp`[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Loading content...