Trait MaybeHasNiche 

pub trait MaybeHasNiche {
    type MnArray;
}

This might contain a valid Niche.

If Self: Size, a niche must have the same size.

A niche must satisfy these requirements if it doesn’t need a tag:

• No valid values are a prefix of it, if Self is inline. Otherwise we might misinterpret a concatenation.
• It’s not a prefix of any values. Otherwise we wouldn’t be able to parse some valid values.

Required Associated Types

type MnArray

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

Dyn Compatibility

This trait is dyn compatible.

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

Implementations on Foreign Types

impl MaybeHasNiche for ()

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

impl MaybeHasNiche for Bytes

Available on crate feature bytes only.

type MnArray = NoNiche<NicheForUnsized>

impl MaybeHasNiche for BytesMut

Available on crate feature bytes only.

type MnArray = NoNiche<NicheForUnsized>

impl MaybeHasNiche for CString

type MnArray = NoNiche<NicheForUnsized>

impl MaybeHasNiche for Infallible

type MnArray = SomeNiche<ZeroNiche<UTerm>>

impl MaybeHasNiche for NonZero<u8>

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

impl MaybeHasNiche for NonZero<u16>

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

impl MaybeHasNiche for NonZero<u32>

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

impl MaybeHasNiche for NonZero<u64>

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

impl MaybeHasNiche for NonZero<u128>

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

impl MaybeHasNiche for String

type MnArray = NoNiche<NicheForUnsized>

impl MaybeHasNiche for Ulid

Available on crate feature ulid only.

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

impl MaybeHasNiche for bool

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

impl MaybeHasNiche for char

type MnArray = SomeNiche<CharNiche>

impl MaybeHasNiche for f32

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

impl MaybeHasNiche for f64

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

impl MaybeHasNiche for i8

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

impl MaybeHasNiche for i16

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

impl MaybeHasNiche for i32

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

impl MaybeHasNiche for i64

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

impl MaybeHasNiche for i128

type MnArray = NoNiche<ZeroNoNiche<<i128 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 u16

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

impl MaybeHasNiche for u32

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

impl MaybeHasNiche for u64

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

impl MaybeHasNiche for u128

type MnArray = NoNiche<ZeroNoNiche<<u128 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, 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<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> 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> 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> 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> 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> 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> 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> 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> 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> MaybeHasNiche for (A, B)

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

impl<T, N: ArrayLength + IsGreater<U0, Output = B>, B: MoreThan0<T, N>> MaybeHasNiche for GenericArray<T, N>

type MnArray = <B as MoreThan0<T, N>>::MnArray

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

where Const<N>: ToUInt<Output: ArrayLength>, GenericArray<T, <Const<N> as ToUInt>::Output>: MaybeHasNiche,

type MnArray = <GenericArray<T, <Const<N> as ToUInt>::Output> as MaybeHasNiche>::MnArray

impl<T: ?Sized + MaybeHasNiche> MaybeHasNiche for &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> MaybeHasNiche for Box<T>

type MnArray = <T as MaybeHasNiche>::MnArray

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

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

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: MaybeHasNiche> MaybeHasNiche for (T,)

type MnArray = <T as MaybeHasNiche>::MnArray

impl<T> MaybeHasNiche for Vec<T>

type MnArray = NoNiche<NicheForUnsized>

impl<T> MaybeHasNiche for VecDeque<T>

type MnArray = NoNiche<NicheForUnsized>

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

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

impl<const S: usize> MaybeHasNiche for CidGeneric<S>

Available on crate feature cid only.

varint inside.

type MnArray = NoNiche<NicheForUnsized>

Implementors

impl MaybeHasNiche for Address

type MnArray = <Hash as MaybeHasNiche>::MnArray

impl MaybeHasNiche for AddressedBytes

where Address: MaybeHasNiche<MnArray: MnArray<MaybeNiche: MaybeNiche>>, Arc<dyn Resolve>: MaybeHasNiche<MnArray: MnArray<MaybeNiche: MaybeNiche>>,

type MnArray = TArr<<<Address as MaybeHasNiche>::MnArray as MnArray>::MaybeNiche, TArr<<<Arc<dyn Resolve> as MaybeHasNiche>::MnArray as MnArray>::MaybeNiche, ATerm>>

