Trait IndexMut 

pub trait IndexMut<Idx>: Index<Idx>
where
    Idx: ?Sized,
{
    // Required method
    fn index_mut(&mut self, index: Idx) -> &mut Self::Output;
}

Available on crate features crypto and std only.

Used for indexing operations (container[index]) in mutable contexts.

container[index] is actually syntactic sugar for *container.index_mut(index), but only when used as a mutable value. If an immutable value is requested, the Index trait is used instead. This allows nice things such as v[index] = value.

Examples

A very simple implementation of a Balance struct that has two sides, where each can be indexed mutably and immutably.

use std::ops::{Index, IndexMut};

#[derive(Debug)]
enum Side {
    Left,
    Right,
}

#[derive(Debug, PartialEq)]
enum Weight {
    Kilogram(f32),
    Pound(f32),
}

struct Balance {
    pub left: Weight,
    pub right: Weight,
}

impl Index<Side> for Balance {
    type Output = Weight;

    fn index(&self, index: Side) -> &Self::Output {
        println!("Accessing {index:?}-side of balance immutably");
        match index {
            Side::Left => &self.left,
            Side::Right => &self.right,
        }
    }
}

impl IndexMut<Side> for Balance {
    fn index_mut(&mut self, index: Side) -> &mut Self::Output {
        println!("Accessing {index:?}-side of balance mutably");
        match index {
            Side::Left => &mut self.left,
            Side::Right => &mut self.right,
        }
    }
}

let mut balance = Balance {
    right: Weight::Kilogram(2.5),
    left: Weight::Pound(1.5),
};

// In this case, `balance[Side::Right]` is sugar for
// `*balance.index(Side::Right)`, since we are only *reading*
// `balance[Side::Right]`, not writing it.
assert_eq!(balance[Side::Right], Weight::Kilogram(2.5));

// However, in this case `balance[Side::Left]` is sugar for
// `*balance.index_mut(Side::Left)`, since we are writing
// `balance[Side::Left]`.
balance[Side::Left] = Weight::Kilogram(3.0);

Required Methods

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

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

Panics

May panic if the index is out of bounds.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl IndexMut<Range<usize>> for ByteString

impl IndexMut<Range<usize>> for UninitSlice

impl IndexMut<RangeFrom<usize>> for ByteString

impl IndexMut<RangeFrom<usize>> for UninitSlice

impl IndexMut<RangeFull> for ByteString

impl IndexMut<RangeFull> for OsString

impl IndexMut<RangeFull> for UninitSlice

impl IndexMut<RangeInclusive<usize>> for ByteString

impl IndexMut<RangeInclusive<usize>> for UninitSlice

impl IndexMut<RangeTo<usize>> for ByteString

impl IndexMut<RangeTo<usize>> for UninitSlice

impl IndexMut<RangeToInclusive<usize>> for ByteString

impl IndexMut<RangeToInclusive<usize>> for UninitSlice

impl IndexMut<Span> for [u8]

impl IndexMut<Span> for [u8]

impl IndexMut<usize> for ByteString

impl<'a, T> IndexMut<Range<usize>> for AllocatedStackMemory<'a, T>

impl<'a, T> IndexMut<usize> for AllocatedStackMemory<'a, T>

impl<'a, T> IndexMut<usize> for HeapPrealloc<'a, T>

where T: 'a,

impl<'s, T, I> IndexMut<I> for SliceVec<'s, T>

where I: SliceIndex<[T]>,

impl<'s> IndexMut<&'s str> for DocumentMut

impl<'s> IndexMut<&'s str> for InlineTable

impl<'s> IndexMut<&'s str> for Table

impl<A, I> IndexMut<I> for ArrayVec<A>

where A: Array, I: SliceIndex<[<A as Array>::Item]>,

impl<A, I> IndexMut<I> for SmallVec<A>

where A: Array, I: SliceIndex<[<A as Array>::Item]>,

