Rust Mozlando Tutorial

Hack without fear!

Nicholas Matsakis

Systems programming without the hassle

Systems programming without the hasslecrashesheisenbugsfear

Parallel!

// sums all the positive values in `v` fn sum_pos(v: &[i32]) -> i32 { let mut sum = 0; for i in v.iter().filter(|i| **i > 0) { sum += *i; } sum }

High-level coding

// sums all the positive values in `v` fn sum_pos(v: &[i32]) -> i32 { let mut sum = 0; for i in v.iter().filter(|i| **i > 0) { sum += *i; } sum }

High-level coding

Iterators.

Closures.

Assembly code

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: &[i32]) -> i32 { v.iter() .filter(|i| **i > 0) .map(|i| *i) .sum() }

Higher-level coding

…generates the same assembly code.

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 }

Might free underlying buffer.

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.

fn parallel_qsort(vec: &mut [int]) { if vec.len() <= 1 { return; } let pivot = vec[random(vec.len())]; let mid = vec.partition(vec, pivot); let (less, greater) = vec.split_at_mut(mid); rayon::join( || parallel_qsort(less), || parallel_qsort(greater) ); }

Parallel

7Caveat: shameless plug for third-party package of mine.

fn parallel_qsort(vec: &mut [int]) { if vec.len() <= 1 { return; } let pivot = vec[random(vec.len())]; let mid = vec.partition(vec, pivot); let (less, greater) = vec.split_at_mut(mid); rayon::join( || parallel_qsort(less), || parallel_qsort(greater) ); }

Parallel

Sort left and right in parallel.Caveat: shameless plug for third-party package of mine.

fn parallel_qsort(vec: &mut [int]) { if vec.len() <= 1 { return; } let pivot = vec[random(vec.len())]; let mid = vec.partition(vec, pivot); let (less, greater) = vec.split_at_mut(mid); rayon::join( || parallel_qsort(less), || parallel_qsort(less) ); }

Parallel… and safe

Data race.

fn parallel_qsort(vec: &mut [int]) { if vec.len() <= 1 { return; } let pivot = vec[random(vec.len())]; let mid = vec.partition(vec, pivot); let (less, greater) = vec.split_at_mut(mid); rayon::join( || parallel_qsort(less), || parallel_qsort(less) ); }

Parallel… and safe

error: closure requires unique access to `less` but it is already borrowed || parallel_qsort(less) ^~~~~~~~~~~~~~~~~~~~~~~

Data race.

Open and welcoming

Rust has been open source from the beginning. !

Open governance model based on public RFCs. !

We have an active, amazing community.

The Plan

1. Hello, world! 2. Structs and such. 3. Threads.

Hello, world!

smallcultfollowing.com/20151209/ !

Example “Hello World”

fn main() { println!(“Hello, world!”); }

Ownership!!n. The act, state, or right of possessing something.

Borrow!!v. To receive something with the promise of returning it.

Ownership/Borrowing

Memory safety

Data-race freedom

No need for a runtime

Ownership/Borrowing

Memory safety

Data-race freedom

Ownership/Borrowing

Memory safety

Data-race freedom

Ownership15

fn main() { let name = format!(“…”); helper(name); helper(name); }

fn helper(name: String) { println!(..); } !!!

Ownership 16

Ownership

Take ownership of a String

Ownership 16

Error: use of moved value: `name`

void main() { Vector name = …; helper(name); helper(name); }

void helper(Vector name) { … } !!!

“Ownership” in Java 17

“Ownership” in Java

Take reference to Vector

new Thread(…);

fn main() { let name = format!(“…”); helper(name.clone()); helper(name); }

fn helper(name: String) { println!(..); } !!!Copy the String

Copy (auto-Clone)

fn main() { let name = 22; helper(name); helper(name); }

fn helper(name: i32) { println!(..); } !!!

Copy (auto-Clone)

i32 is a Copy type

Copy (auto-Clone)