impl MaybeHasNiche for Be<NonZero<i8>>

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

impl MaybeHasNiche for Be<NonZero<i16>>

type MnArray = SomeNiche<ZeroNiche<<Be<NonZero<i16>> as Size>::Size>>

impl MaybeHasNiche for Be<NonZero<i32>>

type MnArray = SomeNiche<ZeroNiche<<Be<NonZero<i32>> as Size>::Size>>

impl MaybeHasNiche for Be<NonZero<i64>>

type MnArray = SomeNiche<ZeroNiche<<Be<NonZero<i64>> as Size>::Size>>

impl MaybeHasNiche for Be<NonZero<i128>>

type MnArray = SomeNiche<ZeroNiche<<Be<NonZero<i128>> as Size>::Size>>

impl MaybeHasNiche for Be<NonZero<u8>>

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

impl MaybeHasNiche for Be<NonZero<u16>>

type MnArray = SomeNiche<ZeroNiche<<Be<NonZero<u16>> as Size>::Size>>

impl MaybeHasNiche for Be<NonZero<u32>>

type MnArray = SomeNiche<ZeroNiche<<Be<NonZero<u32>> as Size>::Size>>

impl MaybeHasNiche for Be<NonZero<u64>>

type MnArray = SomeNiche<ZeroNiche<<Be<NonZero<u64>> as Size>::Size>>

impl MaybeHasNiche for Be<NonZero<u128>>

type MnArray = SomeNiche<ZeroNiche<<Be<NonZero<u128>> as Size>::Size>>

impl MaybeHasNiche for Be<f32>

type MnArray = NoNiche<ZeroNoNiche<<Be<f32> as Size>::Size>>

impl MaybeHasNiche for Be<f64>

type MnArray = NoNiche<ZeroNoNiche<<Be<f64> as Size>::Size>>

impl MaybeHasNiche for Be<i8>

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

impl MaybeHasNiche for Be<i16>

type MnArray = NoNiche<ZeroNoNiche<<Be<i16> as Size>::Size>>

impl MaybeHasNiche for Be<i32>

type MnArray = NoNiche<ZeroNoNiche<<Be<i32> as Size>::Size>>

impl MaybeHasNiche for Be<i64>

type MnArray = NoNiche<ZeroNoNiche<<Be<i64> as Size>::Size>>

impl MaybeHasNiche for Be<i128>

type MnArray = NoNiche<ZeroNoNiche<<Be<i128> as Size>::Size>>

impl MaybeHasNiche for Be<u8>

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

impl MaybeHasNiche for Be<u16>

type MnArray = NoNiche<ZeroNoNiche<<Be<u16> as Size>::Size>>

impl MaybeHasNiche for Be<u32>

type MnArray = NoNiche<ZeroNoNiche<<Be<u32> as Size>::Size>>

impl MaybeHasNiche for Be<u64>

type MnArray = NoNiche<ZeroNoNiche<<Be<u64> as Size>::Size>>

impl MaybeHasNiche for Be<u128>

type MnArray = NoNiche<ZeroNoNiche<<Be<u128> as Size>::Size>>

impl MaybeHasNiche for Ff

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

impl MaybeHasNiche for Hash

type MnArray = SomeNiche<HashNiche<UTerm>>

impl MaybeHasNiche for Le<NonZero<i8>>

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

impl MaybeHasNiche for Le<NonZero<i16>>

type MnArray = SomeNiche<ZeroNiche<<Le<NonZero<i16>> as Size>::Size>>

impl MaybeHasNiche for Le<NonZero<i32>>

type MnArray = SomeNiche<ZeroNiche<<Le<NonZero<i32>> as Size>::Size>>

impl MaybeHasNiche for Le<NonZero<i64>>

type MnArray = SomeNiche<ZeroNiche<<Le<NonZero<i64>> as Size>::Size>>

impl MaybeHasNiche for Le<NonZero<i128>>

type MnArray = SomeNiche<ZeroNiche<<Le<NonZero<i128>> as Size>::Size>>

impl MaybeHasNiche for Le<NonZero<u8>>

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

impl MaybeHasNiche for Le<NonZero<u16>>

type MnArray = SomeNiche<ZeroNiche<<Le<NonZero<u16>> as Size>::Size>>