impl<A, I> IndexMut<I> for TinyVec<A>

where A: Array, I: SliceIndex<[<A as Array>::Item]>,

impl<AllocU32> IndexMut<BucketPopIndex> for EntropyBucketPopulation<AllocU32>

where AllocU32: Allocator<u32>,

impl<G, I> IndexMut<I> for Frozen<'_, G>

where G: IndexMut<I>,

impl<I, T, const N: usize> IndexMut<I> for Simd<T, N>

where T: SimdElement, I: SliceIndex<[T]>,

impl<I> IndexMut<I> for ByteStr

where I: SliceIndex<ByteStr>,

impl<I> IndexMut<I> for Item

where I: Index,

impl<I> IndexMut<I> for String

where I: SliceIndex<str>,

impl<I> IndexMut<I> for Value

where I: Index,

impl<I> IndexMut<I> for str

where I: SliceIndex<str>,

impl<K, V, Q, S> IndexMut<&Q> for IndexMap<K, V, S>

where Q: Hash + Equivalent<K> + ?Sized, S: BuildHasher,

Access [IndexMap] values corresponding to a key.

Mutable indexing allows changing / updating values of key-value pairs that are already present.

You can not insert new pairs with index syntax, use .insert().

Examples

use indexmap::IndexMap;

let mut map = IndexMap::new();
for word in "Lorem ipsum dolor sit amet".split_whitespace() {
    map.insert(word.to_lowercase(), word.to_string());
}
let lorem = &mut map["lorem"];
assert_eq!(lorem, "Lorem");
lorem.retain(char::is_lowercase);
assert_eq!(map["lorem"], "orem");

use indexmap::IndexMap;

let mut map = IndexMap::new();
map.insert("foo", 1);
map["bar"] = 1; // panics!

impl<K, V, S> IndexMut<&K> for LiteMap<K, V, S>

where K: Ord, S: StoreMut<K, V>,

impl<K, V, S> IndexMut<(Bound<usize>, Bound<usize>)> for IndexMap<K, V, S>

impl<K, V, S> IndexMut<Range<usize>> for IndexMap<K, V, S>

impl<K, V, S> IndexMut<RangeFrom<usize>> for IndexMap<K, V, S>

impl<K, V, S> IndexMut<RangeFull> for IndexMap<K, V, S>

impl<K, V, S> IndexMut<RangeInclusive<usize>> for IndexMap<K, V, S>

impl<K, V, S> IndexMut<RangeTo<usize>> for IndexMap<K, V, S>

impl<K, V, S> IndexMut<RangeToInclusive<usize>> for IndexMap<K, V, S>

impl<K, V, S> IndexMut<usize> for IndexMap<K, V, S>

Access [IndexMap] values at indexed positions.

Mutable indexing allows changing / updating indexed values that are already present.

You can not insert new values with index syntax – use [.insert()][IndexMap::insert].

Examples

use indexmap::IndexMap;

let mut map = IndexMap::new();
for word in "Lorem ipsum dolor sit amet".split_whitespace() {
    map.insert(word.to_lowercase(), word.to_string());
}
let lorem = &mut map[0];
assert_eq!(lorem, "Lorem");
lorem.retain(char::is_lowercase);
assert_eq!(map["lorem"], "orem");

use indexmap::IndexMap;

let mut map = IndexMap::new();
map.insert("foo", 1);
map[10] = 1; // panics!

impl<K, V> IndexMut<(Bound<usize>, Bound<usize>)> for Slice<K, V>

impl<K, V> IndexMut<Range<usize>> for Slice<K, V>

impl<K, V> IndexMut<RangeFrom<usize>> for Slice<K, V>

impl<K, V> IndexMut<RangeFull> for Slice<K, V>

impl<K, V> IndexMut<RangeInclusive<usize>> for Slice<K, V>

impl<K, V> IndexMut<RangeTo<usize>> for Slice<K, V>

impl<K, V> IndexMut<RangeToInclusive<usize>> for Slice<K, V>

