#[lang = "index_mut"]
pub trait IndexMut<Idx>: Index<Idx> where
Idx: ?Sized, {
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.
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),
};
assert_eq!(balance[Side::Right], Weight::Kilogram(2.5));
balance[Side::Left] = Weight::Kilogram(3.0);
fn index_mut(&mut self, index: Idx) -> &mut Self::Output
Performs the mutable indexing (container[index]) operation.
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 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.
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].
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].
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].