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 = 0

type Size = UTerm

impl Size for bool

type Size = UInt<UTerm, B1>

impl Size for i8

const SIZE: usize = 1

type Size = UInt<UTerm, B1>

impl Size for u8

const SIZE: usize = 1

type Size = UInt<UTerm, B1>

impl Size for ()

const SIZE: usize = 0

type Size = UTerm

impl Size for NonZero<i8>

const SIZE: usize = <i8 as Size>::SIZE

type Size = <i8 as Size>::Size

impl Size for NonZero<u8>

const SIZE: usize = <u8 as Size>::SIZE

type Size = <u8 as Size>::Size

impl<'a, B: 'a + ToOwned + Size + ?Sized> Size for Cow<'a, B>

const SIZE: usize = B::SIZE

type Size = <B as Size>::Size

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 = 0

type Size = UTerm

Implementors

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 = Hash::SIZE

type Size = <Hash as Size>::Size

impl<__Output: Unsigned> Size for Hash

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

const SIZE: usize = <[u8; HASH_SIZE] as ::object_rainbow::Size>::SIZE

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 = <[u8; HASH_SIZE] as ::object_rainbow::Size>::SIZE

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