impl<K, V> IndexMut<usize> for Slice<K, V>

impl<N, E, Ty, Ix> IndexMut<EdgeIndex<Ix>> for Graph<N, E, Ty, Ix>

where Ty: EdgeType, Ix: IndexType,

Index the Graph by EdgeIndex to access edge weights.

Panics if the edge doesn’t exist.

impl<N, E, Ty, Ix> IndexMut<Ix> for Csr<N, E, Ty, Ix>

where Ty: EdgeType, Ix: IndexType,

impl<N, E, Ty, Ix> IndexMut<NodeIndex<Ix>> for Graph<N, E, Ty, Ix>

where Ty: EdgeType, Ix: IndexType,

Index the Graph by NodeIndex to access node weights.

Panics if the node doesn’t exist.

impl<Q> IndexMut<&Q> for Map<String, Value>

where String: Borrow<Q>, Q: Ord + Eq + Hash + ?Sized,

Mutably access an element of this map. Panics if the given key is not present in the map.

map["key"] = json!("value");

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> IndexMut<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> IndexMut<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> IndexMut<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> IndexMut<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> IndexMut<UInt<UInt<UInt<UTerm, B1>, B0>, B0>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> IndexMut<UInt<UInt<UInt<UTerm, B1>, B0>, B1>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> IndexMut<UInt<UInt<UInt<UTerm, B1>, B1>, B0>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> IndexMut<UInt<UInt<UInt<UTerm, B1>, B1>, B1>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> IndexMut<UInt<UInt<UTerm, B1>, B0>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> IndexMut<UInt<UInt<UTerm, B1>, B1>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> IndexMut<UInt<UTerm, B1>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> IndexMut<UTerm> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> IndexMut<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> IndexMut<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> IndexMut<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> IndexMut<UInt<UInt<UInt<UTerm, B1>, B0>, B0>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> IndexMut<UInt<UInt<UInt<UTerm, B1>, B0>, B1>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> IndexMut<UInt<UInt<UInt<UTerm, B1>, B1>, B0>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> IndexMut<UInt<UInt<UInt<UTerm, B1>, B1>, B1>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> IndexMut<UInt<UInt<UTerm, B1>, B0>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> IndexMut<UInt<UInt<UTerm, B1>, B1>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> IndexMut<UInt<UTerm, B1>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> IndexMut<UTerm> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> IndexMut<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> IndexMut<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> IndexMut<UInt<UInt<UInt<UTerm, B1>, B0>, B0>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> IndexMut<UInt<UInt<UInt<UTerm, B1>, B0>, B1>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> IndexMut<UInt<UInt<UInt<UTerm, B1>, B1>, B0>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> IndexMut<UInt<UInt<UInt<UTerm, B1>, B1>, B1>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> IndexMut<UInt<UInt<UTerm, B1>, B0>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> IndexMut<UInt<UInt<UTerm, B1>, B1>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> IndexMut<UInt<UTerm, B1>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> IndexMut<UTerm> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> IndexMut<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8)

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> IndexMut<UInt<UInt<UInt<UTerm, B1>, B0>, B0>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8)

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> IndexMut<UInt<UInt<UInt<UTerm, B1>, B0>, B1>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8)

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> IndexMut<UInt<UInt<UInt<UTerm, B1>, B1>, B0>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8)

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> IndexMut<UInt<UInt<UInt<UTerm, B1>, B1>, B1>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8)

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> IndexMut<UInt<UInt<UTerm, B1>, B0>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8)

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> IndexMut<UInt<UInt<UTerm, B1>, B1>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8)

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> IndexMut<UInt<UTerm, B1>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8)

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> IndexMut<UTerm> for (T0, T1, T2, T3, T4, T5, T6, T7, T8)

impl<T0, T1, T2, T3, T4, T5, T6, T7> IndexMut<UInt<UInt<UInt<UTerm, B1>, B0>, B0>> for (T0, T1, T2, T3, T4, T5, T6, T7)