impl MaybeHasNiche for Le<NonZero<u32>>

type MnArray = SomeNiche<ZeroNiche<<Le<NonZero<u32>> as Size>::Size>>

impl MaybeHasNiche for Le<NonZero<u64>>

type MnArray = SomeNiche<ZeroNiche<<Le<NonZero<u64>> as Size>::Size>>

impl MaybeHasNiche for Le<NonZero<u128>>

type MnArray = SomeNiche<ZeroNiche<<Le<NonZero<u128>> as Size>::Size>>

impl MaybeHasNiche for Le<f32>

type MnArray = NoNiche<ZeroNoNiche<<Le<f32> as Size>::Size>>

impl MaybeHasNiche for Le<f64>

type MnArray = NoNiche<ZeroNoNiche<<Le<f64> as Size>::Size>>

impl MaybeHasNiche for Le<i8>

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

impl MaybeHasNiche for Le<i16>

type MnArray = NoNiche<ZeroNoNiche<<Le<i16> as Size>::Size>>

impl MaybeHasNiche for Le<i32>

type MnArray = NoNiche<ZeroNoNiche<<Le<i32> as Size>::Size>>

impl MaybeHasNiche for Le<i64>

type MnArray = NoNiche<ZeroNoNiche<<Le<i64> as Size>::Size>>

impl MaybeHasNiche for Le<i128>

type MnArray = NoNiche<ZeroNoNiche<<Le<i128> as Size>::Size>>

impl MaybeHasNiche for Le<u8>

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

impl MaybeHasNiche for Le<u16>

type MnArray = NoNiche<ZeroNoNiche<<Le<u16> as Size>::Size>>

impl MaybeHasNiche for Le<u32>

type MnArray = NoNiche<ZeroNoNiche<<Le<u32> as Size>::Size>>

impl MaybeHasNiche for Le<u64>

type MnArray = NoNiche<ZeroNoNiche<<Le<u64> as Size>::Size>>

impl MaybeHasNiche for Le<u128>

type MnArray = NoNiche<ZeroNoNiche<<Le<u128> as Size>::Size>>

impl MaybeHasNiche for NicheCut

type MnArray = NoNiche<NicheForUnsized>

impl MaybeHasNiche for OptionalHash

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

impl MaybeHasNiche for dyn Resolve + '_

type MnArray = NoNiche<ZeroNoNiche<<dyn Resolve + '_ as Size>::Size>>

impl<Extra> MaybeHasNiche for Extras<Extra>

type MnArray = NoNiche<ZeroNoNiche<<Extras<Extra> as Size>::Size>>

impl<Extra> MaybeHasNiche for InlineExtra<Extra>

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

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

impl<K> MaybeHasNiche for PartialByteTag<K>

type MnArray = SomeNiche<IncrByteNiche<K>>

impl<M> MaybeHasNiche for SmExtra<M>

type MnArray = NoNiche<ZeroNoNiche<<SmExtra<M> as Size>::Size>>

impl<T, Extra> MaybeHasNiche for Addressed<T, Extra>

where Extras<Extra>: MaybeHasNiche<MnArray: MnArray<MaybeNiche: MaybeNiche>>, AddressedBytes: MaybeHasNiche<MnArray: MnArray<MaybeNiche: MaybeNiche>>, ObjectMarker<T>: MaybeHasNiche<MnArray: MnArray<MaybeNiche: MaybeNiche>>,

type MnArray = TArr<<<Extras<Extra> as MaybeHasNiche>::MnArray as MnArray>::MaybeNiche, TArr<<<AddressedBytes as MaybeHasNiche>::MnArray as MnArray>::MaybeNiche, TArr<<<ObjectMarker<T> as MaybeHasNiche>::MnArray as MnArray>::MaybeNiche, ATerm>>>

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: ?Sized> MaybeHasNiche for ObjectMarker<T>

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

impl<T: MaybeHasNiche<MnArray = NoNiche<NicheForUnsized>>> MaybeHasNiche for Zt<T>

type MnArray = NoNiche<NicheForUnsized>

impl<T: MaybeHasNiche> MaybeHasNiche for WithRepr<T>

type MnArray = WithRepr<T>

impl<T> MaybeHasNiche for Local<T>

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

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