Rust Mozlando Tutorial

1. 1 Hack without fear! Nicholas Matsakis

2. 2 Systems programming without the hassle

3. 2 Systems programming without the hassle crashes heisenbugs fear

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

5. // 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 3

6. // 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 3 Iterators. Closures.

7. Assembly code 4 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

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

9. Safe 6 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 }

10. Safe 6 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.

11. Safe 6 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.

12. 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.

13. 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 7 Sort left and right in parallel.Caveat: shameless plug for third-party package of mine.

14. 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 8 Data race.

15. 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 8 error: closure requires unique access to `less` but it is already borrowed || parallel_qsort(less) ^~~~~~~~~~~~~~~~~~~~~~~ Data race.

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

17. The Plan 10 1. Hello, world! 2. Structs and such. 3. Threads.

18. 11 Hello, world!

19. Hello, world! 12 smallcultfollowing.com/20151209/ ! Example “Hello World” fn main() { println!(“Hello, world!”); }

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

21. Ownership/Borrowing Memory safety Data-race freedom No need for a runtime 14

22. Ownership/Borrowing Memory safety Data-race freedom No need for a runtime C++ 14

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

24. Ownership 15

25. Ownership 15

26. fn main() { let name = format!(“…”); helper(name); helper(name); } fn helper(name: String) { println!(..); } ! ! ! Ownership 16

28. fn main() { let name = format!(“…”); helper(name); helper(name); } fn helper(name: String) { println!(..); } ! ! ! Ownership Take ownership of a String 16

35. fn main() { let name = format!(“…”); helper(name); helper(name); } fn helper(name: String) { println!(..); } ! ! ! Ownership 16 Error: use of moved value: `name`

36. void main() { Vector name = …; helper(name); helper(name); } void helper(Vector name) { … } ! ! ! “Ownership” in Java 17

38. void main() { Vector name = …; helper(name); helper(name); } void helper(Vector name) { … } ! ! ! “Ownership” in Java Take reference to Vector 17

48. void main() { Vector name = …; helper(name); helper(name); } void helper(Vector name) { … } ! ! ! “Ownership” in Java 17 new Thread(…);

53. Clone 18 fn main() { let name = format!(“…”); helper(name.clone()); helper(name); } fn helper(name: String) { println!(..); } ! ! !

55. Clone 18 fn main() { let name = format!(“…”); helper(name.clone()); helper(name); } fn helper(name: String) { println!(..); } ! ! ! Copy the String

62. Copy (auto-Clone) 19 fn main() { let name = 22; helper(name); helper(name); } fn helper(name: i32) { println!(..); } ! ! !

63. Copy (auto-Clone) 19 fn main() { let name = 22; helper(name); helper(name); } fn helper(name: i32) { println!(..); } ! ! ! i32 is a Copy type

68. 20 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).

69. Exercise: ownership 21 http://smallcultfollowing.com/20151209 Cheat sheet: fn helper(name: String) // takes ownership ! string.clone() // clone the string http://doc.rust-lang.org/std

70. Borrowing 22

71. Borrowing 22

72. Borrowing 22

73. fn helper(name: &String) { println!(..); } ! ! ! fn main() { let name = format!(“…”); helper(&name); helper(&name); } Shared borrow 23

76. fn helper(name: &String) { println!(..); } ! ! ! fn main() { let name = format!(“…”); helper(&name); helper(&name); } Shared borrow Take a reference to a String 23

77. fn helper(name: &String) { println!(..); } ! ! ! fn main() { let name = format!(“…”); helper(&name); helper(&name); } Shared borrow Take a reference to a String 23 Lend the string

87. Shared == Immutable 24 fn helper(name: &String) { println!(“{}”, name); } fn helper(name: &String) { name.push_str(“foo”); }

88. Shared == Immutable 24 fn helper(name: &String) { println!(“{}”, name); } fn helper(name: &String) { name.push_str(“foo”); } OK. Just reads.

89. Shared == Immutable 24 fn helper(name: &String) { println!(“{}”, name); } fn helper(name: &String) { name.push_str(“foo”); } OK. Just reads. Error. Writes.

90. Shared == Immutable 24 fn helper(name: &String) { println!(“{}”, name); } fn helper(name: &String) { name.push_str(“foo”); } OK. Just reads. Error. Writes. error: cannot borrow immutable borrowed content `*name` as mutable name.push_str(“s”); ^~~~

