Rust Mozlando Tutorial

1.
1 Hack without fear! NicholasMatsakis

2.
2 Systems programming withoutthe hassle

3.
2 Systems programming withoutthe hassle crashes heisenbugs fear

4.
2 Systems programming withoutthe hassle crashes heisenbugs fear Parallel!

5.
// sums allthe 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 allthe 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: &mutVec<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: &mutVec<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: &mutVec<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 Rusthas 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 “HelloWorld” 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 aruntime 14

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

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

24.
Ownership 15

25.
Ownership 15

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

27.

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

29.

30.

31.

32.

33.

34.

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

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

37.

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

39.

40.

41.

42.

43.

44.

45.

46.

47.

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

49.

50.

51.

52.

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

54.

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

56.

57.

58.

59.

60.

61.

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

64.

65.

66.

67.

68.
20 Non-copyable: Values movefrom 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: fnhelper(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

74.

75.

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

78.

79.

80.

81.

82.

83.

84.

85.

86.

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

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

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

90.
Shared == Immutable 24 fnhelper(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 fnhelper(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: &mutString) { name.push_str(“…”); } ! ! ! fn main() { let mut name = …; update(&mut name); println!(“{}”, name); } Mutable borrow 25

93.

94.
fn update(name: &mutString) { 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: &mutString) { 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

96.

97.

98.

99.

100.

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

102.

103.

104.

105.

106.

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

108.

109.

110.

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

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

113.

114.

115.
.capacity: … .len: 10 fnhelper(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 fnhelper(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”

117.

118.

119.

120.
.capacity: … .len: 10 fnhelper(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

121.

122.
.capacity: … .len: 10 fnhelper(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 fnhelper(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

124.

125.

126.

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…

128.

129.

130.

131.

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”

136.

137.

138.

139.

140.

141.

142.

143.

144.

145.

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

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

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

149.

150.

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

152.

153.

154.

155.

156.

157.

158.

159.

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() { letr; { let name = format!(“…”); r = &name; } println!(“{}”, r); } 33http://is.gd/HJyO7A

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

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

165.

166.

167.

168.

169.

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

171.
fn main() { letr; { 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() { letr; { 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() { letr; { 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

176.

177.

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

181.

182.

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 letmut buffer: String = format!(“Rustacean”); let slice = &buffer[1..]; buffer.push_str(“s”); println!(“{:?}”, slice);

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

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

187.

188.

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

190.

191.

192.
Dangers of mutation 35 letmut 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 letmut 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 letmut 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’

195.

196.

197.
Dangers of mutation 35 letmut 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 letmut 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:! ! Creatinga 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 fnmain() { 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 fnmain() { 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 fnmain() { 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 fnmain() { 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 fnmain() { 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 fnmain() { 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() { letmut 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() { letmut 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

208.

209.

210.
fn main() { letmut 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 youdrop! By QuentinUK (Own work), via Wikimedia Commons

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

215.

216.

217.

218.

219.

220.

221.

222.

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

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

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

226.
Declaring a structure 42 structStore { 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

228.

229.

230.

231.

232.

233.

234.

235.

236.

237.

238.

239.

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 } }

241.

242.

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

244.

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

246.

247.

248.

249.

250.

251.

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)

255.

256.

257.

258.

259.

260.

261.

262.

263.

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

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

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

267.

268.

269.

270.

271.

272.

273.

274.

275.

276.

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:

278.

279.

280.

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>

283.

284.

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:

289.

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>

292.

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:

294.

295.

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

297.

298.
Exercise: structs 50 http://smallcultfollowing.com/20151209 Implement fn total_price(..) Cheatsheet: 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; } _ => { } } }

309.

310.

311.

312.

313.

314.

315.

316.

317.

318.

319.

320.

321.

322.

323.

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

325.

326.

327.

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

329.

330.

331.

332.

333.

334.

335.
use std::thread; … let muthandles = 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 muthandles = 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 muthandles = 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.

338.

339.
use std::thread; … let muthandles = 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.

340.

341.
Closure body can producea 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

342.

343.

344.

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 }

355.

356.

357.

358.

359.

360.

361.

362.

363.

364.

365.

366.

367.

368.

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.

371.

372.

373.

374.

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); }

378.

379.

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];

381.

382.

383.

384.

385.

386.

387.

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

389.

390.

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

392.

393.

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

396.

397.

398.

399.

400.
Arc => Immutable 62 usestd::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 usestd::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 usestd::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); }

404.

405.

406.

407.

408.

409.

410.

411.

412.

413.

414.

415.

416.

417.

418.

419.

420.

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 threadallows thread to send one result. What if we wanted multiple results?

424.

425.

426.

427.

428.

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

430.
65 Joining a threadallows 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

433.

434.

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(); }

442.

443.

444.

445.

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

449.

450.

451.

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

453.

454.

455.

456.

457.

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

462.

463.

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

465.

466.

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

468.

469.

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

471.

472.

473.

474.

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

Similar to Rust Mozlando Tutorial

Recently uploaded

Rust Mozlando Tutorial