impl<T0, T1, T2, T3, T4, T5, T6, T7> IndexMut<UInt<UInt<UInt<UTerm, B1>, B0>, B1>> for (T0, T1, T2, T3, T4, T5, T6, T7)

impl<T0, T1, T2, T3, T4, T5, T6, T7> IndexMut<UInt<UInt<UInt<UTerm, B1>, B1>, B0>> for (T0, T1, T2, T3, T4, T5, T6, T7)

impl<T0, T1, T2, T3, T4, T5, T6, T7> IndexMut<UInt<UInt<UInt<UTerm, B1>, B1>, B1>> for (T0, T1, T2, T3, T4, T5, T6, T7)

impl<T0, T1, T2, T3, T4, T5, T6, T7> IndexMut<UInt<UInt<UTerm, B1>, B0>> for (T0, T1, T2, T3, T4, T5, T6, T7)

impl<T0, T1, T2, T3, T4, T5, T6, T7> IndexMut<UInt<UInt<UTerm, B1>, B1>> for (T0, T1, T2, T3, T4, T5, T6, T7)

impl<T0, T1, T2, T3, T4, T5, T6, T7> IndexMut<UInt<UTerm, B1>> for (T0, T1, T2, T3, T4, T5, T6, T7)

impl<T0, T1, T2, T3, T4, T5, T6, T7> IndexMut<UTerm> for (T0, T1, T2, T3, T4, T5, T6, T7)

impl<T0, T1, T2, T3, T4, T5, T6> IndexMut<UInt<UInt<UInt<UTerm, B1>, B0>, B0>> for (T0, T1, T2, T3, T4, T5, T6)

impl<T0, T1, T2, T3, T4, T5, T6> IndexMut<UInt<UInt<UInt<UTerm, B1>, B0>, B1>> for (T0, T1, T2, T3, T4, T5, T6)

impl<T0, T1, T2, T3, T4, T5, T6> IndexMut<UInt<UInt<UInt<UTerm, B1>, B1>, B0>> for (T0, T1, T2, T3, T4, T5, T6)

impl<T0, T1, T2, T3, T4, T5, T6> IndexMut<UInt<UInt<UTerm, B1>, B0>> for (T0, T1, T2, T3, T4, T5, T6)

impl<T0, T1, T2, T3, T4, T5, T6> IndexMut<UInt<UInt<UTerm, B1>, B1>> for (T0, T1, T2, T3, T4, T5, T6)

impl<T0, T1, T2, T3, T4, T5, T6> IndexMut<UInt<UTerm, B1>> for (T0, T1, T2, T3, T4, T5, T6)

impl<T0, T1, T2, T3, T4, T5, T6> IndexMut<UTerm> for (T0, T1, T2, T3, T4, T5, T6)

impl<T0, T1, T2, T3, T4, T5> IndexMut<UInt<UInt<UInt<UTerm, B1>, B0>, B0>> for (T0, T1, T2, T3, T4, T5)

impl<T0, T1, T2, T3, T4, T5> IndexMut<UInt<UInt<UInt<UTerm, B1>, B0>, B1>> for (T0, T1, T2, T3, T4, T5)

impl<T0, T1, T2, T3, T4, T5> IndexMut<UInt<UInt<UTerm, B1>, B0>> for (T0, T1, T2, T3, T4, T5)

impl<T0, T1, T2, T3, T4, T5> IndexMut<UInt<UInt<UTerm, B1>, B1>> for (T0, T1, T2, T3, T4, T5)

impl<T0, T1, T2, T3, T4, T5> IndexMut<UInt<UTerm, B1>> for (T0, T1, T2, T3, T4, T5)

impl<T0, T1, T2, T3, T4, T5> IndexMut<UTerm> for (T0, T1, T2, T3, T4, T5)

