Rust tutorial from Boston Meetup 2015-07-22

Nicholas Matsakis!
Mozilla Research

So, you want more control?
C++?
OMG!
2
Too slow!
Other things you might want:!
• Standalone library, as you would get from C
• Interface with another runtime, e.g. Ruby
• Use a really cool language :)

My god, it’s full of bugs
3
Dangling pointers
!
Segmentation faults
!
Double frees
!
Uninitialized data
!
Null pointer exceptions
!
Resource leaks (DB handle)
!
Data races
Solved by GC
Not so much.

4
Systems programming without the hassle
crashes!
heisenbugs!
fear
Parallel!

// sums all the positive values in `v`
fn sum_pos(v: &Vec<i32>) -> i32 {
let mut sum = 0;
for i in v.iter().filter(|i| **i > 0) {
sum += *i;
}
sum
}
High-level coding
5
Iterators.
Closures.

Assembly code
6
leaq (%rdi,%rsi,4), %rcx
xorl %eax, %eax
jmp .LBB5_1
.LBB5_3:
addl %edx, %eax
.align 16, 0x90
.LBB5_1:
cmpq %rdi, %rcx
je .LBB5_4
movl (%rdi), %edx
addq $4, %rdi
testl %edx, %edx
jle .LBB5_1
jmp .LBB5_3
.LBB5_4:
retq

fn foo(v: &Vec<i32>) -> i32 {
v.iter()
.filter(|i| **i > 0)
.map(|i| *i)
.sum()
}
Higher-level coding
7
…generates the same assembly code.

Safe
8
fn this_wont_compile(v: &mut Vec<i32>) -> i32 {
let mut sum = 0;
for &i in v.iter() {
sum += i;
if i > 0 { v.push(0); }
}
sum
}
error: cannot borrow `*v` as mutable because it is also borrowed
as immutable
if i > 0 { v.push(0); }
^
note: previous borrow of `*v` occurs here; the immutable borrow
prevents subsequent moves or mutable borrows of `*v` until
the borrow ends
for &i in v.iter() {
^
Might free
underlying buffer.

Parallel
9
use std::thread;
fn qsort(data: &mut [i32])
if data.len() <= 1 {
return;
}
let mid = partition(data[0], data);
let (left, right) = data.split_at_mut(mid);
let t1 = thread::scoped(|| qsort(left));
qsort(right);
}
Sort left and right
in parallel.Caveat: unstable API.

Open and welcoming
Rust has been open source from the beginning.
!
Open governance model based on public RFCs.
!
We have an active, amazing community.
❤
10

Getting Started
11
You can either install Rust, or
just use play.rust-lang.org
Exercises are available at:
!
http://nikomatsakis.github.io/rust-tutorial-boston-20150722/

Outline
12
1. The big ideas:!
a. Ownership
b. Borrowing
2. Everyday life:!
a. Data types
b. Modules and privacy
c. Cargo

Ownership!
!
n. The act, state, or right of possessing something.
13
Borrow!
!
v. To receive something with the promise of returning it.

The Big Idea
Ownership and borrowing:!
!
1. All memory has a clear owner.
2. Others can borrow from the owner.
3. Owner cannot free or mutate the
memory while it is borrowed.
14

Ownership/Borrowing
Memory
safety
Data-race
freedom
No need for
a runtime
GCC++
15

Clean up the mess
16
http://mylifeandkids.com/messy-house-edition-boys-bedroom-2/

fn give() {
let mut vec = vec![];
vec.push(1);
vec.push(2);
take(vec);
…
}
fn take(vec: Vec<i32>) {
// …
}
!
!
!
Ownership
Take ownership
of a Vec<i32>
18

fn give() {
let mut vec = Vec::new();
vec.push(1);
vec.push(2);
take(vec);
…
}
vec.push(2);
Compiler enforces moves
fn take(vec: Vec<i32>) {
// …
}
!
!
!Error: vec has been moved
Prevents:
- use after free
- double moves
- …
19

void give() {
Vector vec = …;
vec.add(1);
vec.add(2);
take(vec);
vec.add(3);
}
void take(Vector vec) {
// …
}
!
!
!
“Ownership” in Java
Take reference
to Vector
20

Mutability
21
fn prefix_sum(mut v: Vec<i32>) -> Vec<i32> {
let mut sum = 0;
for i in 0 .. v.len() {
sum += v[i];
v[i] = sum;
}
v
}
http://is.gd/wCtQQZ
1, 2, 3, 4 1, 3, 6, 10
(caller) (preﬁx sum)

Clone
22
fn main() {
let d = vec![1, 3, 4, 10];
let ps = prefix_sum(d);
println!("prefix sum of {:?} is {:?}",
d, ps);
}
http://is.gd/nbuxdV

