Trait Hashable 

pub trait Hashable {
    // Required methods
    fn hash(&self) -> Digest;
    fn leaf_count(&self) -> usize;
    fn hashable_pair<'a>(
        &'a self,
    ) -> Option<(impl Hashable + 'a, impl Hashable + 'a)>;
}

Required Methods

fn hash(&self) -> Digest

fn leaf_count(&self) -> usize

fn hashable_pair<'a>( &'a self, ) -> Option<(impl Hashable + 'a, impl Hashable + 'a)>

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl Hashable for &str

fn hash(&self) -> Digest

fn leaf_count(&self) -> usize

fn hashable_pair<'a>( &'a self, ) -> Option<(impl Hashable + 'a, impl Hashable + 'a)>

impl Hashable for ()

fn hash(&self) -> Digest

fn leaf_count(&self) -> usize

fn hashable_pair<'a>( &'a self, ) -> Option<(impl Hashable + 'a, impl Hashable + 'a)>

impl Hashable for String

Available on crate feature alloc only.

fn hash(&self) -> Digest

fn leaf_count(&self) -> usize

fn hashable_pair<'a>( &'a self, ) -> Option<(impl Hashable + 'a, impl Hashable + 'a)>

impl Hashable for bool

fn hash(&self) -> Digest

fn leaf_count(&self) -> usize

fn hashable_pair<'a>( &'a self, ) -> Option<(impl Hashable + 'a, impl Hashable + 'a)>

impl Hashable for i32

fn hash(&self) -> Digest

fn leaf_count(&self) -> usize

fn hashable_pair<'a>( &'a self, ) -> Option<(impl Hashable + 'a, impl Hashable + 'a)>

impl Hashable for u32

fn hash(&self) -> Digest

fn leaf_count(&self) -> usize

fn hashable_pair<'a>( &'a self, ) -> Option<(impl Hashable + 'a, impl Hashable + 'a)>

impl Hashable for u64

fn hash(&self) -> Digest

fn leaf_count(&self) -> usize

fn hashable_pair<'a>( &'a self, ) -> Option<(impl Hashable + 'a, impl Hashable + 'a)>

impl Hashable for usize

fn hash(&self) -> Digest

fn leaf_count(&self) -> usize

fn hashable_pair<'a>( &'a self, ) -> Option<(impl Hashable + 'a, impl Hashable + 'a)>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> Hashable for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

where A: Hashable, B: Hashable, C: Hashable, D: Hashable, E: Hashable, F: Hashable, G: Hashable, H: Hashable, I: Hashable, J: Hashable, K: Hashable, L: Hashable, M: Hashable, N: Hashable, O: Hashable, P: Hashable, Q: Hashable, R: Hashable, S: Hashable, T: Hashable,

fn hash(&self) -> Digest

fn leaf_count(&self) -> usize

fn hashable_pair<'a>( &'a self, ) -> Option<(impl Hashable + 'a, impl Hashable + 'a)>

impl<B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> Hashable for (B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

where B: Hashable, C: Hashable, D: Hashable, E: Hashable, F: Hashable, G: Hashable, H: Hashable, I: Hashable, J: Hashable, K: Hashable, L: Hashable, M: Hashable, N: Hashable, O: Hashable, P: Hashable, Q: Hashable, R: Hashable, S: Hashable, T: Hashable,

fn hash(&self) -> Digest

fn leaf_count(&self) -> usize

fn hashable_pair<'a>( &'a self, ) -> Option<(impl Hashable + 'a, impl Hashable + 'a)>

impl<C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> Hashable for (C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

where C: Hashable, D: Hashable, E: Hashable, F: Hashable, G: Hashable, H: Hashable, I: Hashable, J: Hashable, K: Hashable, L: Hashable, M: Hashable, N: Hashable, O: Hashable, P: Hashable, Q: Hashable, R: Hashable, S: Hashable, T: Hashable,

fn hash(&self) -> Digest

fn leaf_count(&self) -> usize

fn hashable_pair<'a>( &'a self, ) -> Option<(impl Hashable + 'a, impl Hashable + 'a)>

impl<D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> Hashable for (D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

where D: Hashable, E: Hashable, F: Hashable, G: Hashable, H: Hashable, I: Hashable, J: Hashable, K: Hashable, L: Hashable, M: Hashable, N: Hashable, O: Hashable, P: Hashable, Q: Hashable, R: Hashable, S: Hashable, T: Hashable,

fn hash(&self) -> Digest

fn leaf_count(&self) -> usize

fn hashable_pair<'a>( &'a self, ) -> Option<(impl Hashable + 'a, impl Hashable + 'a)>

