core::ops::IndexMut - Rust
Description: API documentation for the Rust `IndexMut` trait in crate `core`.
Keywords: rust, rustlang, rust-lang, IndexMut

# 1.0.0[−][src]Trait core::ops::IndexMut

    #[lang = "index_mut"]
    pub trait IndexMut<Idx: ?Sized>: Index<Idx> {
        fn index_mut(&mut self, index: Idx) -> &mut Self::Output;
    }

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<'a>(&'a self, index: Side) -> &'a Weight {
            println!("Accessing {:?}-side of balance immutably", index);
            match index {
                Side::Left => &self.left,
                Side::Right => &self.right,
            }
        }
    }

    impl IndexMut<Side> for Balance {
        fn index_mut<'a>(&'a mut self, index: Side) -> &'a mut Weight {
            println!("Accessing {:?}-side of balance mutably", index);
            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

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

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

Loading content...

## Implementors

### `impl IndexMut<Range<usize>> for str`[src]

Implements mutable substring slicing with syntax `&mut self[begin .. end]`.

Returns a mutable slice of the given string from the byte range [`begin`..`end`).

This operation is `O(1)`.

# Panics

Panics if `begin` or `end` does not point to the starting byte offset of a character (as defined by `is_char_boundary`). Requires that `begin <= end` and `end <= len` where `len` is the length of the string.

#### `fn index_mut(&mut self, index: Range<usize>) -> &mut str`[src]

### `impl IndexMut<RangeFrom<usize>> for str`[src]

Implements mutable substring slicing with syntax `&mut self[begin ..]`.

Returns a mutable slice of the string from byte offset `begin` to the end of the string.

Equivalent to `&mut self[begin .. len]`.

#### `fn index_mut(&mut self, index: RangeFrom<usize>) -> &mut str`[src]

### `impl IndexMut<RangeFull> for str`[src]

Implements mutable substring slicing with syntax `&mut self[..]`.

Returns a mutable slice of the whole string. This operation can never panic.

Equivalent to `&mut self[0 .. len]`.

#### `fn index_mut(&mut self, _index: RangeFull) -> &mut str`[src]

### `impl IndexMut<RangeInclusive<usize>> for str`[src]

#### `fn index_mut(&mut self, index: RangeInclusive<usize>) -> &mut str`[src]

### `impl IndexMut<RangeTo<usize>> for str`[src]

Implements mutable substring slicing with syntax `&mut self[.. end]`.

Returns a mutable slice of the string from the beginning to byte offset `end`.

Equivalent to `&mut self[0 .. end]`.

#### `fn index_mut(&mut self, index: RangeTo<usize>) -> &mut str`[src]

### `impl IndexMut<RangeToInclusive<usize>> for str`[src]

#### `fn index_mut(&mut self, index: RangeToInclusive<usize>) -> &mut str`[src]

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

#### `fn index_mut(&mut self, index: I) -> &mut I::Output`[src]

Loading content...

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g., `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)