Enum VecMutation 

pub enum VecMutation<T>
where
    T: Clone,
{
    Splice(usize, usize, Vec<T>),
    InsertMany(usize, Vec<T>),
    InsertOne(usize, T),
    Extend(Vec<T>),
    Push(T),
    RemoveRange(usize, usize),
    RemoveOne(usize),
    RemoveMany(IndexSet),
    RemoveLast,
    Clear,
    Update(usize, T),
    UpdateLast(T),
    Set(Vec<T>),
}

Ergonomic, debuggable and loggable mutation to a Vec<T>.

Variants in this enum may represent overlapping operations as they are designed for ergonomics and clarity. To analyze the precise changes to a vector, use the [VecMutation::log] method which produces a detailed log of the changes that a mutation will apply.

Variants

Splice(usize, usize, Vec<T>)

Replaces the given range with new elements.

Splice is capable of both inserting and removing elements.

When analyzed as a VecEffect, this mutation is equivalent to a Remove followed by an Insert.

InsertMany(usize, Vec<T>)

Inserts many elements at the given index.

Same as Splice with an empty removal range.

InsertOne(usize, T)

Inserts one element at the given index.

Same as [InsertMany] but for a single element.

Extend(Vec<T>)

Appends many elements to the end of the vec.

Similar to InsertMany but targeting the end of the vec when applied.

Push(T)

Appends one element to the end of the vec.

Same as Extend but for a single element.

RemoveRange(usize, usize)

Removes a range of elements.

Same as Splice with an empty insertion list.

RemoveOne(usize)

Removes a single element at the given index.

Same as RemoveRange but for a single element.

RemoveMany(IndexSet)

Remove many sparse elements at once.

When analyzed as a VecEffect, this mutation is equivalent to multiple sparse Removes.

Note: This is more efficient than multiple RemoveOne mutations, as all removals are performed in a single retain pass. However, building the index list itself can be expensive anyways, so use this with caution.

RemoveLast

Removes the last element from the vec.

When analyzed as a VecEffect, this mutation is equivalent to a Remove.

Clear

Removes all elements from the vec.

Same as RemoveRange targeting the full range of the vec.

Update(usize, T)

Updates the element at the given index.

When analyzed as a VecEffect, this mutation is equivalent to an Update.

UpdateLast(T)

Updates the last element in the vec.

When analyzed as a VecEffect, this mutation is equivalent to an Update.

Set(Vec<T>)

Replaces the entire contents of the vec with the given elements.

When analyzed as a VecEffect, this mutation is equivalent to a Remove of the full previous contents followed by an Insert of the new contents.

Implementations

impl<T> VecMutation<T>

where T: Clone,

pub fn apply(self, list: &mut Vec<T>)

Apply the changes represented by this mutation to the given vec.

pub fn update_with( target: &[T], index: usize, updater: impl FnOnce(&mut T), ) -> VecMutation<T>

Use a function to craft a VecMutation::Update using mutable semantics.

This clones the target item on construction.

pub fn update_last_with( target: &[T], updater: impl FnOnce(&mut T), ) -> VecMutation<T>

Use a function to craft a VecMutation::UpdateLast using mutable semantics.

This clones the target item on construction.

pub fn remove_many_with_retain( target: &[T], retain: impl FnMut(usize, &T) -> bool, ) -> VecMutation<T>

Constructs a VecMutation::RemoveMany using retention semantics.

The retain predicate should return true for elements to keep and false for elements to remove. This matches the semantics of Rust’s standard Vec::retain method.

Warning: This will allocate a Vec to hold all the matched indices. Read the documentation of VecMutation::RemoveMany for more details.

pub fn effects<'a>( &'a self, target: &'a [T], ) -> Box<dyn Iterator<Item = VecEffect<'a, T>> + 'a>

Trait Implementations

impl<T> Clone for VecMutation<T>

where T: Clone,

fn clone(&self) -> VecMutation<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for VecMutation<T>

where T: Debug + Clone,

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

Formats the value using the given formatter.

impl From<VecMutation<Bot>> for ChatStateMutation

fn from(mutation: VecMutation<Bot>) -> ChatStateMutation

Converts to this type from the input type.

impl From<VecMutation<Message>> for ChatStateMutation

fn from(mutation: VecMutation<Message>) -> ChatStateMutation

Converts to this type from the input type.

impl<T> PartialEq for VecMutation<T>

where T: PartialEq + Clone,

fn eq(&self, other: &VecMutation<T>) -> 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> StructuralPartialEq for VecMutation<T>

where T: Clone,