impl<E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> Hashable for (E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

where E: Hashable, F: Hashable, G: Hashable, H: Hashable, I: Hashable, J: Hashable, K: Hashable, L: Hashable, M: Hashable, N: Hashable, O: Hashable, P: Hashable, Q: Hashable, R: Hashable, S: Hashable, T: Hashable,

fn hash(&self) -> Digest

fn leaf_count(&self) -> usize

fn hashable_pair<'a>( &'a self, ) -> Option<(impl Hashable + 'a, impl Hashable + 'a)>

impl<F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> Hashable for (F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

where F: Hashable, G: Hashable, H: Hashable, I: Hashable, J: Hashable, K: Hashable, L: Hashable, M: Hashable, N: Hashable, O: Hashable, P: Hashable, Q: Hashable, R: Hashable, S: Hashable, T: Hashable,

fn hash(&self) -> Digest

fn leaf_count(&self) -> usize

fn hashable_pair<'a>( &'a self, ) -> Option<(impl Hashable + 'a, impl Hashable + 'a)>

impl<G, H, I, J, K, L, M, N, O, P, Q, R, S, T> Hashable for (G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

where G: Hashable, H: Hashable, I: Hashable, J: Hashable, K: Hashable, L: Hashable, M: Hashable, N: Hashable, O: Hashable, P: Hashable, Q: Hashable, R: Hashable, S: Hashable, T: Hashable,

fn hash(&self) -> Digest

fn leaf_count(&self) -> usize

fn hashable_pair<'a>( &'a self, ) -> Option<(impl Hashable + 'a, impl Hashable + 'a)>

impl<H, I, J, K, L, M, N, O, P, Q, R, S, T> Hashable for (H, I, J, K, L, M, N, O, P, Q, R, S, T)

where H: Hashable, I: Hashable, J: Hashable, K: Hashable, L: Hashable, M: Hashable, N: Hashable, O: Hashable, P: Hashable, Q: Hashable, R: Hashable, S: Hashable, T: Hashable,

fn hash(&self) -> Digest

fn leaf_count(&self) -> usize

fn hashable_pair<'a>( &'a self, ) -> Option<(impl Hashable + 'a, impl Hashable + 'a)>

impl<I, J, K, L, M, N, O, P, Q, R, S, T> Hashable for (I, J, K, L, M, N, O, P, Q, R, S, T)

where I: Hashable, J: Hashable, K: Hashable, L: Hashable, M: Hashable, N: Hashable, O: Hashable, P: Hashable, Q: Hashable, R: Hashable, S: Hashable, T: Hashable,

fn hash(&self) -> Digest

fn leaf_count(&self) -> usize

fn hashable_pair<'a>( &'a self, ) -> Option<(impl Hashable + 'a, impl Hashable + 'a)>

impl<J, K, L, M, N, O, P, Q, R, S, T> Hashable for (J, K, L, M, N, O, P, Q, R, S, T)

where J: Hashable, K: Hashable, L: Hashable, M: Hashable, N: Hashable, O: Hashable, P: Hashable, Q: Hashable, R: Hashable, S: Hashable, T: Hashable,

fn hash(&self) -> Digest

fn leaf_count(&self) -> usize

fn hashable_pair<'a>( &'a self, ) -> Option<(impl Hashable + 'a, impl Hashable + 'a)>

impl<K, L, M, N, O, P, Q, R, S, T> Hashable for (K, L, M, N, O, P, Q, R, S, T)

where K: Hashable, L: Hashable, M: Hashable, N: Hashable, O: Hashable, P: Hashable, Q: Hashable, R: Hashable, S: Hashable, T: Hashable,

fn hash(&self) -> Digest

fn leaf_count(&self) -> usize

fn hashable_pair<'a>( &'a self, ) -> Option<(impl Hashable + 'a, impl Hashable + 'a)>

impl<L, M, N, O, P, Q, R, S, T> Hashable for (L, M, N, O, P, Q, R, S, T)

where L: Hashable, M: Hashable, N: Hashable, O: Hashable, P: Hashable, Q: Hashable, R: Hashable, S: Hashable, T: Hashable,

fn hash(&self) -> Digest

fn leaf_count(&self) -> usize

fn hashable_pair<'a>( &'a self, ) -> Option<(impl Hashable + 'a, impl Hashable + 'a)>

impl<M, N, O, P, Q, R, S, T> Hashable for (M, N, O, P, Q, R, S, T)

where M: Hashable, N: Hashable, O: Hashable, P: Hashable, Q: Hashable, R: Hashable, S: Hashable, T: Hashable,

fn hash(&self) -> Digest

fn leaf_count(&self) -> usize

fn hashable_pair<'a>( &'a self, ) -> Option<(impl Hashable + 'a, impl Hashable + 'a)>

impl<N, O, P, Q, R, S, T> Hashable for (N, O, P, Q, R, S, T)

where N: Hashable, O: Hashable, P: Hashable, Q: Hashable, R: Hashable, S: Hashable, T: Hashable,

fn hash(&self) -> Digest

fn leaf_count(&self) -> usize

