Trait MaybeHasNiche 

pub trait MaybeHasNiche {
    type MnArray;
}

This might contain a valid Niche.

Required Associated Types

type MnArray

Should implement [MnArray]. Not constraint explicitly, because that breaks things.

Implementations on Foreign Types

impl MaybeHasNiche for Infallible

type MnArray = SomeNiche<ZeroNiche<UTerm>>

impl MaybeHasNiche for bool

type MnArray = SomeNiche<IncrByteNiche<UInt<UInt<UTerm, B1>, B0>>>

impl MaybeHasNiche for i8

type MnArray = NoNiche<ZeroNoNiche<<i8 as Size>::Size>>

impl MaybeHasNiche for str

type MnArray = NoNiche<NicheForUnsized>

impl MaybeHasNiche for u8

type MnArray = NoNiche<ZeroNoNiche<<u8 as Size>::Size>>

impl MaybeHasNiche for ()

type MnArray = NoNiche<ZeroNoNiche<<() as Size>::Size>>

impl MaybeHasNiche for CString

type MnArray = NoNiche<NicheForUnsized>

impl MaybeHasNiche for String

type MnArray = NoNiche<NicheForUnsized>

impl MaybeHasNiche for NonZero<i8>

type MnArray = SomeNiche<ZeroNiche<<NonZero<i8> as Size>::Size>>

impl MaybeHasNiche for NonZero<u8>

type MnArray = SomeNiche<ZeroNiche<<NonZero<u8> as Size>::Size>>

impl MaybeHasNiche for Ulid

Available on crate feature ulid only.

type MnArray = NoNiche<ZeroNoNiche<<Ulid as Size>::Size>>

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

type MnArray = <B as MaybeHasNiche>::MnArray

impl<A, O: BitOrder> MaybeHasNiche for BitArray<A, O>

where PhantomData<O>: MaybeHasNiche<MnArray: MnArray<MaybeNiche: MaybeNiche>>, A: MaybeHasNiche<MnArray: MnArray<MaybeNiche: MaybeNiche>> + BitViewSized,

Available on crate feature bitvec only.

type MnArray = TArr<<<PhantomData<O> as MaybeHasNiche>::MnArray as MnArray>::MaybeNiche, TArr<<<A as MaybeHasNiche>::MnArray as MnArray>::MaybeNiche, ATerm>>

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

type MnArray = TArr<<A as MaybeHasNiche>::MnArray, TArr<<B as MaybeHasNiche>::MnArray, ATerm>>

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

type MnArray = TArr<<A as MaybeHasNiche>::MnArray, TArr<<B as MaybeHasNiche>::MnArray, TArr<<C as MaybeHasNiche>::MnArray, ATerm>>>

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

type MnArray = TArr<<A as MaybeHasNiche>::MnArray, TArr<<B as MaybeHasNiche>::MnArray, TArr<<C as MaybeHasNiche>::MnArray, TArr<<D as MaybeHasNiche>::MnArray, ATerm>>>>

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

type MnArray = TArr<<A as MaybeHasNiche>::MnArray, TArr<<B as MaybeHasNiche>::MnArray, TArr<<C as MaybeHasNiche>::MnArray, TArr<<D as MaybeHasNiche>::MnArray, TArr<<E as MaybeHasNiche>::MnArray, ATerm>>>>>

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

type MnArray = TArr<<A as MaybeHasNiche>::MnArray, TArr<<B as MaybeHasNiche>::MnArray, TArr<<C as MaybeHasNiche>::MnArray, TArr<<D as MaybeHasNiche>::MnArray, TArr<<E as MaybeHasNiche>::MnArray, TArr<<F as MaybeHasNiche>::MnArray, ATerm>>>>>>

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

type MnArray = TArr<<A as MaybeHasNiche>::MnArray, TArr<<B as MaybeHasNiche>::MnArray, TArr<<C as MaybeHasNiche>::MnArray, TArr<<D as MaybeHasNiche>::MnArray, TArr<<E as MaybeHasNiche>::MnArray, TArr<<F as MaybeHasNiche>::MnArray, TArr<<G as MaybeHasNiche>::MnArray, ATerm>>>>>>>

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