Clone
23
fn main() {
let d = vec![1, 3, 4, 10];
let ps = prefix_sum(d.clone());
println!("prefix sum of {:?} is {:?}",
d, ps);
}
http://is.gd/nbuxdV
1, 2, 3, 4 1, 3, 6, 10
(caller) (preﬁx sum)
1, 2, 3, 4

24
struct Point {
x: u32,
y: u32
}
!
fn area(ul: Point, lr: Point) -> u32 {
(lr.x - ul.x) * (lr.y - ul.y)
}
!
fn main() {
let origin = Point { x: 0, y: 0 };
let unit = Point { x: 1, y: 1 };
let here = Point { x: 5, y: 6 };
println!(“{:?}”, area(origin, unit));
println!(“{:?}”, area(origin, here));
}
Declare a struct
type Point with two
ﬁelds, x and y.
// 1
// ?
http://is.gd/5dDnaH
32-bit unsigned integer

“Copy” types
25
#[derive(Copy, Clone)]
struct Point {
x: u32,
y: u32
}

26
Default: Type cannot be copied.
Values move from place to place.
Example: File descriptor.
!
Clone: Type is expensive to copy,
so make it explicit by calling clone().
Example: Vector, hashtable.!
!
Copy: Type is implicitly copied
whenever it is referenced.
Example: u32, i32, Point

* Actually: mutation only in controlled circumstances
*
Shared borrow (&T)
Sharing Mutation

Mutable borrow (&mut T)
29
Sharing Mutation

30
fn sum(v: Vec<i32>) -> i32 {
let mut s = 0;
s += v[i];
}
s
}
!
fn main() {
let v = vec![1, 2, 3];
println!(“{:?}”, sum(v));
}
Take ownership
of a Vec<i32>
Give ownership

31
fn sum(v: &Vec<i32>) -> i32 {
let mut s = 0;
s += v[i];
}
s
}
!
fn main() {
let v = vec![1, 2, 3];
println!(“{:?}”, sum(&v));
}
Borrow!
Vec<i32>
Lend the vector
http://is.gd/aHalet

32
fn prefix_sum(v: &mut Vec<i32>) {
let mut s = 0;
s += v[i];
v[i] = s;
}
}
!
fn main() {
let mut v = vec![1, 2, 3];
prefix_sum(&mut v);
println!("{:?}", v);
}
Mutable borrow
Mutable loan
http://is.gd/jvKmF2

fn example() {
let mut names = Vec::new();
names.push(..);
names.push(..);
let name = &names[1];
names.push(..);
print(name);
}
names
data
length
capacity
“brson”
“pcwalton”
name
“brson”
“pcwalton”
“acrichto”
Sharing: more than
one pointer to same
memory.
Dangling pointer: pointer
to freed memory.
Mutating the vector
freed old contents.
33

Rust solution
34
Compile-time read-write-lock:!
!
Creating a shared reference to X “read locks” X.
- Other readers OK.
- No writers.
- Lock lasts until reference goes out of scope.
!
Creating a mutable reference to X “writes locks” X.
- No other readers or writers.
- Lock lasts until reference goes out of scope.
Never have a reader/writer at same time.

fn example() {
names.push(“brson”);
names.push(“pcwalton”);
let name = &names[1];
names.push(“acrichto”);
println!(“{:?}”, name);
}
Borrow “locks”
`names` until `name`
goes out of scopeError: cannot mutate
`names` while borrowed
35
http://is.gd/jeKW1E

Outside of borrow scope — OK.
Scope of borrow
in this case covers
only the loop body.
36
http://is.gd/thMY5N
fn main() {
names.push("brson");
names.push("pcwalton");
for i in 0 .. names.len() {
let name = &names[i];
names.push("acrichto");
println!("{:?}", name);
}
}

Rust reasons about scopes
37
fn main() {
names.push("brson");
names.push("pcwalton");
for i in 0 .. names.len() {
let name = &names[i];
println!("{:?}", name);
}
}
Even though reference is not used,
it is still in scope for the entire block..
http://is.gd/pLE8bb

Methods
40
struct Point {
x: f32,
y: f32,
}
!
impl Point {
fn new() -> Point {
Point { x: 0.0, y: 0.0 }
}
!
fn negate(&self) -> Point {
Point { x: -self.x, y: -self.y }
}
} http://is.gd/KbbORT

Common derivations
41
#[derive(PartialEq)]
+ #[derive(PartialOrd)]
#[derive(Clone)]
#[derive(Debug)]
x == y, x != y
x < y, x <= y, …
x.clone()
+ #[derive(Copy)] use(x); use(x);
println!(“{:?}”, x);
#[derive(Hash)] HashMap<T>

