Trait Size 

pub trait Size {
    type Size: Unsigned;

    const SIZE: usize = <Self::Size as Unsigned>::USIZE;
}

Provided Associated Constants

const SIZE: usize = <Self::Size as Unsigned>::USIZE

Required Associated Types

type Size: Unsigned

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 Size for Infallible

const SIZE: usize = 0usize

type Size = UTerm

impl Size for bool

type Size = UInt<UTerm, B1>

impl Size for u8

const SIZE: usize = 1usize

type Size = UInt<UTerm, B1>

impl Size for ()

const SIZE: usize = 0usize

type Size = UTerm

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

where TArr<A::Size, TArr<B::Size, ATerm>>: FoldAdd<Output: Unsigned>,

const SIZE: usize

type Size = <TArr<<A as Size>::Size, TArr<<B as Size>::Size, ATerm>> as FoldAdd>::Output

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

where TArr<A::Size, TArr<B::Size, TArr<C::Size, ATerm>>>: FoldAdd<Output: Unsigned>,

const SIZE: usize

type Size = <TArr<<A as Size>::Size, TArr<<B as Size>::Size, TArr<<C as Size>::Size, ATerm>>> as FoldAdd>::Output

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

where TArr<A::Size, TArr<B::Size, TArr<C::Size, TArr<D::Size, ATerm>>>>: FoldAdd<Output: Unsigned>,

const SIZE: usize

type Size = <TArr<<A as Size>::Size, TArr<<B as Size>::Size, TArr<<C as Size>::Size, TArr<<D as Size>::Size, ATerm>>>> as FoldAdd>::Output

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

where TArr<A::Size, TArr<B::Size, TArr<C::Size, TArr<D::Size, TArr<E::Size, ATerm>>>>>: FoldAdd<Output: Unsigned>,

const SIZE: usize

type Size = <TArr<<A as Size>::Size, TArr<<B as Size>::Size, TArr<<C as Size>::Size, TArr<<D as Size>::Size, TArr<<E as Size>::Size, ATerm>>>>> as FoldAdd>::Output

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

where TArr<A::Size, TArr<B::Size, TArr<C::Size, TArr<D::Size, TArr<E::Size, TArr<F::Size, ATerm>>>>>>: FoldAdd<Output: Unsigned>,

const SIZE: usize

type Size = <TArr<<A as Size>::Size, TArr<<B as Size>::Size, TArr<<C as Size>::Size, TArr<<D as Size>::Size, TArr<<E as Size>::Size, TArr<<F as Size>::Size, ATerm>>>>>> as FoldAdd>::Output

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

where TArr<A::Size, TArr<B::Size, TArr<C::Size, TArr<D::Size, TArr<E::Size, TArr<F::Size, TArr<G::Size, ATerm>>>>>>>: FoldAdd<Output: Unsigned>,

const SIZE: usize

type Size = <TArr<<A as Size>::Size, TArr<<B as Size>::Size, TArr<<C as Size>::Size, TArr<<D as Size>::Size, TArr<<E as Size>::Size, TArr<<F as Size>::Size, TArr<<G as Size>::Size, ATerm>>>>>>> as FoldAdd>::Output

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

where TArr<A::Size, TArr<B::Size, TArr<C::Size, TArr<D::Size, TArr<E::Size, TArr<F::Size, TArr<G::Size, TArr<H::Size, ATerm>>>>>>>>: FoldAdd<Output: Unsigned>,

const SIZE: usize

type Size = <TArr<<A as Size>::Size, TArr<<B as Size>::Size, TArr<<C as Size>::Size, TArr<<D as Size>::Size, TArr<<E as Size>::Size, TArr<<F as Size>::Size, TArr<<G as Size>::Size, TArr<<H as Size>::Size, ATerm>>>>>>>> as FoldAdd>::Output

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

where TArr<A::Size, TArr<B::Size, TArr<C::Size, TArr<D::Size, TArr<E::Size, TArr<F::Size, TArr<G::Size, TArr<H::Size, TArr<I::Size, ATerm>>>>>>>>>: FoldAdd<Output: Unsigned>,

const SIZE: usize

type Size = <TArr<<A as Size>::Size, TArr<<B as Size>::Size, TArr<<C as Size>::Size, TArr<<D as Size>::Size, TArr<<E as Size>::Size, TArr<<F as Size>::Size, TArr<<G as Size>::Size, TArr<<H as Size>::Size, TArr<<I as Size>::Size, ATerm>>>>>>>>> as FoldAdd>::Output

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

where TArr<A::Size, TArr<B::Size, TArr<C::Size, TArr<D::Size, TArr<E::Size, TArr<F::Size, TArr<G::Size, TArr<H::Size, TArr<I::Size, TArr<J::Size, ATerm>>>>>>>>>>: FoldAdd<Output: Unsigned>,