i32 is a Copy type

Copy (auto-Clone)

i32 is a Copy type

Copy (auto-Clone)

i32 is a Copy type

Copy (auto-Clone)

i32 is a Copy type

Non-copyable: Values move from place to place. Examples: File descriptor, database handle. !

Clone: Run custom code to make a copy. Examples: String, Vector!!

Copy: Type is implicitly copied when referenced. Examples: u32, i32, (f32, i32).

Exercise: ownership

http://smallcultfollowing.com/20151209

Cheat sheet:

fn helper(name: String) // takes ownership !string.clone() // clone the string

http://doc.rust-lang.org/std

Borrowing22

fn helper(name: &String) { println!(..); } !!!

fn main() { let name = format!(“…”); helper(&name); helper(&name); }

Shared borrow 23

Shared borrow

Take a reference to a String

Shared borrow

Lend the string

Shared borrow

Lend the string

Shared borrow

Lend the string

Shared borrow 23

Shared == Immutable

fn helper(name: &String) { println!(“{}”, name); }

fn helper(name: &String) { name.push_str(“foo”); }

Shared == Immutable

OK. Just reads.

Shared == Immutable

OK. Just reads.

Error. Writes.

Shared == Immutable

OK. Just reads.

Error. Writes.

error: cannot borrow immutable borrowed content `*name` as mutable name.push_str(“s”); ^~~~

Shared == Immutable

OK. Just reads.

Error. Writes.

* Actually: mutation only in controlled circumstances.

error: cannot borrow immutable borrowed content `*name` as mutable name.push_str(“s”); ^~~~

fn update(name: &mut String) { name.push_str(“…”); } !!!

fn main() { let mut name = …; update(&mut name); println!(“{}”, name); }

Mutable borrow 25

Mutable borrow

Take a mutable reference to a String

Mutable borrow

Lend the string mutably

Mutable borrow

Mutable borrow 25

Mutate string in place

Mutable borrow 25

Prints the updated string.

Mutable borrow 25

Play time

26http://is.gd/no0tTH

.capacity: …

.len: 10

fn main()

name.data

‘R’ ‘u’ … ‘n’ ‘s’

.capacity: …

.len: 10

fn main()

name.data

‘R’ ‘u’ … ‘n’ ‘s’

.capacity: …

.len: 10

fn main()

name.data

‘R’ ‘u’ … ‘n’ ‘s’

.capacity: …

.len: 10

fn main()

name.data

fn helper()

String owned by somebody else up the stack.

‘R’ ‘u’ … ‘n’ ‘s’

.capacity: …

.len: 10

fn helper(name: &str) { !}

fn main()

name.data

fn helper()

name.data

fn main() { let name = format!(“…”); helper(&name[1..9]); helper(&name); }

.len: 8

‘R’ ‘u’ … ‘n’ ‘s’

“ustacean”

.capacity: …

.len: 10

fn main()

name.data

fn helper()

name.data

.len: 8

‘R’ ‘u’ … ‘n’ ‘s’

“ustacean”

.capacity: …

.len: 10

fn main()

name.data

fn helper()

name.data

.len: 8

‘R’ ‘u’ … ‘n’ ‘s’

“ustacean”

.capacity: …

.len: 10

fn main()

name.data

fn helper()

name.data

.len: 8

‘R’ ‘u’ … ‘n’ ‘s’

“ustacean”

.capacity: …

.len: 10

fn main()

name.data

fn helper()

name.data

.len: 8

‘R’ ‘u’ … ‘n’ ‘s’

“ustacean”

Subslice of a string owned up the stack

.capacity: …

.len: 10

fn main()

name.data

fn helper()

name.data

.len: 8

‘R’ ‘u’ … ‘n’ ‘s’

“ustacean”

.capacity: …

.len: 10

fn main()

name.data

fn helper()

name.data

.len: 8

‘R’ ‘u’ … ‘n’ ‘s’

“ustacean”

helper(&name[1..]);

