Enum SmallCopyList 

pub enum SmallCopyList<T>
where
    T: Copy + Debug + Hash + Eq,
{
    Empty,
    One([T; 1]),
    Two([T; 2]),
    Three([T; 3]),
}

Variants

Empty

One([T; 1])

Two([T; 2])

Three([T; 3])

Trait Implementations

impl<T> AsRef<[T]> for SmallCopyList<T>

where T: Copy + Debug + Hash + Eq,

fn as_ref(&self) -> &[T]

Converts this type into a shared reference of the (usually inferred) input type.

impl<T> Clone for SmallCopyList<T>

where T: Clone + Copy + Debug + Hash + Eq,

fn clone(&self) -> SmallCopyList<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Debug for SmallCopyList<T>

where T: Debug + Copy + Hash + Eq,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<T> Hash for SmallCopyList<T>

where T: Hash + Copy + Debug + Eq,

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> PartialEq for SmallCopyList<T>

where T: PartialEq + Copy + Debug + Hash + Eq,

fn eq(&self, other: &SmallCopyList<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> StableHash for SmallCopyList<T>

where T: Copy + Debug + Hash + Eq, [T; 1]: StableHash, [T; 2]: StableHash, [T; 3]: StableHash,

fn stable_hash<__Hcx>( &self, __hcx: &mut __Hcx, __hasher: &mut StableHasher<SipHasher128>, )

where __Hcx: StableHashCtxt,

impl<T, I> TypeFoldable<I> for SmallCopyList<T>

where T: Copy + Debug + Hash + Eq, I: Interner, [T; 1]: TypeFoldable<I>, [T; 2]: TypeFoldable<I>, [T; 3]: TypeFoldable<I>,

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<SmallCopyList<T>, <__F as FallibleTypeFolder<I>>::Error>

where __F: FallibleTypeFolder<I>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<__F>(self, __folder: &mut __F) -> SmallCopyList<T>

where __F: TypeFolder<I>,

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<T, I> TypeVisitable<I> for SmallCopyList<T>

where T: Copy + Debug + Hash + Eq, I: Interner, [T; 1]: TypeVisitable<I>, [T; 2]: TypeVisitable<I>, [T; 3]: TypeVisitable<I>,

fn visit_with<__V>( &self, __visitor: &mut __V, ) -> <__V as TypeVisitor<I>>::Result

where __V: TypeVisitor<I>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<T> Copy for SmallCopyList<T>

where T: Copy + Debug + Hash + Eq,

impl<T> Eq for SmallCopyList<T>

where T: Eq + Copy + Debug + Hash,

impl<T> StructuralPartialEq for SmallCopyList<T>

where T: Copy + Debug + Hash + Eq,

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.