# Trait std::ops::IndexMut

1.0.0 · source ·

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

Expand description

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);

Run

## Required Methods§

source

#### 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.

## Implementors§

1.3.0 · source§

### impl IndexMut<Range<usize>> for String

1.3.0 · source§

### impl IndexMut<RangeFrom<usize>> for String

1.44.0 · source§

### impl IndexMut<RangeFull> for OsString

1.3.0 · source§

### impl IndexMut<RangeFull> for String

1.26.0 · source§

### impl IndexMut<RangeInclusive<usize>> for String

1.3.0 · source§

### impl IndexMut<RangeTo<usize>> for String

1.26.0 · source§

### impl IndexMut<RangeToInclusive<usize>> for String

source§

### impl<I> IndexMut<I> for str where I: SliceIndex<str>,

source§

### impl<I, T, const LANES: usize> IndexMut<I> for Simd<T, LANES>where T: SimdElement, LaneCount<LANES>: SupportedLaneCount, I: SliceIndex<[T]>,

source§

### impl<T, A> IndexMut<usize> for VecDeque<T, A>where A: Allocator,

source§

### impl<T, I> IndexMut<I> for [T]where I: SliceIndex<[T]>,

source§

### impl<T, I, A, FH> IndexMut<I> for Vec<T, A, FH>where I: SliceIndex<[T]>, A: Allocator, FH: FailureHandling,

1.50.0 · source§

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