.capacity: …

.len: 10

fn main()

name.data

fn helper()

name.data

.len: 8

‘R’ ‘u’ … ‘n’ ‘s’

“ustacean”

helper(&name[1..]);

“stacean”7

.capacity: …

.len: 10

fn main()

name.data

fn helper()

name.data

.len: 8

‘R’ ‘u’ … ‘n’ ‘s’

“ustacean”

helper(&name[1..]);

“stacean”7

.capacity: …

.len: 10

fn main()

name.data

fn helper()

name.data

.len: 8

‘R’ ‘u’ … ‘n’ ‘s’

“ustacean”

helper(&name[1..]);

“stacean”7

.capacity: …

.len: 10

fn main()

name.data

fn helper()

name.data

.len: 8

‘R’ ‘u’ … ‘n’ ‘s’

“ustacean”

helper(&name[1..]);

“stacean”7

String

capacity

String

capacity

‘R’ ‘u’ … ‘s’‘R’ ‘u’ … ‘s’

“Rustaceans”: &str

format!(“Rustaceans”): String

…Rustaceans…

String

capacity

String

capacity

‘R’ ‘u’ … ‘s’‘R’ ‘u’ … ‘s’

…Rustaceans…

String

capacity

String

capacity

‘R’ ‘u’ … ‘s’‘R’ ‘u’ … ‘s’

…Rustaceans…

String

capacity

String

capacity

‘R’ ‘u’ … ‘s’‘R’ ‘u’ … ‘s’

…Rustaceans…

String

capacity

String

capacity

‘R’ ‘u’ … ‘s’‘R’ ‘u’ … ‘s’

…Rustaceans…

String

capacity

String

capacity

‘R’ ‘u’ … ‘s’‘R’ ‘u’ … ‘s’

…Rustaceans…

&’static str

String

capacity

String

capacity

‘R’ ‘u’ … ‘s’‘R’ ‘u’ … ‘s’

…Rustaceans…

&’static str

Whither Safety?

30https://www.flickr.com/photos/langtind/2217639550/in/photostream/

GC vs C++ vs Rust

GC’d language (e.g. Java)One size fits all`void helper(String name)`

temporary access?start a thread?store in a static?

RustTemporary references — confined to owner’s scopeData cannot be freed or mutated while reference is live

C++No clear rulesEasily invalidated“Don’t make mistakes”

GC vs C++ vs Rust

fn main() { let r; { let name = format!(“…”); r = &name; } println!(“{}”, r); }

.capacity: …

.len: 10

name.data ‘R’ ‘u’ … ‘n’ ‘s’

.capacity: …

.len: 10

.capacity: …

.len: 10

.capacity: …

.len: 10

.capacity: …

.len: 10

.capacity: …

.len: 10

.capacity: …

.len: 10

.capacity: …

.len: 10

.capacity: …

.len: 10

.capacity: …

.len: 10

Dangling reference!

.capacity: …

.len: 10

Dangling reference!

33http://is.gd/HJyO7A

Lifetime: span of code where reference is used.

http://is.gd/HJyO7A

Scope of data being borrowed (here, `name`)compared against

http://is.gd/HJyO7A

error: `name` does not live long enough r = &name; ^~~~

use std::thread; !fn helper(name: &String) { thread::spawn(move || { use(name); }); }

`name` can only be used within this fn

Might escape the function!

