SIGPL Summer School 2016 http://sigpl.or.kr/school/2016s/

1. Tour of Rust
Seo Sanghyeon
2016-08-18

2. Control and Safety
• C++
More control, less safety
• Java
Less control, more safety
• Rust
More control, more safety

3. Users
• Rust
Rust compiler is written in Rust
• Servo
Parallel browser engine
• Dropbox
Cloud file storage
• More on
https://www.rust-lang.org/en-US/friends.html

4. Memory representation
struct Point { x: i32, y: i32 }
struct Size { width: i32, height: i32 }
struct Rect { origin: Point, size: Size }

5. Boxed representation
x
y
width
height
origin
size
rect

6. Unboxed representation
x
y
width
height

7. Assignment
• b = a, by default,
Reference in Python
Copy in C++
Move in Rust

8. Reference (Python)
a = [1, 2, 3]
b = a
a[2] = 4
b[2] # evaluates to 4

9. Reference
1 2 3a
b
4

10. Copy (C++)
std::vector<int> a, b;
a = {1, 2, 3};
b = a;
a[2] = 4;
b[2]; // evaluates to 3

11. Copy
1 2 3a
b 1 2 3
4

12. Copy (C++) and destruction
std::vector<int> a, b;
a = {1, 2, 3};
b = a;
// b is destroyed
// a is destroyed

13. Move (Rust) and destruction
let a = vec![1, 2, 3];
let b = a;
// a is moved and can’t be used
// any more
// b is destroyed
// a is not destroyed

14. Move
1 2 3a
b

15. Comparison
Python C++ Rust
Reference b = a T& b = a b = &a
Copy b = list(a) b = a b = a.clone()
Move b = move(a) b = a

16. Move (C++)
std::vector<int> a, b;
a = {1, 2, 3};
b = std::move(a);
a[2] = 4; // crashes

17. Move (Rust), 1
let a = vec![1, 2, 3];
let b = a;
a[2] = 4;

18. Immutable by default
| let a = vec![1, 2, 3];
| - use `mut a` here
| let b = a;
| a[2] = 4;
| ^ cannot borrow mutably

19. Move (Rust), 2
let mut a = vec![1, 2, 3];
let b = a;
a[2] = 4;

20. Move is enforced
| let b = a;
| - value moved here
| a[2] = 4;
| ^ value used here after move

21. Conditional move
let a = vec![1, 2, 3];
if random() {
let b = a;
}
// is a destroyed?

22. Move flag
let a = vec![1, 2, 3];
let a_flag = true;
if random() {
let a_flag = false;
let b = a;
}
if a_flag { /* a is destroyed */ }

23. Move based on type
• In Rust, b = a
Move by default
Copy if a: T and T: Copy

24. Copy is opt-in
struct Point {
x: i32,
y: i32,
}
impl Copy for Point {}

25. Copy impl is checked
struct Point {
name: String,
x: i32,
y: i32,
}
impl Copy for Point {}
// error: field `name` does not implement Copy

26. Copy for references
• &T: Copy
Immutable reference is copied
• &mut T: !Copy
Mutable reference cannot be copied

27. Invalidation (C++)
std::vector<int> a;
a.push_back(1);
int& b = a[0];
a.push_back(2);
b; // undefined

28. Invalidation (Rust)
let mut a = vec![];
a.push(1);
let b = &a[0];
a.push(2);

29. Compile time check
| let b = &a[0];
| - immutable borrow
| a.push(2);
| ^ mutable borrow

30. Borrow is scoped
let mut a = vec![];
a.push(1);
{
let b = &a[0];
b; // this is okay!
}
a.push(2); // this too!

31. Aliasing XOR Mutation
• Multiple immutable borrows
• Or single mutable borrow
• This is why &mut T cannot be copied

32. Function
fn get(v: &Vec<i32>, i: usize)
-> &i32 { &v[i] }
let mut a = vec![];
a.push(1);
let b = get(&a, 0);
a.push(2);

33. Lifetime
fn get<’a>(v: &’a Vec<i32>,
i: usize)
-> &’a i32 { &v[i] }
let mut a = vec![];
a.push(1);
let b = get(&a, 0);
a.push(2);

34. Lifetime subtyping
• If ’a: ’b (’a outlives ’b)
&’a T <: &’b T
• Converse is also true:
If &’a T <: &’b T
’a: ’b

35. Lifetime inference
fn get<’a>(v: &’a Vec<i32>,
i: usize)
-> &’a i32 { &v[i] }
let b: &’x i32 = get(&’y a, 0);
// what is relationship between
// ’x and ’y?

36. Inference steps
• fn get <: get
• &’a T -> &’a U <: &’y T -> &’x U
• &’y T <: &’a T, &’a U <: &’x U
• ’y: ’a, ’a: ’x
• ’y: ’x

37. Lifetime inference result
let b: &’x i32 = get(&’y a, 0);
// ’y outlives ’x
// a is borrowed as long as
// b is in scope
// which was to be demonstrated