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".

Implementations on Foreign Types

impl Size for ()

const SIZE: usize = 0

type Size = UTerm

impl Size for Infallible

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<i16>

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

type Size = <i16 as Size>::Size

impl Size for NonZero<i32>

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

type Size = <i32 as Size>::Size

impl Size for NonZero<i64>

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

type Size = <i64 as Size>::Size

impl Size for NonZero<i128>

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

type Size = <i128 as Size>::Size

impl Size for NonZero<u8>

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

type Size = <u8 as Size>::Size

impl Size for NonZero<u16>

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

type Size = <u16 as Size>::Size

impl Size for NonZero<u32>

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

type Size = <u32 as Size>::Size

impl Size for NonZero<u64>

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

type Size = <u64 as Size>::Size

impl Size for NonZero<u128>

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

type Size = <u128 as Size>::Size

impl Size for Ordering

const SIZE: usize = 1

type Size = UInt<UTerm, B1>

impl Size for Ulid

Available on crate feature ulid only.

const SIZE: usize = 16

type Size = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>

impl Size for bool

type Size = UInt<UTerm, B1>

impl Size for f32

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for f64

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for i8

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for i16

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for i32

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for i64

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for i128

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for u8

const SIZE: usize = 1

type Size = UInt<UTerm, B1>

impl Size for u16

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for u32

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for u64

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for u128

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

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, O: BitOrder> Size for BitArray<A, O>

where PhantomData<O>: Size, A: Size + BitViewSized, TArr<U0, TArr<<PhantomData<O> as Size>::Size, TArr<<A as Size>::Size, ATerm>>>: FoldAdd<Output: Unsigned>,

Available on crate feature bitvec only.

const SIZE: usize

type Size = <TArr<UTerm, TArr<<PhantomData<O> as Size>::Size, TArr<<A 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<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> 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> 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> 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> 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> 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> 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> 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> 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> 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<T: ?Sized + Size> Size for &T

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

impl<T: Size, N> Size for GenericArray<T, N>

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

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

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: Size<Size = N> + MaybeHasNiche<MnArray: MnArray<MaybeNiche: Niche<NeedsTag = B, N = N>>>, N: Unsigned, B: OptionSize<N>> Size for Option<T>

type Size = <B as OptionSize<N>>::Size

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

const SIZE: usize = T::SIZE

type Size = <T as Size>::Size

impl<T> Size for dyn Send + Sync + ExtraFor<T>

const SIZE: usize = 0

type Size = UTerm

Implementors

impl Size for Be<NonZero<i8>>

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

type Size = <Be<i8> as Size>::Size

impl Size for Be<NonZero<i16>>

const SIZE: usize = <Be<i16> as Size>::SIZE

type Size = <Be<i16> as Size>::Size

impl Size for Be<NonZero<i32>>

const SIZE: usize = <Be<i32> as Size>::SIZE

type Size = <Be<i32> as Size>::Size

impl Size for Be<NonZero<i64>>

const SIZE: usize = <Be<i64> as Size>::SIZE

type Size = <Be<i64> as Size>::Size

impl Size for Be<NonZero<i128>>

const SIZE: usize = <Be<i128> as Size>::SIZE

type Size = <Be<i128> as Size>::Size

impl Size for Be<NonZero<u8>>

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

type Size = <Be<u8> as Size>::Size

impl Size for Be<NonZero<u16>>

const SIZE: usize = <Be<u16> as Size>::SIZE

type Size = <Be<u16> as Size>::Size

impl Size for Be<NonZero<u32>>

const SIZE: usize = <Be<u32> as Size>::SIZE

type Size = <Be<u32> as Size>::Size

impl Size for Be<NonZero<u64>>

const SIZE: usize = <Be<u64> as Size>::SIZE

type Size = <Be<u64> as Size>::Size

impl Size for Be<NonZero<u128>>

const SIZE: usize = <Be<u128> as Size>::SIZE

type Size = <Be<u128> as Size>::Size

impl Size for Be<f32>

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for Be<f64>

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for Be<i8>

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for Be<i16>

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for Be<i32>

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for Be<i64>

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for Be<i128>

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for Be<u8>

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for Be<u16>

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for Be<u32>

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for Be<u64>

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for Be<u128>

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for Ff

type Size = UInt<UTerm, B1>

impl Size for Hash

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

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

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

impl Size for Le<NonZero<i8>>

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

type Size = <Le<i8> as Size>::Size

impl Size for Le<NonZero<i16>>

const SIZE: usize = <Le<i16> as Size>::SIZE

type Size = <Le<i16> as Size>::Size

impl Size for Le<NonZero<i32>>

const SIZE: usize = <Le<i32> as Size>::SIZE

type Size = <Le<i32> as Size>::Size

impl Size for Le<NonZero<i64>>

const SIZE: usize = <Le<i64> as Size>::SIZE

type Size = <Le<i64> as Size>::Size

impl Size for Le<NonZero<i128>>

const SIZE: usize = <Le<i128> as Size>::SIZE

type Size = <Le<i128> as Size>::Size

impl Size for Le<NonZero<u8>>

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

type Size = <Le<u8> as Size>::Size

impl Size for Le<NonZero<u16>>

const SIZE: usize = <Le<u16> as Size>::SIZE

type Size = <Le<u16> as Size>::Size

impl Size for Le<NonZero<u32>>

const SIZE: usize = <Le<u32> as Size>::SIZE

type Size = <Le<u32> as Size>::Size

impl Size for Le<NonZero<u64>>

const SIZE: usize = <Le<u64> as Size>::SIZE

type Size = <Le<u64> as Size>::Size

impl Size for Le<NonZero<u128>>

const SIZE: usize = <Le<u128> as Size>::SIZE

type Size = <Le<u128> as Size>::Size

impl Size for Le<f32>

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for Le<f64>

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for Le<i8>

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for Le<i16>

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for Le<i32>

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for Le<i64>

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for Le<i128>

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for Le<u8>

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for Le<u16>

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for Le<u32>

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for Le<u64>

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for Le<u128>

const SIZE: usize

type Size = <Const<{ Self::SIZE }> as ToUInt>::Output

impl Size for NicheCut

where TArr<U0, ATerm>: FoldAdd<Output: Unsigned>,

const SIZE: usize = 0

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

impl Size for OptionalHash

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

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

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

impl<A, B> Size for TupleOfArrays<A, B>

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

const SIZE: usize

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

impl<K> Size for PartialByteTag<K>

const SIZE: usize = 1

type Size = UInt<UTerm, B1>

impl<M> Size for SmExtra<M>

const SIZE: usize = 0

type Size = UTerm

impl<T, M> Size for MappedExtra<T, M>

where M: Size, T: Size, TArr<U0, TArr<<M as Size>::Size, TArr<<T as Size>::Size, ATerm>>>: FoldAdd<Output: Unsigned>,

const SIZE: usize

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

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

where T: Size, TArr<U0, TArr<<T as Size>::Size, ATerm>>: FoldAdd<Output: Unsigned>,

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

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

impl<T: Size> Size for WithRepr<T>

const SIZE: usize = T::SIZE

type Size = <T as Size>::Size

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

const SIZE: usize = Hash::SIZE

type Size = <Hash as Size>::Size