91. Shared == Immutable 24 fn helper(name: &String) { println!(“{}”, name); } fn helper(name: &String) { name.push_str(“foo”); } OK. Just reads. Error. Writes. * Actually: mutation only in controlled circumstances. * error: cannot borrow immutable borrowed content `*name` as mutable name.push_str(“s”); ^~~~

92. fn update(name: &mut String) { name.push_str(“…”); } ! ! ! fn main() { let mut name = …; update(&mut name); println!(“{}”, name); } Mutable borrow 25

94. fn update(name: &mut String) { name.push_str(“…”); } ! ! ! fn main() { let mut name = …; update(&mut name); println!(“{}”, name); } Mutable borrow Take a mutable reference to a String 25

95. fn update(name: &mut String) { name.push_str(“…”); } ! ! ! fn main() { let mut name = …; update(&mut name); println!(“{}”, name); } Mutable borrow Take a mutable reference to a String 25 Lend the string mutably

101. fn update(name: &mut String) { name.push_str(“…”); } ! ! ! fn main() { let mut name = …; update(&mut name); println!(“{}”, name); } Mutable borrow 25 Mutate string in place

107. fn update(name: &mut String) { name.push_str(“…”); } ! ! ! fn main() { let mut name = …; update(&mut name); println!(“{}”, name); } Mutable borrow 25 Prints the updated string.

111. Play time 26http://is.gd/no0tTH

112. .capacity: … .len: 10 fn helper(name: &String) { println!(..); } ! ! ! 27 fn main() name.data fn main() { let name = format!(“…”); helper(&name); helper(&name); } ‘R’ ‘u’ … ‘n’ ‘s’

115. .capacity: … .len: 10 fn helper(name: &String) { println!(..); } ! ! ! 27 fn main() name.data fn helper() name fn main() { let name = format!(“…”); helper(&name); helper(&name); } String owned by somebody else up the stack. ‘R’ ‘u’ … ‘n’ ‘s’

116. .capacity: … .len: 10 fn helper(name: &str) { ! } 28 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”

120. .capacity: … .len: 10 fn helper(name: &str) { ! } 28 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” Subslice of a string owned up the stack

122. .capacity: … .len: 10 fn helper(name: &str) { ! } 28 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” helper(&name[1..]);

123. .capacity: … .len: 10 fn helper(name: &str) { ! } 28 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” helper(&name[1..]); “stacean” 7

127. data len data len String data len capacity String data len capacity ‘R’ ‘u’ … ‘s’‘R’ ‘u’ … ‘s’ 29 “Rustaceans”: &str format!(“Rustaceans”): String …Rustaceans…

132. data len data len String data len capacity String data len capacity ‘R’ ‘u’ … ‘s’‘R’ ‘u’ … ‘s’ 29 “Rustaceans”: &str format!(“Rustaceans”): String …Rustaceans… &’static str

133. data len data len String data len capacity String data len capacity ‘R’ ‘u’ … ‘s’‘R’ ‘u’ … ‘s’ 29 “Rustaceans”: &str format!(“Rustaceans”): String …Rustaceans… &’static str

134. Whither Safety? 30https://www.ﬂickr.com/photos/langtind/2217639550/in/photostream/

135. GC vs C++ vs Rust 31 GC’d language (e.g. Java) One size ﬁts all `void helper(String name)` temporary access? start a thread? store in a static? Rust Temporary references — conﬁned to owner’s scope Data cannot be freed or mutated while reference is live C++ No clear rules Easily invalidated “Don’t make mistakes”

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

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

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

151. .capacity: … .len: 10 name.data ‘R’ ‘u’ … ‘n’ ‘s’ 32 fn main() { let r; { let name = format!(“…”); r = &name; } println!(“{}”, r); } r

160. .capacity: … .len: 10 name.data ‘R’ ‘u’ … ‘n’ ‘s’ 32 fn main() { let r; { let name = format!(“…”); r = &name; } println!(“{}”, r); } r Dangling reference!

161. .capacity: … .len: 10 name.data ‘R’ ‘u’ … ‘n’ ‘s’ 32 fn main() { let r; { let name = format!(“…”); r = &name; } println!(“{}”, r); } r Dangling reference!

