Struct TinyVec 

pub struct TinyVec<T> { /* private fields */ }

Ultra-compact vector using a thin pointer (8 bytes on stack).

Memory layout:

• Stack: single pointer (8 bytes) - null for empty
• Heap: [len: u8][items: T...] - only allocated when non-empty

Compared to standard types:

• Vec<T>: 24 bytes (ptr + len + cap)
• Box<[T]>: 16 bytes (fat pointer)
• TinyVec<T>: 8 bytes (thin pointer)

Limitations:

• Max 255 items (u8 length)
• Immutable after creation (no push/pop - recreate to modify)
• Perfect for attachments/reactions which rarely change

Implementations

impl<T> TinyVec<T>

pub const fn new() -> Self

Create an empty TinyVec (no allocation)

pub fn from_vec(vec: Vec<T>) -> Self

Create from a Vec, consuming it

pub fn len(&self) -> usize

Number of items

pub fn is_empty(&self) -> bool

pub fn as_slice(&self) -> &[T]

Get a slice of the items

pub fn as_mut_slice(&mut self) -> &mut [T]

Get a mutable slice of the items

pub fn iter(&self) -> Iter<'_, T>

Iterate over items

pub fn iter_mut(&mut self) -> IterMut<'_, T>

Iterate mutably

pub fn to_vec(&self) -> Vec<T>

where T: Clone,

Convert to Vec (clones items)

pub fn first(&self) -> Option<&T>

Get the first item (immutable)

pub fn last(&self) -> Option<&T>

Get the last item (immutable)

pub fn last_mut(&mut self) -> Option<&mut T>

Get the last item (mutable)

pub fn get(&self, index: usize) -> Option<&T>

Get item by index (immutable)

pub fn get_mut(&mut self, index: usize) -> Option<&mut T>

Get item by index (mutable)

pub fn push(&mut self, item: T)

where T: Clone,

Push an item (rebuilds the entire allocation - use sparingly!)

pub fn retain<F>(&mut self, f: F)

where T: Clone, F: FnMut(&T) -> bool,

Retain items matching a predicate (rebuilds the allocation)

pub fn any<F>(&self, f: F) -> bool

where F: FnMut(&T) -> bool,

Check if any item matches a predicate

Trait Implementations

impl<T: Clone> Clone for TinyVec<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for TinyVec<T>

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

Formats the value using the given formatter.

impl<T> Default for TinyVec<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> Drop for TinyVec<T>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<T> Index<usize> for TinyVec<T>

type Output = T

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T> IndexMut<usize> for TinyVec<T>

fn index_mut(&mut self, index: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<'a, T> IntoIterator for &'a TinyVec<T>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut TinyVec<T>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: Send> Send for TinyVec<T>

impl<T: Sync> Sync for TinyVec<T>