CodeBlanks Logo Icon CodeBlanks
Login Register

Borrowing rules

Learn the rules for multiple references at the same time.

Borrowing rules

At any given time, only one of these can be true for a value:

  • any number of &T (readers), or
  • a single &mut T (a writer).
let mut v = vec![1, 2, 3];
let ilk = &v[0];        // a reader
// v.push(4);           // error E0502: can't write while a reader exists
println!("{ilk}");
v.push(4);              // ilk is no longer used, fine

This rule prevents a reference from pointing at an old address after the vector grows and moves to new memory.

Fixing the error

The fix for these errors is usually one of: finishing the use of the reference before the change, copying the value (let ilk = v[0]; is Copy for i32), or separating the operations:

let mut v = vec![1, 2, 3];
let ilk = v[0];          // a copy, not a reference
v.push(ilk * 10);
println!("{:?}", v);     // [1, 2, 3, 10]

Practice Duplicate the first element

Declare let mut v = vec![1, 2, 3];. Take the first element by copying (let ilk = v[0];), then do v.push(ilk * 10); and print with {:?}.

Starter code

main.rs
fn main() {
    // buraya yaz
}

Sample solution

main.rs
fn main() {
    let mut v = vec![1, 2, 3];
    let ilk = v[0];
    v.push(ilk * 10);
    println!("{:?}", v);
}

Expected output

[1, 2, 3, 10]

Questions and answers

Review the lesson questions together with their answers. To test yourself, solve the lesson interactively.

1 In the example above, why would <code>v.push(4)</code> fail on the first line?

  • push might move to new memory and ilk would point at an invalid address Correct answer
  • v is immutable
  • 4 is the wrong type
  • It wouldn't fail

Explanation: When capacity runs out, the vector allocates a new array and moves the elements; the borrow checker catches this use-after-free bug at compile time.

2 Fix with a copy

Question 
let mut v = vec![5, 6];
let ilk = ____;   // referans değil
v.push(ilk);
Answer 
let mut v = vec![5, 6];
let ilk = v[0];   // referans değil
v.push(ilk);

Explanation: v[0] produces a copy for i32, so v can be changed.

3 Case and result

Term Meaning
&v + &v Allowed
&mut v + &mut v E0499
&v + v.push() E0502
let x = v[0]; v.push() Allowed (copy)

All lessons in Beginner

1 Rust basics

  1. What is Rust?
  2. Project with Cargo
  3. Your first program
  4. println! and formatting
  5. Comments
  6. Summary - Rust basics

2 Variables

  1. Variables with let
  2. Mutability with mut
  3. Constants with const
  4. Static variables
  5. Shadowing
  6. Summary - Variables

3 Data types

  1. Integers
  2. Floating point
  3. Bool and char
  4. Tuple
  5. Array
  6. Summary - Data types

4 Strings

  1. &str vs String
  2. Creating a String
  3. Concatenating strings
  4. format! macro
  5. String length
  6. Summary - Strings

5 Project: Calculator

  1. Project skeleton
  2. Reading input
  3. Computing
  4. Error handling
  5. Loop and exit

6 Functions

  1. Defining with fn
  2. Parameters
  3. Return value
  4. Expressions and statements
  5. Early return
  6. Summary - Functions

7 Control flow

  1. if-else
  2. match basics
  3. loop
  4. while loop
  5. for loop
  6. Summary - Control flow

8 Ownership

  1. What is ownership?
  2. Move semantics
  3. Copy trait
  4. Functions and ownership
  5. Return and ownership
  6. Summary - Ownership

9 Borrowing

  1. References
  2. Mutable reference
  3. Borrowing rules
  4. Dangling reference
  5. References and functions
  6. Summary - Borrowing

10 Slices

  1. String slices
  2. Slice syntax
  3. Array slices
  4. Slices and functions
  5. Range types
  6. Summary - Slices

11 Project: Guessing game

  1. Game skeleton
  2. Reading input
  3. Comparing numbers
  4. Random number
  5. Loop and exit

12 Structs

  1. Struct definition
  2. Creating an instance
  3. Tuple struct
  4. Unit-like struct
  5. Field update
  6. Summary - Structs

13 Methods

  1. impl block
  2. self parameter
  3. &mut self
  4. Associated functions
  5. Multiple impl blocks
  6. Summary - Methods

14 Enums

  1. Enum definition
  2. Variants
  3. Variants with data
  4. Option<T>
  5. Option instead of null
  6. Summary - Enums

15 Pattern matching

  1. match patterns
  2. Value binding
  3. if let
  4. while let
  5. _ wildcard
  6. Summary - Pattern matching

16 Project: To-do CLI

  1. Task model
  2. Adding
  3. Listing
  4. Marking done
  5. Reading commands

17 Vectors

  1. Vec<T>
  2. Push and pop
  3. Index and get
  4. Looping a vector
  5. with_capacity
  6. Summary - Vectors

18 Advanced strings

  1. String and &str conversion
  2. chars and bytes
  3. Slicing strings
  4. contains and replace
  5. split and join
  6. Summary - Advanced strings

19 Error handling

  1. Result<T, E>
  2. panic!
  3. ? operator
  4. match and Result
  5. unwrap and expect
  6. Summary - Error handling

20 Beginner final

  1. Vowel counter
  2. Average calculator
  3. Bank account
  4. Temperature converter