162. fn main() { let r; { let name = format!(“…”); r = &name; } println!(“{}”, r); } 33http://is.gd/HJyO7A

163. fn main() { let r; { let name = format!(“…”); r = &name; } println!(“{}”, r); } 33http://is.gd/HJyO7A

164. fn main() { let r; { let name = format!(“…”); r = &name; } println!(“{}”, r); } 33 Lifetime: span of code where reference is used. http://is.gd/HJyO7A

170. fn main() { let r; { let name = format!(“…”); r = &name; } println!(“{}”, r); } 33 ‘l Lifetime: span of code where reference is used. http://is.gd/HJyO7A

171. fn main() { let r; { let name = format!(“…”); r = &name; } println!(“{}”, r); } 33 ‘l Lifetime: span of code where reference is used. Scope of data being borrowed (here, `name`) compared against http://is.gd/HJyO7A

172. ‘s fn main() { let r; { let name = format!(“…”); r = &name; } println!(“{}”, r); } 33 ‘l Lifetime: span of code where reference is used. Scope of data being borrowed (here, `name`) compared against http://is.gd/HJyO7A

173. ‘s fn main() { let r; { let name = format!(“…”); r = &name; } println!(“{}”, r); } 33 ‘l Lifetime: span of code where reference is used. Scope of data being borrowed (here, `name`) compared against http://is.gd/HJyO7A error: `name` does not live long enough r = &name; ^~~~

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

175. 34 use std::thread; ! fn helper(name: &String) { thread::spawn(move || { use(name); }); } `name` can only be used within this fn

178. 34 use std::thread; ! fn helper(name: &String) { thread::spawn(move || { use(name); }); } `name` can only be used within this fn Might escape the function!

179. 34 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

180. 34 use std::thread; ! fn helper(name: &String) { thread::spawn(move || { use(name); }); } `name` can only be used within this fn error: the type `[…]` does not fulfill the required lifetime thread::spawn(move || { ^~~~~~~~~~~~~ note: type must outlive the static lifetime

183. 34 use std::thread; ! fn helper(name: &String) { thread::spawn(move || { use(name); }); } `name` can only be used within this fn 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

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

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

186. Dangers of mutation 35 let mut buffer: String = format!(“Rustacean”); let slice = &buffer[1..]; buffer.push_str(“s”); println!(“{:?}”, slice); ‘R’ ‘u’ … ‘n’ String data len capacity

189. Dangers of mutation 35 let mut buffer: String = format!(“Rustacean”); let slice = &buffer[1..]; buffer.push_str(“s”); println!(“{:?}”, slice); ‘R’ ‘u’ … ‘n’ String data len capacity data len

192. Dangers of mutation 35 let mut buffer: String = format!(“Rustacean”); let slice = &buffer[1..]; buffer.push_str(“s”); println!(“{:?}”, slice); ‘R’ ‘u’ … ‘n’ String data len capacity ‘R’ ‘u’ … ‘n’ data len

193. Dangers of mutation 35 let mut buffer: String = format!(“Rustacean”); let slice = &buffer[1..]; buffer.push_str(“s”); println!(“{:?}”, slice); ‘R’ ‘u’ … ‘n’ String data len capacity ‘R’ ‘u’ … ‘n’ data len ‘s’

194. Dangers of mutation 35 let mut buffer: String = format!(“Rustacean”); let slice = &buffer[1..]; buffer.push_str(“s”); println!(“{:?}”, slice); String data len capacity ‘R’ ‘u’ … ‘n’ data len ‘R’ ‘u’ … ‘n’ ‘s’

197. Dangers of mutation 35 let mut buffer: String = format!(“Rustacean”); let slice = &buffer[1..]; buffer.push_str(“s”); println!(“{:?}”, slice); String data len capacity ‘R’ ‘u’ … ‘n’ data len ‘R’ ‘u’ … ‘n’ ‘s’ Dangling reference!

198. Dangers of mutation 35 let mut buffer: String = format!(“Rustacean”); let slice = &buffer[1..]; buffer.push_str(“s”); println!(“{:?}”, slice); String data len capacity ‘R’ ‘u’ … ‘n’ data len ‘R’ ‘u’ … ‘n’ ‘s’ Dangling reference!

199. Rust solution 36 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.

200. Dangers of mutation 37 fn main() { let mut buffer: String = format!(“Rustacean”); let slice = &buffer[1..]; buffer.push_str(“s”); println!(“{:?}”, slice); } http://is.gd/MCPVWg

201. Dangers of mutation 37 fn main() { let mut buffer: String = format!(“Rustacean”); let slice = &buffer[1..]; buffer.push_str(“s”); println!(“{:?}”, slice); } http://is.gd/MCPVWg

202. Dangers of mutation 37 fn main() { let mut buffer: String = format!(“Rustacean”); let slice = &buffer[1..]; buffer.push_str(“s”); println!(“{:?}”, slice); } Borrow “locks” `buffer` until `slice` goes out of scope http://is.gd/MCPVWg

203. Dangers of mutation 37 fn main() { let mut buffer: String = format!(“Rustacean”); let slice = &buffer[1..]; buffer.push_str(“s”); println!(“{:?}”, slice); } Borrow “locks” `buffer` until `slice` goes out of scope http://is.gd/MCPVWg

204. Dangers of mutation 37 fn main() { let mut buffer: String = format!(“Rustacean”); let slice = &buffer[1..]; buffer.push_str(“s”); println!(“{:?}”, slice); } Borrow “locks” `buffer` until `slice` goes out of scope error: cannot borrow `buffer` as mutable because it is also borrowed as immutable buffer.push_str(“s”); ^~~~~~ http://is.gd/MCPVWg

205. Dangers of mutation 37 fn main() { let mut buffer: String = format!(“Rustacean”); let slice = &buffer[1..]; buffer.push_str(“s”); println!(“{:?}”, slice); } Borrow “locks” `buffer` until `slice` goes out of scope error: cannot borrow `buffer` as mutable because it is also borrowed as immutable buffer.push_str(“s”); ^~~~~~ http://is.gd/MCPVWg

206. 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”); } 38

