Struct LazyVec

pub struct LazyVec<T: Clone> { /* private fields */ }

lazy-cogs implementation of a Vector. It’s a collection meant to be used when you need to work with the individual elements

Cloning a LazyVec is always O(1). Getting elements from it is also O(1)

Modifing existing elements may take O(n) if the vector is a clone that is still modified, or if it has living clones.

Pushing elements follow the same logic

Implementations

impl<T: Clone> LazyVec<T>

pub fn new() -> Self

Creates a new empty LazyVec

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

Obtains a reference to a specific value in the lazy vector

If the index is out of range it returns None

This operation is always O(1)

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

Obtains a mutable reference to a specific value in the lazy vector

If the index is out of range it returns None

This operation is protected, it means, that the other clones aren’t affected

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

Obtains a lazy clone to a specific value in the lazy vector

If the index is out of range it returns None

pub fn set(&mut self, index: usize, value: T) -> Result<(), ()>

Updates an item in the current vector

The operation coast dependents on the state of the vector:

• If vector was never modified, this costs O(n)
• If it was modified but some one cloned it, it’s also O(n)
• If it was modified and no one cloned it, it’s O(1)
• If it isn’t cloned from other vector and no one cloned it, it’s O(1)

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

Pushes a new element at the end of the vector

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

Pops an element at the end of the vector

pub fn remove(&mut self, index: usize) -> T

Removes an element from the vector

pub fn remove_lazy(&mut self, index: usize) -> Lc<T>

Removes an element from the vector and returns a lazy clone to it

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

Inserts an element at a given position in a vector

pub fn iter(&self) -> impl Iterator<Item = &T>

Produces an iterator over the elements

pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut T>

Produces a mutable iterator

Trait Implementations

impl<T: Debug + Clone> Debug for LazyVec<T>

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

Formats the value using the given formatter.

impl<T: Clone> From<&[T]> for LazyVec<T>

fn from(value: &[T]) -> Self

Converts to this type from the input type.

impl<T: Clone> From<Vec<Lc<T>>> for LazyVec<T>

fn from(value: Vec<Lc<T>>) -> Self

Converts to this type from the input type.

impl<T: Clone> From<Vec<T>> for LazyVec<T>

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

Converts to this type from the input type.

impl<T: Clone> FromIterator<T> for LazyVec<T>

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

Creates a value from an iterator.

impl<T: Clone> Index<usize> for LazyVec<T>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T: Clone> IndexMut<usize> for LazyVec<T>

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

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

impl<T: Clone> Into<Vec<Lc<T>>> for LazyVec<T>

fn into(self) -> Vec<Lc<T>>

Converts this type into the (usually inferred) input type.

impl<T: Clone> Into<Vec<T>> for LazyVec<T>

fn into(self) -> Vec<T>

Converts this type into the (usually inferred) input type.

impl<T: Clone> IntoIterator for LazyVec<T>

type Item = 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<T: Clone> LazyClone for LazyVec<T>

fn lazy(&self) -> Self

The O(1) lazy-clone method. Useful for cloning data that doesn’t necessarily need to be mutated.

fn eager(&self) -> Self

A non-lazy cloning method. Useful for cloning data that is known to modified

fn is_mutable(&self) -> bool

Checks if the structure can be mutated with no side effects