error: the type `[…]` does not fulfill the required lifetime thread::spawn(move || { ^~~~~~~~~~~~~ note: type must outlive the static lifetime

However: see crossbeam, simple_parallel, etc on

crates.io

Dangers of mutation

let mut buffer: String = format!(“Rustacean”); let slice = &buffer[1..]; buffer.push_str(“s”); println!(“{:?}”, slice);

Dangers of mutation

‘R’ ‘u’ … ‘n’

String

capacity

Dangers of mutation

‘R’ ‘u’ … ‘n’

String

capacity

Dangers of mutation

‘R’ ‘u’ … ‘n’

String

capacity

Dangers of mutation

‘R’ ‘u’ … ‘n’

String

capacity

Dangers of mutation

‘R’ ‘u’ … ‘n’

String

capacity

Dangers of mutation

‘R’ ‘u’ … ‘n’

String

capacity

Dangers of mutation

‘R’ ‘u’ … ‘n’

String

capacity

‘R’ ‘u’ … ‘n’

Dangers of mutation

‘R’ ‘u’ … ‘n’

String

capacity

‘R’ ‘u’ … ‘n’

‘s’

Dangers of mutation

String

capacity

‘R’ ‘u’ … ‘n’

‘s’

Dangers of mutation

String

capacity

‘R’ ‘u’ … ‘n’

‘s’

Dangers of mutation

String

capacity

‘R’ ‘u’ … ‘n’

‘s’

Dangers of mutation

String

capacity

‘R’ ‘u’ … ‘n’

‘s’

Dangling reference!

Dangers of mutation

String

capacity

‘R’ ‘u’ … ‘n’

‘s’

Dangling reference!

Rust solution

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.

Dangers of mutation

fn main() { let mut buffer: String = format!(“Rustacean”); let slice = &buffer[1..]; buffer.push_str(“s”); println!(“{:?}”, slice); }

http://is.gd/MCPVWg

Dangers of mutation

http://is.gd/MCPVWg

Dangers of mutation

Borrow “locks” `buffer` until `slice` goes out of scope

http://is.gd/MCPVWg

Dangers of mutation

http://is.gd/MCPVWg

Dangers of mutation

error: cannot borrow `buffer` as mutable because it is also borrowed as immutable buffer.push_str(“s”); ^~~~~~

http://is.gd/MCPVWg

Dangers of mutation

error: cannot borrow `buffer` as mutable because it is also borrowed as immutable buffer.push_str(“s”); ^~~~~~

http://is.gd/MCPVWg

fn main() { let mut buffer: String = format!(“Rustacean”); for i in 0 .. buffer.len() { let slice = &buffer[i..]; buffer.push_str(“s”); println!(“{:?}”, slice); } buffer.push_str(“s”); }

OK: `buffer` is not borrowed here

Exercise: borrowing

Cheat sheet:

&String // type of shared reference &mut String // type of mutable reference &str // type of string slice !&name // shared borrow &mut name // mutable borrow &name[x..y] // slice expression

Structs and such

41Shop till you drop!

By QuentinUK (Own work), via Wikimedia Commons

Declaring a structure

struct Store { name: String, prices: Vec<Item>, }

prices

.length

.capacity

.length

.capacity

prices

‘R’ ‘u’ … ‘n’

.length

.capacity

.length

.capacity

prices

‘R’ ‘u’ … ‘n’

.length

.capacity

.length

.capacity

struct Item { name: &’static str, price: f32, }

Other fundamental types

f32 f64 !!

i8 i16 i32 i64 isize

u8 u16 u32 u64 usize

&str &[T] !!

floats signed unsigned slices

f32 f64 !!

&str &[T] !!

f32 f64 !!

&str &[T] !!

f32 f64 !!

&str &[T] !!

f32 f64 !!

&str &[T] !!

f32 f64 !!

&str &[T] !!

f32 f64 !!

&str &[T] !!

f32 f64 !!

&str &[T] !!

f32 f64 !!

&str &[T] !!

f32 f64 !!

&str &[T] !!

f32 f64 !!

&str &[T] !!

f32 f64 !!

&str &[T] !!

f32 f64 !!

&str &[T] !!

Methods

struct Store { .. } struct Item { .. } !impl Store { fn add_item(&mut self, item: Item) { self.items.push(item); } ! fn price(&self, item_name: &str) -> f32 { … // see upcoming slide } }

Methods

store.add_item(…); // must be let mut store.price(…); // let OR let mut

Methods

itself an &mut method

Methods

struct Store { .. } !impl Store { fn new(name: String) -> Store { return Store { name: name, items: vec![], }; } }

Methods

Store::new(some_name)

Methods

Return is optional

struct Store { .. } !impl Store { fn new(name: String) -> Store { Store { name: name, items: vec![], } } }

Return is optional

struct Store { .. } !impl Store { fn new(name: String) -> Store { Store { name: name, items: vec![], } } }

No `;` on last expression: “return this value”

Options and Enums

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

fn main() { let v: Option<i32> = Some(22); match v { Some(x) => println!(“v = {}”, x), None => println!(“v = None”), } println!(“v = {}”, v.unwrap()); // risky }

http://is.gd/Gfum32

Options and Enums

http://is.gd/Gfum32

Options and Enums

http://is.gd/Gfum32

Options and Enums

http://is.gd/Gfum32

Options and Enums

http://is.gd/Gfum32

Options and Enums

http://is.gd/Gfum32

Options and Enums

http://is.gd/Gfum32

Options and Enums

http://is.gd/Gfum32

Options and Enums

http://is.gd/Gfum32

Options and Enums

http://is.gd/Gfum32

Options and Enums

http://is.gd/Gfum32

For Loops

fn main() { let v = vec![format!(“Alpha”), format!(“Beta”), format!(“Gamma”)]; for s in v { println!(“{:?}”, s); } }

http://is.gd/6kJc0O

“Alpha”

“Beta”

“Gamma”

For Loops

http://is.gd/6kJc0O

“Alpha”

“Beta”

“Gamma”

For Loops

http://is.gd/6kJc0O

“Alpha”

“Beta”

“Gamma”

For Loops

http://is.gd/6kJc0O

“Alpha”

“Beta”

“Gamma”

For Loops

http://is.gd/6kJc0O

“Alpha”

“Beta”

“Gamma”

Vec<String>

For Loops

http://is.gd/6kJc0O

“Alpha”

“Beta”

“Gamma”

String

Vec<String>

For Loops

http://is.gd/6kJc0O

“Alpha”

“Beta”

“Gamma”

For Loops

http://is.gd/6kJc0O

“Alpha”

“Beta”

“Gamma”

For Loops

http://is.gd/6kJc0O

“Beta”

“Gamma”

For Loops

http://is.gd/6kJc0O

“Beta”

“Gamma”

For Loops

http://is.gd/6kJc0O

“Gamma”

For Loops

fn main() { let mut v = vec![format!(“Alpha”), format!(“Beta”), format!(“Gamma”)]; ! for s in &v { println!(“{:?}”, s); } ! for s in &mut v { s.push_str(“.”); } }

“Alpha”

“Beta”

“Gamma”

For Loops

“Alpha”

“Beta”

“Gamma”

For Loops

“Alpha”

“Beta”

“Gamma”

&Vec<String>

For Loops

“Alpha”

“Beta”

“Gamma”

&String

&Vec<String>

For Loops

“Alpha”

“Beta”

“Gamma”

For Loops

“Alpha”

“Beta”

“Gamma”

For Loops

“Alpha”

“Beta”

“Gamma”

For Loops

“Alpha”

“Beta”

“Gamma”

For Loops

“Alpha”

“Beta”

“Gamma”

&mut Vec<String>

&mut String

For Loops

“Alpha”

“Beta”

“Gamma”

Exercise: structs

Implement

fn total_price(..)

Cheat sheet:

for s in v { … }

for s in &v { … }

let mut some_var = 0.0;

println!(“{:?}”, s);

some_var += x;

while … { … }

Threading

Multiparadigm

message-passing

Multiparadigm

mutable shared memorymessage-passing

$5.0 $25.5 $81.5 ——— $112.0

$5.0 $20.5 $81.5 ——— $107.0

$5.0 $25.5 $81.5 ——— $112.0

$5.0 $20.5 $81.5 ——— $107.0

$5.0 $23.5

XXX ——— XXX

$5.0 $25.5 $81.5 ——— $112.0

$5.0 $20.5 $81.5 ——— $107.0

$5.0 $23.5

XXX ——— XXX

let mut best = None; let mut best_price = INFINITY; for store in stores { let sum = store.total_price(&shopping_list); match sum { Some(s) if s < best_price => { best = Some(store.name); best_price = s; } _ => { } } }

use std::thread; … let mut handles = vec![]; for store in stores { let handle = thread::spawn(move || { let sum = store.total_price(shopping_list); (store.name, sum) }); handles.push(handle); }

Closure takes ownership

of variables it uses.

Variables used by this closure.

Handle to the thread we spawned.

Closure body can produce a result,

here a (String, f32).

let handle = thread::spawn(…);

… // stuff in parallel // with new thread

let (name, sum) = handle.join().unwrap();

Wait for thread to finish and

get return value.

Result<(String, f32), Error>

get return value.

Thread may have panicked. Propagate.

get return value.

Thread may have panicked. Propagate.Result of thread.

use std::thread; … let shopping_list = vec![…]; let mut handles = vec![]; for store in stores { let handle = thread::spawn(move || { let sum = store.total_price(shopping_list); (store.name, sum) }); handles.push(handle); }

error: capture of moved value: `shopping_list` let sum = store.total_price(&shopping_list); ^~~~~~~~~~~~~ … help: perhaps you meant to use `clone()`?

use std::thread; … let shopping_list = vec![…]; let mut handles = vec![]; for store in stores { let shopping_list = shopping_list.clone(); let handle = thread::spawn(move || { let sum = store.total_price(shopping_list); (store.name, sum) }); handles.push(handle); }

use std::sync::Arc; let shopping_list: Vec<ShoppingList> = …; let arc1 = Arc::new(shopping_list); let arc2 = arc1.clone(); let data = &arc1[0];

Arc => Immutable

use std::sync::Arc; let shopping_list: Vec<ShoppingList> = …; let arc1 = Arc::new(shopping_list); let data = &mut arc1[0];

http://is.gd/nP3Pvb

Arc => Immutable

http://is.gd/nP3Pvb

Arc => Immutable

<anon>:6:21: 6:24 error: cannot borrow immutable borrowed content as mutable <anon>:6 let data = &mut arc[0]; ^~~

http://is.gd/nP3Pvb

use std::thread; … let shopping_list = Arc::new(vec![…]); let mut handles = vec![]; for store in stores { let shopping_list = shopping_list.clone(); let handle = thread::spawn(move || { let sum = store.total_price(shopping_list); (store.name, sum) }); handles.push(handle); }

// exercise (in a bit): join the handles!

Channels

Joining a thread allows thread to send one result.

What if we wanted multiple results?

Or if we wanted a response?

fn parent() { let (tx, rx) = channel(); spawn(move || {…}); let m = rx.recv().unwrap(); }

move || { let m = Message::new(); … tx.send(m).unwrap(); }

MessageMessage

Message

let (tx0, rx0) = channel(); let tx1 = tx0.clone(); spawn(move || /* omitted */); let tx2 = tx0.clone(); spawn(move || /* omitted */);

fn sync_inc(counter: &Arc<Mutex<i32>>) { let mut data = counter.lock().unwrap(); *data += 1; }

https://commons.wikimedia.org/wiki/File:No-DRM_lock.svg

counter

Exercise: threads

Cheat sheet:let (name, sum) = thread.join().unwrap();

use std::sync::mpsc::channel; let (rx, tx) = channel(); tx.send(value).unwrap(); let value = rx.recv().unwrap();

use std::sync::{Arc, Mutex}; let mutex = Arc::new(Mutex::new(data)); let data = mutex.lock().unwrap();

Plea for help

Please fill out the feedback form found at

Thanks for

listenin

Rust Mozlando Tutorial

Software

Transcript of Rust Mozlando Tutorial