207. 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”); } 38 Borrow “locks” `buffer` until `slice` goes out of scope

210. 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”); } 38 Borrow “locks” `buffer` until `slice` goes out of scope OK: `buffer` is not borrowed here

211. Exercise: borrowing 39 http://smallcultfollowing.com/20151209 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 http://doc.rust-lang.org/std

212. 40 Structs and such

213. 41 Shop till you drop! By QuentinUK (Own work), via Wikimedia Commons

214. Declaring a structure 42 struct Store { name: String, prices: Vec<Item>, }

223. Declaring a structure 42 struct Store { name: String, prices: Vec<Item>, } name prices

224. Declaring a structure 42 struct Store { name: String, prices: Vec<Item>, } name prices .length .data .capacity .length .data .capacity

225. Declaring a structure 42 struct Store { name: String, prices: Vec<Item>, } Item name prices ‘R’ ‘u’ … ‘n’ Item Item .length .data .capacity .length .data .capacity

226. Declaring a structure 42 struct Store { name: String, prices: Vec<Item>, } Item name prices ‘R’ ‘u’ … ‘n’ Item Item .length .data .capacity .length .data .capacity

227. 43 struct Item { name: &’static str, price: f32, } Other fundamental types f32 f64 ! ! i8 i16 i32 i64 isize u8 u16 u32 u64 usize &str &[T] ! ! ﬂoats signed unsigned slices

240. Methods 44 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 } }

243. Methods 44 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 } } store.add_item(…); // must be let mut store.price(…); // let OR let mut

245. Methods 44 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 } } store.add_item(…); // must be let mut store.price(…); // let OR let mut itself an &mut method

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

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

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

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

265. Return is optional 46 struct Store { .. } ! impl Store { fn new(name: String) -> Store { Store { name: name, items: vec![], } } } No `;` on last expression: “return this value”

266. Options and Enums 47 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

277. For Loops 48 fn main() { let v = vec![format!(“Alpha”), format!(“Beta”), format!(“Gamma”)]; for s in v { println!(“{:?}”, s); } } http://is.gd/6kJc0O “Alpha” “Beta” “Gamma” v: s:

281. For Loops 48 fn main() { let v = vec![format!(“Alpha”), format!(“Beta”), format!(“Gamma”)]; for s in v { println!(“{:?}”, s); } } http://is.gd/6kJc0O “Alpha” “Beta” “Gamma” v: s: Vec<String>

