How is Rust able to enforce safety in your code? The simple answer to this question is: the borrow checker. This presentation is an overview on the language concepts that helps the developer to allocate and deallocate memory in an efficient way just like in C/C++, and also safe. Rust learnt from C/C++ design patterns and included those in the language, adding the concept of Ownership and Borrowing.

1. The Amazing
Borrow Checker!
By Mario A. Santini

2. Mario A. Santini
a Software Developer
in Telco.

3. Rust Ownership Rules
●
Each value in Rust has a variable that’s called its owner
●
There can only be one owner at a time
●
When the owner goes out of scope, the value will be
dropped

4. RAII
Resource Acquisition Is Initialization

5. Some Examples
...
let my_var = 1;
let another_var = my_var;
println!(“My var {}”, my_var); // ← can’t be done!
...
let my_var = String::from(“Hello SoCraTeN!”);
require_ownership(my_var); // ← move ownership
println!(“My var {}”, my_var); // ← can’t be done!
...
fn require_ownership(s: String) { // ← this signature requires ownership
// some cool stuff here...
}

6. Borrowing
...
let my_var = 1;
let another_var = &my_var; // ← this is borrowed!
println!(“My var {}”, my_var); // ← now it’s perfectly fine
...
let my_var = String::from(“Hello SoCraTeN!”);
doesnt_require_borrow(&my_var); // ← move don’t happen
println!(“My var {}”, my_var); // ← now it’s fine
...
fn doesnt_require_borrow(s: &String) { // ← this signature requires borrowed
// some cool stuff here...
}

7. Slices
Let s = String:from(“Hello World”);
Let s1: &str = &s[6..11];
println!(“:= {}”, s1); // → := World

8. Slices
name value
ptr
len 11
capacity 11
index value
0 H
1 e
2 l
3 l
4 0
5
6 W
7 o
8 r
9 l
10 d
s: String
name value
ptr
len 5
s1: &str
Heap
Stack

9. The Wrong Way
Fighting the borrow checker

10. The Good Way
Borrow Checker is a friend!
Just try to follow the rules

11. Lifetime
fn main() {
let r; // ---------+-- 'a
// |
{ // |
let x = 5; // -+-- 'b |
r = &x; // | |
} // -+ |
// |
println!("r: {}", r); // |
} // ---------+

12. Compiling playground v0.0.1 (/playground)
error[E0597]: `x` does not live long enough
--> src/main.rs:6:13
|
6 | r = &x; // | |
| ^^ borrowed value does not live long enough
7 | } // -+ |
| - `x` dropped here while still borrowed
8 | // |
9 | println!("r: {}", r); // |
| - borrow later used here
For more information about this error, try `rustc --explain E0597`.
error: could not compile `playground` due to previous error

13. Lifetime Annotation Why
fn longest(x: &str, y: &str) -> &str {
if x.len() > y.len() {
x
} else {
y
}
}

14. Lifetime Annotation
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
if x.len() > y.len() {
x
} else {
y
}
}

15. Lifetime Use Example
fn main() {
let string1 = String::from("long string is long");
{
let string2 = String::from("xyz");
let result = longest(string1.as_str(), string2.as_str());
println!("The longest string is {}", result);
}
}
fn main() {
let string1 = String::from("long string is long");
let result;
{
let string2 = String::from("xyz");
result = longest(string1.as_str(), string2.as_str());
}
println!("The longest string is {}", result);
}

16. Copy vs Clone
Copy
Usually cheap
Copy just the reference
Clone
Usually heavy
Copy the memory and create
a new reference.

17. The Reference Counting
●
Allow more than one owner
●
It enforce the safety at runtime
3
4
5 10 Nil
b
c
a

18. The Reference Counting
use std::rc::Rc;
enum List {
Cons(i32, Rc<List>),
Nil,
}
fn main() {
let a = Rc::new(Cons(5, Rc::new(Cons(10, Rc::new(Nil)))));
let b = Cons(3, Rc::clone(&a)); // clone the Rc!
let c = Cons(4, Rc::clone(&a)); // clone the Rc!
}
// This code does not work as Cons → List::Cons and Nil → List:Nil
NO Thread Safe!

19. use std::cell::Cell;
pub struct Cell<T>
where
T: ?Sized, { /* private fields */ }
pub fn set(&self, val: T)
pub fn get(&self) -> T
pub fn get_mut(&mut self) -> &mut T
...
NO Thread Safe!

20. use std::cell::RefCell;
pub struct RefCell<T> where
T: ?Sized, { /* private fields */ }
pub fn borrow(&self) -> Ref<'_, T>
pub fn borrow_mut(&self) -> RefMut<'_, T>
...
NO Thread Safe!

21. Interior Mutability Cell<T>/RefCell<T>
use std::cell::{RefCell, RefMut};
use std::collections::HashMap;
use std::rc::Rc;
fn main() {
let shared_map: Rc<RefCell<_>> = Rc::new(RefCell::new(HashMap::new()));
// Create a new block to limit the scope of the dynamic borrow
{
let mut map: RefMut<_> = shared_map.borrow_mut();
map.insert("africa", 92388);
map.insert("kyoto", 11837);
map.insert("piccadilly", 11826);
map.insert("marbles", 38);
}
// Note that if we had not let the previous borrow of the cache fall out
// of scope then the subsequent borrow would cause a dynamic thread panic.
// This is the major hazard of using `RefCell`.
let total: i32 = shared_map.borrow().values().sum();
println!("{total}");
}

22. References
●
Rust book: The Rust Programming Language
– (https://doc.rust-lang.org/book/)
●
Rustonomincon
– (https://doc.rust-lang.org/nomicon/)
●
Jon Gjengset YouTube channel
– (https://www.youtube.com/c/JonGjengset)
●
Rust Playground
– (https://play.rust-lang.org/)

23. Thank You!
Have any question?
Please go ahead! :)