type MnArray = TArr<<A as MaybeHasNiche>::MnArray, TArr<<B as MaybeHasNiche>::MnArray, TArr<<C as MaybeHasNiche>::MnArray, TArr<<D as MaybeHasNiche>::MnArray, TArr<<E as MaybeHasNiche>::MnArray, TArr<<F as MaybeHasNiche>::MnArray, TArr<<G as MaybeHasNiche>::MnArray, TArr<<H as MaybeHasNiche>::MnArray, ATerm>>>>>>>>

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

type MnArray = TArr<<A as MaybeHasNiche>::MnArray, TArr<<B as MaybeHasNiche>::MnArray, TArr<<C as MaybeHasNiche>::MnArray, TArr<<D as MaybeHasNiche>::MnArray, TArr<<E as MaybeHasNiche>::MnArray, TArr<<F as MaybeHasNiche>::MnArray, TArr<<G as MaybeHasNiche>::MnArray, TArr<<H as MaybeHasNiche>::MnArray, TArr<<I as MaybeHasNiche>::MnArray, ATerm>>>>>>>>>

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

type MnArray = TArr<<A as MaybeHasNiche>::MnArray, TArr<<B as MaybeHasNiche>::MnArray, TArr<<C as MaybeHasNiche>::MnArray, TArr<<D as MaybeHasNiche>::MnArray, TArr<<E as MaybeHasNiche>::MnArray, TArr<<F as MaybeHasNiche>::MnArray, TArr<<G as MaybeHasNiche>::MnArray, TArr<<H as MaybeHasNiche>::MnArray, TArr<<I as MaybeHasNiche>::MnArray, TArr<<J as MaybeHasNiche>::MnArray, ATerm>>>>>>>>>>

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

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

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

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

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

type MnArray = NoNiche<ZeroNoNiche<<dyn ExtraFor<T> + Send + Sync as Size>::Size>>

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

type MnArray = <T as MaybeHasNiche>::MnArray

impl<T: MaybeHasNiche<MnArray: MnArray<MaybeNiche = Mn>>, Mn: Niche<NeedsTag = B, N: Add<B, Output: ArrayLength>>, B: OptionNicheWrapper> MaybeHasNiche for Option<T>

type MnArray = <B as OptionNicheWrapper>::Wrap<Mn>

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

type MnArray = <T as MaybeHasNiche>::MnArray

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

type MnArray = <T as MaybeHasNiche>::MnArray

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

type MnArray = NoNiche<ZeroNoNiche<<PhantomData<T> as Size>::Size>>

impl<const N: usize> MaybeHasNiche for [u8; N]

where Const<N>: ToUInt<Output: ArrayLength>,

type MnArray = NoNiche<ZeroNoNiche<<Const<N> as ToUInt>::Output>>

Implementors

impl MaybeHasNiche for Hash

type MnArray = SomeNiche<HashNiche<UTerm>>

impl MaybeHasNiche for OptionalHash

type MnArray = SomeNiche<HashNiche<UInt<UTerm, B1>>>

impl<K> MaybeHasNiche for PartialByteTag<K>

type MnArray = SomeNiche<IncrByteNiche<K>>

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

where M: MaybeHasNiche<MnArray: MnArray<MaybeNiche: MaybeNiche>>, T: MaybeHasNiche<MnArray: MnArray<MaybeNiche: MaybeNiche>>,

type MnArray = TArr<<<M as MaybeHasNiche>::MnArray as MnArray>::MaybeNiche, TArr<<<T as MaybeHasNiche>::MnArray as MnArray>::MaybeNiche, ATerm>>

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

where T: MaybeHasNiche<MnArray: MnArray<MaybeNiche: MaybeNiche>>,

type MnArray = TArr<<<T as MaybeHasNiche>::MnArray as MnArray>::MaybeNiche, ATerm>

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

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

type MnArray = TArr<SomeNiche<OneNiche<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>>, TArr<NoNiche<ZeroNoNiche<<T as Size>::Size>>, ATerm>>