Mut keyword. In the Rust language we must mark variables or references that can be changed in memory. The mut keyword refers to mutable variables.
When deciding what code owns the memory for a variable, mutability is important. It is safe for any code to read memory, but writing to memory can interfere with code correctness elsewhere.
Simple error. Local variables that are modified more than once must be marked with mut. Even a simple local integer must have the mut keyword. This program won't compile.
fn main() {
// This variable must be mut x.
let x = 10;
println!("{}", x);
x += 1;
println!("{}", x);
}error[E0384]: cannot assign twice to immutable variable x
... help: consider making this binding mutable: mut x
... cannot assign twice to immutable variable
Simple error, fix. Here we add the needed mut keyword. The program compiles and works as expected, and the variable x can be modified any number of times.
fn main() {
// This variable must be mut x.
let mut x = 10;
println!("{}", x);
x += 1;
println!("{}", x);
}10
11
Mutable reference. Suppose we are passing a reference to a struct—this is efficient, as the struct does not need to be copied. But we cannot by default modify the struct in the function we call.
Here We try to modify Bird in update_features, but this does not compile. We must have a mutable Bird reference.
struct Bird {
feathers: Vec<u8>
}
fn update_feathers(b: &Bird) {
// This modifies the Bird, so it must have a mutable reference.
b.feathers.push(1);
}
fn main() {
let mut b = Bird{feathers:vec![]};
// Does not compile.
update_feathers(&b);
println!("Feathers: {}", b.feathers.len());
}error[E0596]: cannot borrow b.feathers as mutable, as it is behind a & reference
... help: consider changing this to be a mutable reference: &mut Bird
... b is a & reference, so the data it refers to cannot be borrowed as mutable
Reference, fix. To fix the mutable reference problem, we can use the "ampersand mut" syntax. This syntax means we want to modify the data pointed to by the reference.
Info The syntax is a bit confusing at first. There is no "mut" object anywhere, it is just a keyword in Rust.
struct Bird {
feathers: Vec<u8>
}
fn update_feathers(b: &mut Bird) {
// This modifies the Bird.
b.feathers.push(1);
}
fn main() {
let mut b = Bird{feathers:vec![]};
update_feathers(&mut b);
println!("Feathers: {}", b.feathers.len());
}Feathers: 1
A summary. We fixed some errors with the "mut" keyword in Rust in the simplest possible way. Rust tracks parts of code that change data pointed to by references.
Dot Net Perls is a collection of pages with code examples, which are updated to stay current. Programming is an art, and it can be learned from examples.
Donate to this site to help offset the costs of running the server. Sites like this will cease to exist if there is no financial support for them.
Sam Allen is passionate about computer languages, and he maintains 100% of the material available on this website. He hopes it makes the world a nicer place.
This page was last updated on Apr 20, 2023 (edit link).