const SIZE: usize

type Size = <TArr<<A as Size>::Size, TArr<<B as Size>::Size, TArr<<C as Size>::Size, TArr<<D as Size>::Size, TArr<<E as Size>::Size, TArr<<F as Size>::Size, TArr<<G as Size>::Size, TArr<<H as Size>::Size, TArr<<I as Size>::Size, TArr<<J as Size>::Size, ATerm>>>>>>>>>> as FoldAdd>::Output

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

where TArr<A::Size, TArr<B::Size, TArr<C::Size, TArr<D::Size, TArr<E::Size, TArr<F::Size, TArr<G::Size, TArr<H::Size, TArr<I::Size, TArr<J::Size, TArr<K::Size, ATerm>>>>>>>>>>>: FoldAdd<Output: Unsigned>,

const SIZE: usize

type Size = <TArr<<A as Size>::Size, TArr<<B as Size>::Size, TArr<<C as Size>::Size, TArr<<D as Size>::Size, TArr<<E as Size>::Size, TArr<<F as Size>::Size, TArr<<G as Size>::Size, TArr<<H as Size>::Size, TArr<<I as Size>::Size, TArr<<J as Size>::Size, TArr<<K as Size>::Size, ATerm>>>>>>>>>>> as FoldAdd>::Output

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

where TArr<A::Size, TArr<B::Size, TArr<C::Size, TArr<D::Size, TArr<E::Size, TArr<F::Size, TArr<G::Size, TArr<H::Size, TArr<I::Size, TArr<J::Size, TArr<K::Size, TArr<L::Size, ATerm>>>>>>>>>>>>: FoldAdd<Output: Unsigned>,

const SIZE: usize

type Size = <TArr<<A as Size>::Size, TArr<<B as Size>::Size, TArr<<C as Size>::Size, TArr<<D as Size>::Size, TArr<<E as Size>::Size, TArr<<F as Size>::Size, TArr<<G as Size>::Size, TArr<<H as Size>::Size, TArr<<I as Size>::Size, TArr<<J as Size>::Size, TArr<<K as Size>::Size, TArr<<L as Size>::Size, ATerm>>>>>>>>>>>> as FoldAdd>::Output

impl<T: Size + MaybeHasNiche<MnArray: MnArray<MaybeNiche: Niche<NeedsTag = B, N: Add<B, Output = N>>>>, B: Bit, N: Unsigned> Size for Option<T>

type Size = N

impl<T: Size> Size for (T,)

const SIZE: usize = T::SIZE

type Size = <T as Size>::Size

impl<T: Size, const N: usize> Size for [T; N]

where Const<N>: ToUInt<Output: Unsigned + Mul<T::Size, Output: Unsigned>>,

const SIZE: usize

type Size = <<Const<N> as ToUInt>::Output as Mul<<T as Size>::Size>>::Output

impl<T: ?Sized + Size> Size for Box<T>

const SIZE: usize = T::SIZE

type Size = <T as Size>::Size

impl<T: ?Sized + Size> Size for Arc<T>

const SIZE: usize = T::SIZE

type Size = <T as Size>::Size

impl<T: ?Sized> Size for PhantomData<T>

const SIZE: usize = 0usize

type Size = UTerm

Implementors

impl<T> Size for Point<T>

const SIZE: usize = 32usize

type Size = <Const<HASH_SIZE> as ToUInt>::Output

impl<T, const MAX: usize, __Output: Unsigned> Size for EnumTag<T, MAX>

where T: Size, TArr<<T as Size>::Size, ATerm>: FoldAdd<Output = __Output>,

const SIZE: usize = <T as ::object_rainbow::Size>::SIZE

type Size = <TArr<<T as Size>::Size, ATerm> as FoldAdd>::Output

impl<T: Size> Size for Lp<T>

where U8: Add<T::Size, Output: Unsigned>,

type Size = <UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0> as Add<<T as Size>::Size>>::Output

impl<T: ToOutput> Size for Hashed<T>

const SIZE: usize = 32usize

type Size = <Point<T> as Size>::Size

impl<__Output: Unsigned> Size for Hash

where TArr<<[u8; 32] as Size>::Size, ATerm>: FoldAdd<Output = __Output>,

const SIZE: usize = 32usize

type Size = <TArr<<[u8; 32] as Size>::Size, ATerm> as FoldAdd>::Output

impl<__Output: Unsigned> Size for OptionalHash

where TArr<<[u8; 32] as Size>::Size, ATerm>: FoldAdd<Output = __Output>,

const SIZE: usize = 32usize

type Size = <TArr<<[u8; 32] as Size>::Size, ATerm> as FoldAdd>::Output