Enum SmallCopyList 

pub enum SmallCopyList<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])

Implementations

impl<T: Copy + Debug + Hash + Eq> SmallCopyList<T>

fn empty() -> Self

fn new(first: T) -> Self

fn union(self, other: Self) -> Option<Self>

Computes the union of two lists. Duplicates are removed.

Trait Implementations

impl<T: Copy + Debug + Hash + Eq> AsRef<[T]> for SmallCopyList<T>

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

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

impl<T: Clone + Copy + Debug + Hash + Eq> Clone for SmallCopyList<T>

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 + Copy + Debug + Hash + Eq> Debug for SmallCopyList<T>

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

Formats the value using the given formatter.

impl<T: Hash + Copy + Debug + Hash + Eq> Hash for SmallCopyList<T>

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

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 + Copy + Debug + Hash + Eq> PartialEq for SmallCopyList<T>

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: Copy + Debug + Hash + Eq> StableHash for SmallCopyList<T>

where [T; 1]: StableHash, [T; 2]: StableHash, [T; 3]: StableHash,

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

impl<T: Copy + Debug + Hash + Eq, I> TypeFoldable<I> for SmallCopyList<T>

where I: Interner, [T; 1]: TypeFoldable<I>, [T; 2]: TypeFoldable<I>, [T; 3]: TypeFoldable<I>,

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

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

fn fold_with<__F: TypeFolder<I>>(self, __folder: &mut __F) -> Self

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

impl<T: Copy + Debug + Hash + Eq, I> TypeVisitable<I> for SmallCopyList<T>

where I: Interner, [T; 1]: TypeVisitable<I>, [T; 2]: TypeVisitable<I>, [T; 3]: TypeVisitable<I>,

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

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

impl<T: Copy + Copy + Debug + Hash + Eq> Copy for SmallCopyList<T>

impl<T: Eq + Copy + Debug + Hash + Eq> Eq for SmallCopyList<T>

impl<T: Copy + Debug + Hash + Eq> StructuralPartialEq for SmallCopyList<T>

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.