Enums
42
struct Point {..}
!
enum Shape {
Circle { origin: Point,
radius: f32 },
!
Rectangle { ul: Point,
lr: Point }
}

43
struct Point {..}
!
enum Shape {
Circle { origin: Point, radius: f32 },
Rectangle { ul: Point, lr: Point }
}
!
impl Shape {
fn unit_circle() -> Shape {
Shape::Circle {
origin: Point { x: 0.0, y: 0.0 },
radius: 1.0
}
}
}

const PI: f32 = 3.14159;
impl Shape {
fn area(&self) -> f32 {
match *self {
Shape::Circle { origin: _, radius: r } =>
PI * r * r,
!
Shape::Rectangle { ul, lr } =>
(lr.y - ul.y).abs() * (lr.x - ul.x).abs()
}
}
}
44
http://is.gd/a2YcvG

Option
45
enum Option<T> {
None,
Some(T),
}

No null types
46
class Shape {
Color color;
!
Shape() { }
!
Color getColor(Color default) {
if (color != null)
return color;
return default;
}
}
(Java)

47
struct Shape {
color: Option<Color>
}
!
impl Shape {
fn new() -> Shape {
Shape { color: None }
}
!
fn get_color(&self, default: Color) -> Color {
match self.color {
None => default,
Some(ref c) => c.clone()
}
}
} (Rust)

48
match self.color {
None => default,
Some(ref c) => c.clone()
}
if let Some(ref c) = self.color {
c.clone()
} else {
default
}
self.color.unwrap_or(default)
self.color.unwrap_or_else(|| default)

Slices
49
fn main() {
// Heap-allocated.
let v: Vec<i32> = vec![1, 2, 3, 4];
!
// Reference to one element.
let e: &i32 = &v[1];
!
// Reference to many elements.
let slice: &[i32] = &v[1..3];
}
http://is.gd/QftPT8

Mutable slices
50
fn main() {
// Heap-allocated.
let mut v: Vec<i32> = vec![1, 2, 3, 4];
println!(“v={:?}”, v);
{
let slice = &mut v[..];
slice[1] += 22;
}
println!(“v={:?}”, v);
}
http://is.gd/31rKv5

For loops and slices
51
for x in &v {
// x is an &i32
}
let v: Vec<i32> = vec![1, 2, 3, 4];
for x in &mut v {
// x is an &mut i32
}
for x in v {
// x is an i32
} // v is consumed after loop
for converts its argument into an iterator
using the IntoIterator trait

Iterators
52
struct PlayerScore {
player_name: String,
score: u32
}
!
fn high_scorers(v: Vec<PlayerScore>)
-> Vec<(String, u32)>
{
v.into_iter()
.filter(|ps| ps.score > 20)
.map(|ps| (ps.player_name, ps.score))
.collect()
}

Cargo
54
> cargo new my_project
> cargo new —-bin my_project
> cd my_project
> emacs
Create a template for a new project:
Edit your project:
> cargo build [—-release]
> cargo test
Build and test your project:
http://doc.crates.io/guide.html

Dependencies
55
[package]
name = "hello_world"
version = "0.1.0"
authors = ["Your Name <you@example.com>”]
!
[dependencies]
regex = "0.1.41"
Cargo.toml
lib.rs
extern crate regex;

Modules
56
mod data;
mod code;
lib.rs/main.rs
data/mod.rs
mod point;
mod shape;
data/point.rs
struct Point {
}
::
data
point
shape
code
data/shape/mod.rs
struct Point {
}

Often used to make
a mod test for unit tests,
or for demonstations.
Inline modules
57
mod data {
mod point {
..
}
!
mod shape {
..
}
}
!
mod code {
lib.rs/main.rs Exactly the same as
creating a separate ﬁle.

Use
58
::
data
point
shape
code
code.rs
use data::point::Point;
data/mod.rs
use self::point::Point;
data/shape.rs
use super::point::Point;

Privacy
59
Privacy is the default, use pub to override.
pub struct Point {
pub x: f32,
pub y: f32,
}
impl Point {
pub fn m(&self);
}
pub enum Shape {
…
}
pub mod child;
Private means: code in this module or a descendant.

Where to learn more
60
doc.rust-lang.org/book
users.rust-lang.org / IRC / Stackoverﬂow
doc.rust-lang.org/std

Rust tutorial from Boston Meetup 2015-07-22

More Related Content

What's hot

Similar to Rust tutorial from Boston Meetup 2015-07-22

Recently uploaded

Rust tutorial from Boston Meetup 2015-07-22