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 feature 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<usize> for ByteString

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 String

where I: SliceIndex<str>,

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<(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().

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<K> for BoxedSlice<K, V>

where K: EntityRef,

Mutable indexing into a BoxedSlice.

impl<K, V> IndexMut<K> for PrimaryMap<K, V>

where K: EntityRef,

Mutable indexing into an PrimaryMap.

impl<K, V> IndexMut<K> for SecondaryMap<K, V>

where K: EntityRef, V: Clone,

Mutable indexing into an SecondaryMap.

The map grows as needed to accommodate new keys.

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<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 Vec<T, A>

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

impl<T, I, U> IndexMut<I> for Array<T, U>

where [T]: IndexMut<I>, U: ArraySize,

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

where I: SliceIndex<[T]>,

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

where [T]: IndexMut<I>,

impl<T, I> IndexMut<I> for SerVec<T>

where I: SliceIndex<[T]>,

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

where I: SliceIndex<[T]>,

impl<const A: usize, I> IndexMut<I> for AlignedVec<A>

where I: SliceIndex<[u8]>,