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 */);

Rust Mozlando Tutorial

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Ähnlich wie Rust Mozlando Tutorial

Ähnlich wie Rust Mozlando Tutorial (20)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

Rust Mozlando Tutorial