Struct NonEmptySmallVec

Source

pub struct NonEmptySmallVec<const N: usize, T> {
    pub head: T,
    pub tail: SmallVec<[T; N]>,
}

Expand description

A Non-empty stack vector which can grow to the heap.

See crate::collections::NonEmptyVec for more inforamtion, as it’s identical to it except that we make use of a SmallVec instead of a Vec for tail storage.

Note that the total storage is N+1, as N is the size of the tail, but there’s also the head.

Fields§

§head: T§tail: SmallVec<[T; N]>

Implementations§

Source §

impl<const N: usize, T> NonEmptySmallVec<N, T>

Source

pub fn new(e: T) -> Self

Alias for NonEmptySmallVec::singleton.

Source

pub fn to_ref(&self) -> NonEmptySmallVec<N, &T>

Converts from &NonEmptySmallVec<N, T> to NonEmptySmallVec<N, &T>, allocating a new tail of borrows. Named to_ (not as_) because it is not a free view.

Source

pub fn collect(iter: I) -> Option<Self>
where I: IntoIterator<Item = T>,

Attempt to convert an iterator into a NonEmptySmallVec vector. Returns None if the iterator was empty.

Source

pub fn singleton(head: T) -> Self

Create a new non-empty list with an initial element.

Source

pub const fn is_empty(&self) -> bool

Always returns false.

Source

pub const fn first(&self) -> &T

Get the first element. Never fails.

Source

pub fn first_mut(&mut self) -> &mut T

Get the mutable reference to the first element. Never fails.

Source

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

Get the possibly-empty tail of the list.

Source

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

Push an element to the end of the list.

Source

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

Pop an element from the end of the list.

Source

pub fn insert(&mut self, index: usize, element: T)

Inserts an element at position index within the vector, shifting all elements after it to the right.

§Panics

Panics if index > len.

Source

pub fn len(&self) -> usize

Get the length of the list.

Source

pub fn len_nonzero(&self) -> NonZeroUsize

Gets the length of the list as a NonZeroUsize.

Source

pub fn capacity(&self) -> NonZeroUsize

Get the capacity of the list.

Source

pub fn last(&self) -> &T

Get the last element. Never fails.

Source

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

Get the last element mutably.

Source

pub fn contains(&self, x: &T) -> bool
where T: PartialEq,

Check whether an element is contained in the list.

Source

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

Get an element by index.

Source

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

Get an element by index, mutably.

Source

pub fn truncate(&mut self, len: NonZeroUsize)

Truncate the list to a certain size. Must be greater than 0.

Source

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

Source

pub fn iter_mut(&mut self) -> impl DoubleEndedIterator<Item = &mut T> + '_

Source

pub fn from_slice(slice: &[T]) -> Option<Self>
where T: Clone,

Often we have a Vec (or slice &[T]) but want to ensure that it is NonEmptySmallVec before proceeding with a computation. Using from_slice will give us a proof that we have a NonEmptySmallVec in the Some branch, otherwise it allows the caller to handle the None case.

Source

pub fn from_smallvec(vec: SmallVec<[T; N]>) -> Option<Self>

Often we have a Vec (or slice &[T]) but want to ensure that it is NonEmptySmallVec before proceeding with a computation. Using from_smallvec will give us a proof that we have a NonEmptySmallVec in the Some branch, otherwise it allows the caller to handle the None case.

This version will consume the Vec you pass in. If you would rather pass the data as a slice then use NonEmptySmallVec::from_slice.

Source

pub fn split_first(&self) -> (&T, &[T])

Deconstruct a NonEmptySmallVec into its head and tail. This operation never fails since we are guaranteed to have a head element.

Source

pub fn split(&self) -> (&T, &[T], Option<&T>)

Deconstruct a NonEmptySmallVec into its first, last, and middle elements, in that order.

If there is only one element then last is None.

Source

pub fn append(&mut self, other: &mut SmallVec<[T; N]>)

Append a Vec to the tail of the NonEmptySmallVec.

Source

pub fn map<U, F>(self, f: F) -> NonEmptySmallVec<N, U>
where F: FnMut(T) -> U,

A structure preserving map. This is useful for when we wish to keep the NonEmptySmallVec structure guaranteeing that there is at least one element. Otherwise, we can use non_empty_smallvec.iter().map(f).

Source

pub fn try_map<E, U, F>(self, f: F) -> Result<NonEmptySmallVec<N, U>, E>
where F: FnMut(T) -> Result<U, E>,

A structure preserving, fallible mapping function.

Source

pub fn flat_map<U, F>(self, f: F) -> NonEmptySmallVec<N, U>
where F: FnMut(T) -> NonEmptySmallVec<N, U>,

When we have a function that goes from some T to a NonEmptySmallVec, we may want to apply it to a NonEmptySmallVec<T> but keep the structure flat. This is where flat_map shines.

Source

pub fn flatten(full: NonEmptySmallVec<N, Self>) -> Self

Flatten nested NonEmptySmallVecs into a single one.

Source

pub fn binary_search(&self, x: &T) -> Result<usize, usize>
where T: Ord,

Binary searches this sorted non-empty vector for a given element.

If the value is found then Result::Ok is returned, containing the index of the matching element. If there are multiple matches, then any one of the matches could be returned.

If the value is not found then Result::Err is returned, containing the index where a matching element could be inserted while maintaining sorted order.

Source

pub fn binary_search_by<'a, F>(&'a self, f: F) -> Result<usize, usize>
where F: FnMut(&'a T) -> Ordering,

Binary searches this sorted non-empty with a comparator function.

The comparator function should implement an order consistent with the sort order of the underlying slice, returning an order code that indicates whether its argument is Less, Equal or Greater the desired target.

If the value is found then Result::Ok is returned, containing the index of the matching element. If there are multiple matches, then any one of the matches could be returned. If the value is not found then Result::Err is returned, containing the index where a matching element could be inserted while maintaining sorted order.

Source

pub fn binary_search_by_key<'a, B, F>( &'a self, b: &B, f: F, ) -> Result<usize, usize>
where B: Ord, F: FnMut(&'a T) -> B,

Binary searches this sorted non-empty vector with a key extraction function.

Assumes that the vector is sorted by the key.

If the value is found then Result::Ok is returned, containing the index of the matching element. If there are multiple matches, then any one of the matches could be returned. If the value is not found then Result::Err is returned, containing the index where a matching element could be inserted while maintaining sorted order.

Source