282. For Loops 48 fn main() { let v = vec![format!(“Alpha”), format!(“Beta”), format!(“Gamma”)]; for s in v { println!(“{:?}”, s); } } http://is.gd/6kJc0O “Alpha” “Beta” “Gamma” v: s: String Vec<String>

285. For Loops 48 fn main() { let v = vec![format!(“Alpha”), format!(“Beta”), format!(“Gamma”)]; for s in v { println!(“{:?}”, s); } } http://is.gd/6kJc0O “Beta” “Gamma” v: s:

286. For Loops 48 fn main() { let v = vec![format!(“Alpha”), format!(“Beta”), format!(“Gamma”)]; for s in v { println!(“{:?}”, s); } } http://is.gd/6kJc0O “Beta” “Gamma” v: s:

287. For Loops 48 fn main() { let v = vec![format!(“Alpha”), format!(“Beta”), format!(“Gamma”)]; for s in v { println!(“{:?}”, s); } } http://is.gd/6kJc0O “Gamma” v: s:

288. For Loops 49 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” v:

290. For Loops 49 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” v: &Vec<String>

291. For Loops 49 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” v: &String &Vec<String>

293. For Loops 49 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” v: s:

296. For Loops 49 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” v: s: &mut Vec<String> &mut String

298. Exercise: structs 50 http://smallcultfollowing.com/20151209 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 … { … } http://doc.rust-lang.org/std

299. 51 Threading

300. Multiparadigm 52 Multiparadigm

301. Multiparadigm 52 Multiparadigm message-passing

302. Multiparadigm 52 Multiparadigm mutable shared memorymessage-passing

303. 53

304. 53 $5.0 $25.5 $81.5 ——— $112.0

305. 53 $5.0 $25.5 $81.5 ——— $112.0 $5.0 $20.5 $81.5 ——— $107.0

306. 53 $5.0 $25.5 $81.5 ——— $112.0 $5.0 $20.5 $81.5 ——— $107.0 $5.0 $23.5 XXX ——— XXX

307. 53 $5.0 $25.5 $81.5 ——— $112.0 $5.0 $20.5 $81.5 ——— $107.0 $5.0 $23.5 XXX ——— XXX

308. 54 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; } _ => { } } }

324. 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; } _ => { } } } 55

328. 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); } 56

335. 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); } 56 Closure takes ownership of variables it uses.

336. 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); } 56 Closure takes ownership of variables it uses. Variables used by this closure.

337. 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); } 56 Closure takes ownership of variables it uses. Variables used by this closure.

339. 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); } 56 Handle to the thread we spawned.

341. Closure body can produce a result, here a (String, f32). 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); } 56

345. 57 let handle = thread::spawn(…);

346. 57 let handle = thread::spawn(…);

347. 57 let handle = thread::spawn(…); … // stuff in parallel // with new thread

348. 57 let handle = thread::spawn(…); … // stuff in parallel // with new thread let (name, sum) = handle.join().unwrap();

349. 57 let handle = thread::spawn(…); … // stuff in parallel // with new thread let (name, sum) = handle.join().unwrap();

350. 57 let handle = thread::spawn(…); … // stuff in parallel // with new thread let (name, sum) = handle.join().unwrap(); Wait for thread to ﬁnish and get return value.

351. 57 let handle = thread::spawn(…); … // stuff in parallel // with new thread let (name, sum) = handle.join().unwrap(); Wait for thread to ﬁnish and get return value. Result<(String, f32), Error>

352. 57 let handle = thread::spawn(…); … // stuff in parallel // with new thread let (name, sum) = handle.join().unwrap(); Wait for thread to ﬁnish and get return value. Thread may have panicked. Propagate.

353. 57 let handle = thread::spawn(…); … // stuff in parallel // with new thread let (name, sum) = handle.join().unwrap(); Wait for thread to ﬁnish and get return value. Thread may have panicked. Propagate.Result of thread.

354. 58 let shopping_list = vec![…]; let mut handles = vec![]; for store in stores { handles.push( thread::spawn(move || { let sum = …; (store.name, sum) }); } ! for handle in handles { let (name, sum) = handle.join().unwrap(); // find best price }

369. 59 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); }

370. 59 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); } Variables used by this closure.

375. 59 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()`?

376. 59 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()`?

