Struct vec_option::VecOption

pub struct VecOption<T> { /* fields omitted */ }

A space optimized version of Vec<Option<T>> that stores the discriminant seperately

Pros

• Can have a smaller memory footprint compared to Vec<Option<T>> if Option<T>'s space optimizations don't take effect
• Quickly set the entire collection to contain None
• Fast extend with None

Cons

• 2 allocations, instead of a single allocation
• Cannot remove elements from the middle of the vector
• Cannot work on the option's directly

Methods

impl<T> VecOption<T>

pub fn new() -> Self

Creates an empty vector, does not allocate

pub fn with_capacity(cap: usize) -> Self

Creates an empty vector

allocates at least cap elements of space

pub fn reserve(&mut self, amount: usize)

reserves at least amount elements

if there is already enough space, this does nothing

pub fn reserve_exact(&mut self, amount: usize)

reserves exactly amount elements

if there is already enough space, this does nothing

pub fn len(&self) -> usize

The length of this vector

pub fn is_empty(&self) -> bool

Is this vector empty

pub fn push<V: Into<Option<T>>>(&mut self, value: V)

Put a value at the end of the vector

Reallocates if there is not enough space

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

Remove the last element of the vector

returns None if the vector is empty

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

Returns a mutable reference to the element at index or None if out of bounds.

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

Returns a reference to the element at index or None if out of bounds.

pub fn with_mut<F: FnOnce(&mut Option<T>) -> R, R>(
    &mut self,
    index: usize,
    f: F
) -> Option<R>

Yields a mutable reference to the Option to the closure, and updates the value in the vector once the closure completes, if the closure panics, the element will be in the None state

pub fn swap(&mut self, a: usize, b: usize)

Swaps two elements of the vector, panics if either index is out of bounds

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

Returns the element at index or None if out of bounds.

Replaces the element at index with None.

pub fn replace<O: Into<Option<T>>>(
    &mut self,
    index: usize,
    value: O
) -> Option<Option<T>>

Replace the element at index with value

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

Reduces the length of the vector to len and drops all excess elements

If len is greater than the length of the vector, nothing happens

pub fn clear(&mut self)

Clears the vector

pub fn set_all_none(&mut self)

Sets all of the elements in the vector to None and drops all values in the closure

pub fn extend_none(&mut self, additional: usize)

Extends the vector with additional number of Nones

Important traits for Iter<'a, T>

impl<'a, T> Iterator for Iter<'a, T> type Item = Option<&'a T>;

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

returns an iterator over references to the elements in the vector

Important traits for IterMut<'a, T>

impl<'a, T> Iterator for IterMut<'a, T> type Item = Option<&'a mut T>;

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

returns an iterator over mutable references to the elements in the vector

pub fn try_fold<A, B, F: FnMut(A, usize, &mut Option<T>) -> Result<A, B>>(
    &mut self,
    init: A,
    f: F
) -> Result<A, B>

Iterates over all of the Option<T>s in the vector and applies the closure to each one of them until the closure returns Err(..), then iteration ends

The closure is passed the init, index, and a mutable reference to the corrosponding element of the vector

This is similar to Iterator::try_fold

pub fn fold<A, F: FnMut(A, usize, &mut Option<T>) -> A>(
    &mut self,
    init: A,
    f: F
) -> A

Iterates over all of the Option<T>s in the vector and applies the closure to each one

The closure is passed the init, index, and a mutable reference to the corrosponding element of the vector

This is similar to Iterator::fold

pub fn try_for_each<B, F: FnMut(usize, &mut Option<T>) -> Result<(), B>>(
    &mut self,
    f: F
) -> Result<(), B>

Iterates over all of the Option<T>s in the vector and applies the closure to each one of them until the closure returns Err(..), then iteration ends

The closure is passed the index, and a mutable reference to the corrosponding element of the vector

This is similar to Iterator::try_for_each

pub fn for_each<F: FnMut(usize, &mut Option<T>)>(&mut self, f: F)

Iterates over all of the Option<T>s in the vector and applies the closure to each one

The closure is passed the index, and a mutable reference to the corrosponding element of the vector

This is similar to Iterator::for_each

Trait Implementations

impl<T: Clone> Clone for VecOption<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Ord> Ord for VecOption<T>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

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

Restrict a value to a certain interval.

impl<T> Default for VecOption<T>

fn default() -> Self

Returns the "default value" for a type.

impl<T> IntoIterator for VecOption<T>

type Item = Option<T>

The type of the elements being iterated over.

type IntoIter = IntoIter<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 VecOption<T>

type Item = Option<&'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<'a, T> IntoIterator for &'a VecOption<T>

type Item = Option<&'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<T> From<Vec<T>> for VecOption<T>

fn from(vec: Vec<T>) -> Self

Performs the conversion.

impl<T> From<Vec<Option<T>>> for VecOption<T>

fn from(vec: Vec<Option<T>>) -> Self

Performs the conversion.

impl<T> Extend<Option<T>> for VecOption<T>

fn extend<I: IntoIterator<Item = Option<T>>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

impl<T> Extend<T> for VecOption<T>

fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

impl<T: PartialOrd> PartialOrd<VecOption<T>> for VecOption<T>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use] fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use] fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use] fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use] fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: PartialEq> PartialEq<VecOption<T>> for VecOption<T>

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T: PartialEq> PartialEq<[T]> for VecOption<T>

fn eq(&self, other: &[T]) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T: PartialEq, S: AsRef<[Option<T>]>> PartialEq<S> for VecOption<T>

fn eq(&self, other: &S) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T> Drop for VecOption<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: Eq> Eq for VecOption<T>

impl<T: Debug> Debug for VecOption<T>

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

Formats the value using the given formatter.

impl<T: Hash> Hash for VecOption<T>

fn hash<H: Hasher>(&self, hasher: &mut H)

Feeds this value into the given [Hasher].

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

Feeds a slice of this type into the given [Hasher].

impl<T> FromIterator<Option<T>> for VecOption<T>

fn from_iter<I: IntoIterator<Item = Option<T>>>(iter: I) -> Self

Creates a value from an iterator.