Struct Vector 

pub struct Vector<T, const N: usize>
where
    Const<N>: ValidBranchingConstant,
{ /* private fields */ }

A persistent vector.

Implementations

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

where Const<N>: ValidBranchingConstant,

pub fn new() -> Self

Create a new, empty, vector.

pub fn len(&self) -> usize

The number of elements in this vector.

pub fn is_empty(&self) -> bool

Returns true if the length is zero.

impl<T: Clone, const N: usize> Vector<T, N>

where Const<N>: ValidBranchingConstant,

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

Gets an element at a given index, or None if idx is out-of-bounds.

pub fn set(&mut self, idx: usize, elt: T)

Sets an element at a given index.

Panics if the index is out of bounds.

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

Adds an element to the end of this array.

Runs in time complexity O(log n) where n is the array length.

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

Removes and returns the element at the end of this array, or None if we’re empty.

Runs in time complexity O(log self.len()).

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

If len is less than our length, shortens this vector to length len.

If len is greater than or equal to our length, does nothing.

The running time is O(log self.len() + (len - self.len())). That is, it is linear in the number of elements to be discarded. Even if the elements to be discarded have trivial destructors, we still need to destroy (and potentially de-allocate) a linear number of internal nodes. However, the constant factor in this linear term should be quite small; you can expect that truncate is much faster than multiple calls to pop.

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

Returns an iterator over all elements in this vector.

Iterator construction runs in O(log self.len()) time. Each step of the iteration runs in amortized constant time, worst-case O(log self.len()) time.

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

Returns a mutable iterator over all elements in this vector.

Iterator construction runs in O(log self.len()) time. Each step of the iteration runs in amortized constant time, worst-case O(log self.len()) time.

pub fn iter_starting_at(&self, idx: usize) -> Iter<'_, T, N>

Returns an iterator over borrowed elements in this vector, starting at a specific index.

Iterator construction runs in O(log self.len()) time. Each step of the iteration runs in amortized constant time, worst-case O(log self.len()) time. In particular, if idx is large then this is much more efficient than calling iter and then advancing past idx elements.

pub fn iter_mut_starting_at(&mut self, idx: usize) -> IterMut<'_, T, N>

Returns an iterator over mutable elements in this vector, starting at a specific index.

Iterator construction runs in O(log self.len()) time. Each step of the iteration runs in amortized constant time, worst-case O(log self.len()) time. In particular, if idx is large then this is much more efficient than calling iter and then advancing past idx elements.

pub fn into_iter_starting_at(self, idx: usize) -> IntoIter<T, N>

Returns an iterator over borrowed elements in this vector, starting at a specific index.

Iterator construction runs in O(log self.len() + idx) time. Each step of the iteration runs in amortized constant time, worst-case O(log self.len()) time. Unlike the borrowed iter_starting_at, this is not asymptotically faster than calling into_iter and then advancing past idx elements, because we need to destruct and then potentially de-allocate a linear (in idx) number of things. However, this method should be faster in practice than iterating over idx elements.

Trait Implementations

impl<T: Clone, const N: usize> Clone for Vector<T, N>

where Const<N>: ValidBranchingConstant,

fn clone(&self) -> Vector<T, N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug, const N: usize> Debug for Vector<T, N>

where Const<N>: ValidBranchingConstant,

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

Formats the value using the given formatter.

impl<T, const N: usize> Default for Vector<T, N>

where Const<N>: ValidBranchingConstant,

fn default() -> Self

Returns the “default value” for a type.

impl<T: Clone, const N: usize> Extend<T> for Vector<T, N>

where Const<N>: ValidBranchingConstant,

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

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

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

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

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

Reserves capacity in a collection for the given number of additional elements.

impl<T: Clone, const N: usize> FromIterator<T> for Vector<T, N>

where Const<N>: ValidBranchingConstant,

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

Creates a value from an iterator.

impl<T: Hash, const N: usize> Hash for Vector<T, N>

where Const<N>: ValidBranchingConstant,

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: Clone, const N: usize> Index<usize> for Vector<T, N>

where Const<N>: ValidBranchingConstant,

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<'a, T, const N: usize> IntoIterator for &'a Vector<T, N>

where Const<N>: ValidBranchingConstant,

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T, N>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T, const N: usize> IntoIterator for &'a mut Vector<T, N>

where Const<N>: ValidBranchingConstant, T: Clone,

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T, N>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: Clone, const N: usize> IntoIterator for Vector<T, N>

where Const<N>: ValidBranchingConstant,

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, N>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: PartialEq, const N: usize> PartialEq for Vector<T, N>

where Const<N>: ValidBranchingConstant,

fn eq(&self, other: &Vector<T, N>) -> 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: Eq, const N: usize> Eq for Vector<T, N>

where Const<N>: ValidBranchingConstant,

impl<T, const N: usize> StructuralPartialEq for Vector<T, N>

where Const<N>: ValidBranchingConstant,