fn hashable_pair<'a>( &'a self, ) -> Option<(impl Hashable + 'a, impl Hashable + 'a)>

impl<O, P, Q, R, S, T> Hashable for (O, P, Q, R, S, T)

where O: Hashable, P: Hashable, Q: Hashable, R: Hashable, S: Hashable, T: Hashable,

fn hash(&self) -> Digest

fn leaf_count(&self) -> usize

fn hashable_pair<'a>( &'a self, ) -> Option<(impl Hashable + 'a, impl Hashable + 'a)>

impl<P, Q, R, S, T> Hashable for (P, Q, R, S, T)

where P: Hashable, Q: Hashable, R: Hashable, S: Hashable, T: Hashable,

fn hash(&self) -> Digest

fn leaf_count(&self) -> usize

fn hashable_pair<'a>( &'a self, ) -> Option<(impl Hashable + 'a, impl Hashable + 'a)>

impl<Q, R, S, T> Hashable for (Q, R, S, T)

where Q: Hashable, R: Hashable, S: Hashable, T: Hashable,

fn hash(&self) -> Digest

fn leaf_count(&self) -> usize

fn hashable_pair<'a>( &'a self, ) -> Option<(impl Hashable + 'a, impl Hashable + 'a)>

impl<R, S, T> Hashable for (R, S, T)

where R: Hashable, S: Hashable, T: Hashable,

fn hash(&self) -> Digest

fn leaf_count(&self) -> usize

fn hashable_pair<'a>( &'a self, ) -> Option<(impl Hashable + 'a, impl Hashable + 'a)>

impl<S, T> Hashable for (S, T)

where S: Hashable, T: Hashable,

fn hash(&self) -> Digest

fn leaf_count(&self) -> usize

fn hashable_pair<'a>( &'a self, ) -> Option<(impl Hashable + 'a, impl Hashable + 'a)>

impl<T, P> Hashable for Either<T, P>

where T: Hashable, P: Hashable,

fn hash(&self) -> Digest

fn leaf_count(&self) -> usize

fn hashable_pair<'a>( &'a self, ) -> Option<(impl Hashable + 'a, impl Hashable + 'a)>

impl<T> Hashable for &T

where T: Hashable + ?Sized,

fn hash(&self) -> Digest

fn leaf_count(&self) -> usize

fn hashable_pair<'a>( &'a self, ) -> Option<(impl Hashable + 'a, impl Hashable + 'a)>

impl<T> Hashable for &[T]

where T: Hashable,

fn hash(&self) -> Digest

fn leaf_count(&self) -> usize

fn hashable_pair<'a>( &'a self, ) -> Option<(impl Hashable + 'a, impl Hashable + 'a)>

impl<T> Hashable for Option<T>

where T: Hashable,

fn hash(&self) -> Digest

fn leaf_count(&self) -> usize

fn hashable_pair<'a>( &'a self, ) -> Option<(impl Hashable + 'a, impl Hashable + 'a)>

impl<T> Hashable for Vec<T>

where T: Hashable,

Available on crate feature alloc only.

fn hash(&self) -> Digest

fn leaf_count(&self) -> usize

fn hashable_pair<'a>( &'a self, ) -> Option<(impl Hashable + 'a, impl Hashable + 'a)>

Implementors

impl Hashable for Belt

impl Hashable for Bignum

where FixedTas<iris_ztd::::bignum::{impl#7}::{constant#0}>: Hashable, Vec<u32>: Hashable, FixedTas<iris_ztd::::bignum::{impl#7}::{constant#1}>: Hashable, FixedTas<iris_ztd::::bignum::{impl#7}::{constant#2}>: Hashable,

impl Hashable for CheetahPoint

impl Hashable for Digest

impl Hashable for MerkleProof

where Digest: Hashable, Vec<Digest>: Hashable,

impl Hashable for MerkleProvenAxis

where MerkleProof: Hashable, u64: Hashable,

impl Hashable for Noun

Available on crate feature alloc only.

impl Hashable for PublicKey

impl Hashable for Signature

Available on crate feature alloc only.

impl<K, V> Hashable for ZMap<K, V>

where ZBase<ZMapEntry<K, V>>: Hashable,

impl<K, V> Hashable for ZMapEntry<K, V>

where K: Hashable, V: Hashable,

impl<T, O> Hashable for HashableList<T>

where T: Deref<Target = [O]>, O: Hashable,

Available on crate feature alloc only.

impl<T> Hashable for ZSet<T>

where ZBase<ZSetEntry<T>>: Hashable,

impl<T> Hashable for ZSetEntry<T>

where T: Hashable,

impl<T> Hashable for Zeroable<T>

where T: Hashable,

Available on crate feature alloc only.

impl<const V: u32> Hashable for FixedU32<V>

impl<const V: u64> Hashable for FixedTas<V>

impl<const V: u64> Hashable for FixedU64<V>