impl<T0, T1, T2, T3, T4> IndexMut<UInt<UInt<UInt<UTerm, B1>, B0>, B0>> for (T0, T1, T2, T3, T4)

impl<T0, T1, T2, T3, T4> IndexMut<UInt<UInt<UTerm, B1>, B0>> for (T0, T1, T2, T3, T4)

impl<T0, T1, T2, T3, T4> IndexMut<UInt<UInt<UTerm, B1>, B1>> for (T0, T1, T2, T3, T4)

impl<T0, T1, T2, T3, T4> IndexMut<UInt<UTerm, B1>> for (T0, T1, T2, T3, T4)

impl<T0, T1, T2, T3, T4> IndexMut<UTerm> for (T0, T1, T2, T3, T4)

impl<T0, T1, T2, T3> IndexMut<UInt<UInt<UTerm, B1>, B0>> for (T0, T1, T2, T3)

impl<T0, T1, T2, T3> IndexMut<UInt<UInt<UTerm, B1>, B1>> for (T0, T1, T2, T3)

impl<T0, T1, T2, T3> IndexMut<UInt<UTerm, B1>> for (T0, T1, T2, T3)

impl<T0, T1, T2, T3> IndexMut<UTerm> for (T0, T1, T2, T3)

impl<T0, T1, T2> IndexMut<UInt<UInt<UTerm, B1>, B0>> for (T0, T1, T2)

impl<T0, T1, T2> IndexMut<UInt<UTerm, B1>> for (T0, T1, T2)

impl<T0, T1, T2> IndexMut<UTerm> for (T0, T1, T2)

impl<T0, T1> IndexMut<UInt<UTerm, B1>> for (T0, T1)

impl<T0, T1> IndexMut<UTerm> for (T0, T1)

impl<T0> IndexMut<UTerm> for (T0,)

impl<T, A> IndexMut<usize> for VecDeque<T, A>

where A: Allocator,

impl<T, I, A> IndexMut<I> for rama::http::grpc::protobuf::prost::alloc::vec::Vec<T, A>

where I: SliceIndex<[T]>, A: Allocator,

impl<T, I, A> IndexMut<I> for Vec<T, A>

where I: SliceIndex<[T]>, A: Allocator,

impl<T, I, const N: usize> IndexMut<I> for [T; N]

where [T]: IndexMut<I>,

impl<T, I> IndexMut<I> for [T]

where I: SliceIndex<[T]>,

impl<T, P> IndexMut<usize> for Punctuated<T, P>

impl<T> IndexMut<PatternID> for rama::http::grpc::protobuf::prost::alloc::vec::Vec<T>

Available on crate feature alloc only.

impl<T> IndexMut<PatternID> for rama::http::grpc::protobuf::prost::alloc::vec::Vec<T>

impl<T> IndexMut<PatternID> for [T]

impl<T> IndexMut<PatternID> for [T]

impl<T> IndexMut<Range<usize>> for WrapBox<T>

impl<T> IndexMut<SmallIndex> for rama::http::grpc::protobuf::prost::alloc::vec::Vec<T>

Available on crate feature alloc only.

impl<T> IndexMut<SmallIndex> for rama::http::grpc::protobuf::prost::alloc::vec::Vec<T>

impl<T> IndexMut<SmallIndex> for [T]

impl<T> IndexMut<SmallIndex> for [T]

impl<T> IndexMut<StateID> for rama::http::grpc::protobuf::prost::alloc::vec::Vec<T>

Available on crate feature alloc only.

impl<T> IndexMut<StateID> for rama::http::grpc::protobuf::prost::alloc::vec::Vec<T>

impl<T> IndexMut<StateID> for [T]

impl<T> IndexMut<StateID> for [T]

impl<T> IndexMut<usize> for NonEmptyVec<T>

impl<T> IndexMut<usize> for Slab<T>

impl<T> IndexMut<usize> for StackRef<T>

where T: Stackable,

impl<T> IndexMut<usize> for WrapBox<T>

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