Rust Advanced Topics

Transcription

1 Rust Advanced Topics Adapted from Generic Functions 1. fn takes_anything<t>(thing: T) -> T { 2. thing 3. } 4. fn main() { 5. let x = takes_anything(4); 6. let y = takes_anything(4.5); 7. let z = takes_anything(true); 8. let a = takes_anything(string::from("hello")); 9. println!("{}\n{}\n{}\n{}", x, y, z, a); 10.} 1

2 Generic Functions with Bounds 1. fn prints_anything<t: Debug>(thing: T) { 2. println!("{:?}", thing); 3. } 4. fn prints_anything<t>(thing: T) 5. where T: Debug { 6. println!("{:?}", thing); 7. } Generic Structs 1. struct Point<Precision> { 2. x: Precision, 3. y: Precision 4. } 5. fn main() { 6. let point = Point { x: 1_u32, y: 2 }; 7. let point: Point<i32> = Point { x: 1, y: 2 }; 8. } Rust finds the types of all variables and generics with sufficient information. 2

3 Generic Enums 1. enum Either<T, X> { 2. Left(T), 3. Right(X) 4. } What can you do with an Either? 5. fn main() { 6. let alternative: Either<i32, f64> = Either::Left(123); 7. } Option (the most important generic enum) 1. enum Option<T> { 2. Some(T), 3. None 4. } Part of the standard library and automatically made available for use. 5. fn main() { 6. let mut args = std::env::args(); 7. println!("{:?} {:?}", args.nth(0), args.nth(1)) 8. } 3

4 Results (the second most important enum) 1. enum Result<T, E> { 2. Ok(T), 3. Err(E) 4. } Err(Error { repr: Os { code: 2, message: "No such file or directory" } }) 5. fn main() { 6. let file = std::fs::file::open("i don't exist!"); 7. println!("{:?}", file); 8. } Why are Options useful? 1. fn main() { 2. let mut args = std::env::args(); 3. match args.nth(1) { 4. Some(arg) => { println!("argument: {}", arg)}, 5. None => { println!("no Argument") } 6. } 7. } 4

5 Why are Options useful? 1. fn main() { 2. let mut args = std::env::args(); 3. if let Some(arg) = args.nth(1) { 4. println!("argument: {}", arg); 6. } Why are Results useful? 1. fn main() { 2. let maybe_file = std::fs::file::open("not there!"); 3. match maybe_file { 4. Ok(f) => { println!("file opened! Debug: {:?}", f) }, 5. Err(e) => { println!("file not opened!! Error: {:?}", e) } 6. } 7. } 5

6 Remember, you must cover all variants! 1. fn main() { 2. let maybe_file = std::fs::file::open("not there!"); 3. match maybe_file { 4. Err(e) => { println!("error: {:?}", e) } 6. } Remember, you must cover all variants! 1. fn main() { 2. let maybe_file = std::fs::file::open("not there!"); 3. match maybe_file { 4. Err(e) => { println!("error: {:?}", e) } 5. _ => {} 6. } 7. } 6

7 Ownership Ownership is the basis for the memory management of Rust. 1. Every value has exactly one owner 2. Ownership can be passed on (given away) 3. The owner is responsible for dropping/de-alocating/removing data 4. The owner has all powers over the data and can mutate it These rules: are fundamental to Rusts type system are enforced at compile time are practical in many other ways 1. #[derive(debug)] 2. struct Dot { Ownership transferred from here to here do to this line. 7. let dot = Dot { x: 1, y: 2 }; 8. pacman(dot); 9. } 10.fn pacman(dot: Dot) { 11. println!("eating {:?}", dot); 12.} 7

8 1. #[derive(debug)] 2. struct Dot { Ownership transferred from here to here do to this line. 7. let dot = Dot { x: 1, y: 2 }; 8. pacman(dot); 9. pacman(dot); 10.} 11.fn pacman(dot: Dot) { 12. println!("eating {:?}", dot); 13.} 1. #[derive(debug)] 2. struct Dot { Ownership transferred from here to here do to this line. 7. let dot = Dot { x: 1, y: 2 }; 8. pacman(dot); 9. pacman(dot); 10.} pacman consumes dot. The value cannot be used anymore. 11.fn pacman(dot: Dot) { 12. println!("eating {:?}", dot); 13.} 8

9 1. #[derive(debug, Clone)] 2. struct Dot { 7. let dot = Dot { x: 1, y: 2 }; 8. pacman(dot.clone()); 9. pacman(dot); 10.} 11.fn pacman(dot: Dot) { 12. println!("eating {:?}", dot); 13.} Better to be explicit than implicit! C++ does this clone for you! 1. #[derive(debug, Clone, Copy)] 2. struct Dot { 7. let dot = Dot { x: 1, y: 2 }; 8. pacman(dot); 9. pacman(dot); 10.} 11.fn pacman(dot: Dot) { 12. println!("eating {:?}", dot); 13.} Rust will let you make this the default behavior! Copy is meant for data that can be quickly copied. 9

10 Borrowing (instead of transferring ownership) 1. What you own, you can borrow 2. Reuse of data after a function call is not possible with ownership if the called function doesn't return the ownership to the value again. 1. #[derive(debug)] 2. struct Point { 7. let mut point = Point { x: 1, y: 2 }; 8. inspect(&point); 9. point.x = 2; 10. inspect(&point); 11. } 12. fn inspect(p: &Point) { 13. println!("{:?}", p); 14. } What if we want to change the borrowed value? 10

11 1. #[derive(debug)] 2. struct Point { 7. let mut point = Point { x: 1, y: 2 }; 8. inspect(&point); 9. move_point(&mut point, 3, 3); 10. inspect(&point); 11. } Mutable borrows are exclusive! 12. fn move_point(p: &mut Point, x: i32, y: i32) { 13. p.x = x; p.y = y; 14. } 15. fn inspect(p: &Point) { println!("{:?}", p); } 1. #[derive(debug)] 2. struct Point { fn main() { 8. let mut point = Point { x: 1, y: 2 }; 9. inspect(&point); 10. // move_point(&mut point, 3, 3); 11. let point2 = move_point(&mut point, 3, 3); 12. inspect(&point); 13. } fn move_point(p: &mut Point, x: i32, y: i32) -> &Point { 16. p.x = x; p.y = y; 17. p 18. } fn inspect(p: &Point) { 21. println!("{:?}", p); 22. } What happens here? 11

12 Borrowing Rules Values can be: 1. Borrowed immutably as often as you'd like 2. Or mutably exactly once 1. fn push_all(on: &mut Vec<u8>, from: &Vec<u8>) { 2. // What is the problem with this function? 3. } Borrowing obeys lexical rules! 1. fn main() { 2. let mut data = vec!['a', 'b', 'c']; 3. { 4. let slice = &mut data[..]; 5. do_something(slice); 6. } 7. data.push('d'); 8. data.push('e'); 9. data.push('f'); 10. } 11. fn do_something(slice: &[char]) { 12. // Do something that mutates slice 13. } 12

13 Pillars of Rust A productive systems programming language that adheres to the following: Memory Safety without Garbage Collection Concurrency without Data Races Abstraction without Overhead Stability without Stagnation 13