377. 60 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); }

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

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

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

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

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

400. Arc => Immutable 62 use std::sync::Arc; let shopping_list: Vec<ShoppingList> = …; let arc1 = Arc::new(shopping_list); let data = &mut arc1[0]; http://is.gd/nP3Pvb

401. Arc => Immutable 62 use std::sync::Arc; let shopping_list: Vec<ShoppingList> = …; let arc1 = Arc::new(shopping_list); let data = &mut arc1[0]; http://is.gd/nP3Pvb

402. Arc => Immutable 62 use std::sync::Arc; let shopping_list: Vec<ShoppingList> = …; let arc1 = Arc::new(shopping_list); let data = &mut arc1[0]; <anon>:6:21: 6:24 error: cannot borrow immutable borrowed content as mutable <anon>:6 let data = &mut arc[0]; ^~~ http://is.gd/nP3Pvb

403. 63 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); }

421. 63 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!

422. Channels 64

423. 65 Joining a thread allows thread to send one result. What if we wanted multiple results?

429. 65 Joining a thread allows thread to send one result. What if we wanted multiple results? Or if we wanted a response?

430. 65 Joining a thread allows thread to send one result. What if we wanted multiple results? Or if we wanted a response?

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

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

435. rx tx fn parent() { let (tx, rx) = channel(); spawn(move || {…}); let m = rx.recv().unwrap(); } 66 move || { let m = Message::new(); … tx.send(m).unwrap(); }

436. rx tx fn parent() { let (tx, rx) = channel(); spawn(move || {…}); let m = rx.recv().unwrap(); } 66 move || { let m = Message::new(); … tx.send(m).unwrap(); }

437. rx tx tx fn parent() { let (tx, rx) = channel(); spawn(move || {…}); let m = rx.recv().unwrap(); } 66 move || { let m = Message::new(); … tx.send(m).unwrap(); }

438. rx tx tx fn parent() { let (tx, rx) = channel(); spawn(move || {…}); let m = rx.recv().unwrap(); } 66 move || { let m = Message::new(); … tx.send(m).unwrap(); }

439. MessageMessage rx tx tx m fn parent() { let (tx, rx) = channel(); spawn(move || {…}); let m = rx.recv().unwrap(); } 66 move || { let m = Message::new(); … tx.send(m).unwrap(); }

440. MessageMessage rx tx tx m fn parent() { let (tx, rx) = channel(); spawn(move || {…}); let m = rx.recv().unwrap(); } 66 move || { let m = Message::new(); … tx.send(m).unwrap(); }

441. Message Message rx tx tx m fn parent() { let (tx, rx) = channel(); spawn(move || {…}); let m = rx.recv().unwrap(); } 66 move || { let m = Message::new(); … tx.send(m).unwrap(); }

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

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

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

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

458. Locks 68

459. 69 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

460. 69 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

461. 0 69 fn sync_inc(counter: &Arc<Mutex<i32>>) { let mut data = counter.lock().unwrap(); *data += 1; } counter https://commons.wikimedia.org/wiki/File:No-DRM_lock.svg

464. 0 69 fn sync_inc(counter: &Arc<Mutex<i32>>) { let mut data = counter.lock().unwrap(); *data += 1; } counter data https://commons.wikimedia.org/wiki/File:No-DRM_lock.svg

467. 0 69 fn sync_inc(counter: &Arc<Mutex<i32>>) { let mut data = counter.lock().unwrap(); *data += 1; } counter data https://commons.wikimedia.org/wiki/File:No-DRM_lock.svg 1

470. 0 69 fn sync_inc(counter: &Arc<Mutex<i32>>) { let mut data = counter.lock().unwrap(); *data += 1; } counter https://commons.wikimedia.org/wiki/File:No-DRM_lock.svg 1

475. Exercise: threads 70 http://smallcultfollowing.com/20151209 Cheat sheet: let (name, sum) = thread.join().unwrap(); http://doc.rust-lang.org/std 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();

476. Plea for help 71 Please ﬁll out the feedback form found at http://smallcultfollowing.com/20151209

477. 72

478. 72 Thanks for listening!

Rust Mozlando Tutorial

More Related Content

What's hot (20)

Similar to Rust Mozlando Tutorial (20)

Recently uploaded (20)

Rust Mozlando Tutorial