Въведение в Rust (OpenFest 2017)

Transcript

1. Въведение в ust
2. Какво е ust?
3. Rust е low-level • Без GC • Почти нулев runtime • Съвместим със C • Бърз
4. Rust е high-level • Пакети • Тестване • Елементи от функционалното програмиране • Елементи от ООП
5. Rust е (доста) безопасен
6. Rust е (доста) безопасен • Няма null • Не позволява висящи pointer-и • Не позволява double free • Силна статична типова система • Не позволява събирането на flot + int • The Big Deol
7. Здравейте, аз съм @AndrewRadev • Прост човек. • Рубист.
8. Rust е много неща
9. Скучни неща
10. fn main() { let x: i32 = 42; let y: i32 = x; println!("x = {}", x); println!("y = {}", y); } // =================== x = 42 y = 42
11. fn main() { let x: char = 'ь'; let y: char = x; println!("x = {}", x); println!("y = {}", y); } // =================== x = ь y = ь
12. fn main() { let x: String = String::from("forty-two"); let y: String = x; println!("x = {}", x); println!("y = {}", y); } // =================== error[E0382]: use of moved value: `x` --> src/main.rs:5:24 | 3 | let y: String = x; | - value moved here 4 | 5 | println!("x = {}", x); | ^ value used here after move | = note: move occurs because `x` has type `std::string::String`, which does not implement the `Copy` trait
13. Move semantics
14. fn main() { let x = String::from("forty-two"); let y = x; }
15. Ownership
16. fn main() { let x = String::from("forty-two"); if 1 == 2 { let local = String::new("Inconceivable!"); println!("{}", local); } // local се деалокира println!("{}", x); } // x се деалокира
17. fn tell_everybody(news: String) { println!("Ае, хора, {}", news); } fn main() { let news = String::from("Извънземните нападат!!!"); tell_everybody(news); // println!("{}", news); // => компилационна грешка }
18. fn tell_everybody(news: String) -> String { println!("Ае, хора, {}", news); news } fn main() { let news = String::from("AI превзе света!!!"); let news_i_got_back = tell_everybody(news); println!("{}", news_i_got_back); // println!("{}", news); // => компилаторна грешка }
19. fn tell_everybody(news: &String) { println!("Ае, хора, {}", news); } fn main() { let news = String::from("50% намаление на репички!!!"); tell_everybody(&news); println!("{}", news); }
20. Borrow checker • Няма невалидни references • Само един mutable ref, или • Колкото си искаме immutable refs
21. fn main() { let mut fact: String = String::from("Компилатора знае две"); fact.push_str("и двеста"); println!("{}", &fact); } // =================== Компилатора знае две и двеста
22. fn main() { let mut fact: String = String::from("Компилатора знае две"); let ending: &str = "и двеста"; fact.push_str(ending); println!("{}", &fact); } // =================== Компилатора знае две и двеста
23. fn main() { let mut fact: String = String::from("Компилатора знае две"); let ending: &str = "и двеста"; fact.push_str(ending); println!("{}", fact); let also_true: &str = &fact[0..32]; println!("{}", also_true); } // =================== Компилатора знае две и двеста Компилатора знае
24. fn main() { let mut fact: String = String::from("Компилатора знае две"); let ending: &str = "и двеста"; String::push_str(&mut fact, ending); let also_true: &str = &fact[0..32]; println!("{}", also_true); } // =================== Компилатора знае
25. fn main() { let mut fact: String = String::from("Компилатора знае две"); let ending: &str = "и двеста"; let fact_reference = &mut fact; String::push_str(fact_reference, ending); let also_true: &str = &fact[0..32]; println!("{}", also_true); } // =================== error[E0502]: cannot borrow `fact` as immutable because it is also borrowed as mutable --> src/main.rs:8:28 | 5 | let fact_reference = &mut fact; | ---- mutable borrow occurs here ... 8 | let also_true: &str = &fact[0..32]; | ^^^^ immutable borrow occurs here 9 | println!("{}", also_true); 10 | } | - mutable borrow ends here
26. fn main() { let mut fact = String::from("Компилатора знае две"); let also_true = &fact[0..32]; // NOPE fact.push_str(" и двеста"); }
27. fn main() { let mut fact = String::from("Компилатора знае две"); { let also_true = &fact[0..32]; // ... } fact.push_str(" и двеста"); }
28. { Scope }
29. fn main() { let lines = { let mut l = Vec::with_capacity(4); l.push("Roses are #FF0000,"); l.push("Violets are #0000FF"); l.push("Such a boring example"); l.push("What is wrong with you?"); l }; for line in lines { println!("{}", line); } }
30. fn main() { let lines = vec![ "Roses are #FF0000", "Violets are #0000FF", "Such a boring example", "What is wrong with you?", ]; for line in lines { println!("{}", line); } }
31. Macros!
33. fn main() { let lines = vec![ "Roses are #FF0000", "The TARDIS is #0000FF", "A tiny bit better", "With that callback to Doctor Who", ]; for line in lines { println!("{}", line); } }
34. fn add(a: i32, b: i32) -> i32 { a + b } fn main() { let boring_result = add(3, 4); println!("Your boring result: {}", boring_result); } // =================== Your boring result: 7
35. fn add(a: i32, b: i32) -> i32 { a + b } fn main() { let boring_result = add(3.0, 4.0); println!("Your boring result: {}", boring_result); } // =================== error[E0308]: mismatched types --> src/main.rs:6:29 | 6 | let boring_result = add(3.0, 4.0); | ^^^ expected i32, found floating-point variable | = note: expected type `i32` found type `{float}`
36. <Generics>
37. fn add<T>(a: T, b: T) -> T { a + b } fn main() { let boring_result = add(3.0, 4.0); println!("Your boring result: {}", boring_result); } // =================== error[E0369]: binary operation `+` cannot be applied to type `T` --> src/main.rs:2:5 | 2 | a + b | ^^^^^ | = note: an implementation of `std::ops::Add` might be missing for `T`
38. Traits
39. use std::ops::Add; fn add<T: Add>(a: T, b: T) -> T::Output { a + b } fn main() { let boring_result = add(3.0, 4.0); println!("Your boring result: {}", boring_result); } // =================== Your boring result: 7.0
40. trait Add<RHS = Self> { type Output; fn add(self, rhs: RHS) -> Self::Output; }
41. trait Add<RHS = Self> { type Output; fn add(self, rhs: RHS) -> Self::Output; } impl Add< > for VimUser { type Output = fn add(self, rhs: ) -> Self::Output { } }
42. trait Add<RHS = Self> { type Output; fn add(self, rhs: RHS) -> Self::Output; } impl Add<EmacsUser> for VimUser { type Output = fn add(self, rhs: EmacsUser) -> Self::Output { } }
43. trait Add<RHS = Self> { type Output; fn add(self, rhs: RHS) -> Self::Output; } impl Add<EmacsUser> for VimUser { type Output = ProductiveConversation<MutualRespect>; fn add(self, rhs: EmacsUser) -> Self::Output { // Долу стереотипите! } }
44. Monomorphisation
45. use std::fmt::Display; fn main() { let displayable: &Display = &5; println!("{}", displayable); }
46. use std::fmt::Display; fn main() { let displayable: Vec<&Display> = vec![&5, &"baba" as &Display, &3.14]; for d in displayable.iter() { println!("{}", d); } } // The magic of vtables
47. Generics vs Trait Objects
48. Zero-cost abstraction C++ implementations obey the zero-overhead principle: What you don’t use, you don’t pay for [Stroustrup, 1994]. And further: What you do use, you couldn’t hand code any better. – Stroustrup
49. fn main() { let potato = " Любов, любов, варен картоф, разрежеш го, а той суров. "; println!("--\n{}\n--", potato); } // =================== --- Любов, любов, варен картоф, разрежеш го, а той суров. ---
50. fn main() { let potato = " Любов, любов, варен картоф, разрежеш го, а той суров. "; let lines = potato. trim(). lines(). map(|l| l.trim()); println!("---"); for line in lines { println!("{}", line); } println!("---"); } // =================== --- Любов, любов, варен картоф, разрежеш го, а той суров. ---
51. fn main() { let potato = " Любов, любов, варен картоф, разрежеш го, а той суров. "; let lines = potato. trim(). lines(). map(|l| l.trim()); println!("+-------------------------------+"); for line in lines { println!("| {}\t|", line); } println!("+-------------------------------+"); } // =================== +-------------------------------+ | Любов, любов, варен картоф, | | разрежеш го, а той суров. | +-------------------------------+
52. let lines = potato. trim(). lines(). map(|l| l.trim()); for line in lines { println!("{}", line); }
53. let lines = potato. // => &str trim(). lines(). map(|l| l.trim()); for line in lines { println!("{}", line); } fn trim(&self) -> &str { // // " Любов, ала-бала, картоф " // ^___________________________^ -> текущия &str // // " Любов, ала-бала, картоф " // ^_____________________^ -> върнатия &str }
54. let lines = potato. trim(). lines(). // => Lines (std::str::Lines) map(|l| l.trim()); for line in lines { println!("{}", line); } // нещо като... impl Iterator for Lines { type Item = &str; fn next() -> Option<Item> { // Some("Любов, любов...") // Some("Картоф, картоф...") // None } } enum Option<T> { Some(T), None, }
55. let lines = potato. trim(). lines(). map(|l| l.trim()); for line in lines { println!("{}", line); }
56. let lines = potato. trim(). lines(). map(|l| l.trim()); // => std::iter::Map<std::str::Lines<'_>, [closure@src/main.rs:10:13: 10:25]> for line in lines { println!("{}", line); }
57. let lines = potato. trim(). lines(). map(|l| l.trim()); for line in lines { println!("{}", line); } |l| l.trim() // се превежда до нещо като... struct PotatoClosure { // ... прихванати променливи } impl Fn(&str) -> &str for PotatoClosure { fn call(&self, l: &str) -> &str { l.trim() } }
58. let lines = potato. trim(). lines(). map(|l| l.trim()); for line in lines { println!("{}", line); }
59. fn main() { let potato = " Любов, любов, варен картоф, разрежеш го, а той суров. "; let lines = potato. trim(). lines(). map(|l| l.trim()); for line in lines { println!("{}", line); } }
60. fn main() { let potato = String::from(" Любов, любов, варен картоф, разрежеш го, а той суров. "); let lines = potato. as_str(). trim(). lines(). map(|l| l.trim()); for line in lines { println!("{}", line); } }
61. Zero-cost abstraction
62. Error handling
63. use std::fs::File; use std::io::Read; fn main() { let mut file = File::open("boring.txt"); let mut contents = String::new(); file.read_to_string(&mut contents); println!("{}", contents); } //==================== error[E0599]: no method named `read_to_string` found for type `std::result::Result<std::fs::File, std::io::Error>` in the current scope --> src/main.rs:7:7 | 7 | f.read_to_string(&mut contents); | ^^^^^^^^^^^^^^ error: aborting due to previous error
64. enum Result<T, E> { Ok(T), Err(E), } // Error handling in C be like: open("excellent_file.txt", "r") // => 15 open("broken_file.txt") // -1 errno // -17 // In Rust: File::open("excellent_file.txt") // => Ok(File) File::open("broken_file.txt") // => Err("you're err is -17")
65. use std::fs::File; use std::io::Read; fn main() { let mut file = match File::open("boring.txt") { Ok(f) => f, Err(e) => panic!("OH, NO! {}", e), }; let mut contents = String::new(); file.read_to_string(&mut contents); println!("{}", contents); } //==================== Компилационна грешка (ха-ха, това е буквалното съдържание на файла)
66. use std::fs::File; use std::io::Read; fn main() { do_magic_stuff(); } fn do_magic_stuff() { let mut boring = match File::open("boring.txt") { Ok(f) => f, Err(e) => panic!("OH, NO! {}", e), }; let mut fun = match File::open("fun.txt") { Ok(f) => f, Err(e) => panic!("OH, NO! {}", e), }; let mut contents = String::new(); boring.read_to_string(&mut contents); fun.read_to_string(&mut contents); println!("{}", contents); }
67. use std::fs::File; use std::io::{self, Read}; fn main() { match do_magic_stuff() { Ok(contents) => println!("{}", contents), Err(e) => panic!("OH, NO! {}", e), } } fn do_magic_stuff() -> Result<String, io::Error> { let mut boring = match File::open("boring.txt") { Ok(f) => f, Err(e) => return Err(e), }; let mut fun = match File::open("fun.txt") { Ok(f) => f, Err(e) => return Err(e), }; let mut contents = String::new(); boring.read_to_string(&mut contents); fun.read_to_string(&mut contents); return Ok(contents); }
68. macro_rules! try { ($expr:expr) => { match $expr { Ok(result) => result, Err(e) => return Err(e), } } }
69. use std::fs::File; use std::io::{self, Read}; fn main() { match do_magic_stuff() { Ok(contents) => println!("{}", contents), Err(e) => panic!("OH, NO! {}", e), } } fn do_magic_stuff() -> Result<String, io::Error> { let mut boring = match File::open("boring.txt") { Ok(f) => f, Err(e) => return Err(e), }; let mut fun = match File::open("fun.txt") { Ok(f) => f, Err(e) => return Err(e), }; let mut contents = String::new(); boring.read_to_string(&mut contents); fun.read_to_string(&mut contents); return Ok(contents); }
70. use std::fs::File; use std::io::{self, Read}; fn main() { match do_magic_stuff() { Ok(contents) => println!("{}", contents), Err(e) => panic!("OH, NO! {}", e), } } fn do_magic_stuff() -> Result<String, io::Error> { let mut boring = try!(File::open("boring.txt")); let mut fun = try!(File::open("fun.txt")); let mut contents = String::new(); boring.read_to_string(&mut contents); fun.read_to_string(&mut contents); return Ok(contents); }
71. fn main() { let contents = try!(do_magic_stuff()); println!("{}", contents), } //==================== error[E0308]: mismatched types --> src/main.rs:8:30 | 8 | Err(e) => return Err(e), | ^^^^^^ expected (), found enum `std::result::Result` ... 14 | try!(do_magic_stuff()); | ----------------------- in this macro invocation | = note: expected type `()` found type `std::result::Result<_, std::io::Error>`
72. let mut fun = try!(File::open("fun.txt")); let mut fun = try! { File::open("fun.txt"). or_else(|_| File::open("passable.txt")). or_else(|_| File::open("okay_i_guess.txt")) }; let optional_fun = File::open("fun.txt"). or_else(|_| File::open("passable.txt")). or_else(|_| File::open("okay_i_guess.txt")); if let Ok(mut fun) = optional_fun { // Super-special Fun Time! }
73. Нещо по-просто
74. fn main() { let args: Vec<String> = std::env::args().collect(); if args.len() > 0 { let filename = args.get(0); // Oh, no! Some(String)!
75. fn main() { let args: Vec<String> = std::env::args().collect(); if args.len() > 0 { let filename = args.get(0).unwrap(); run_interpreter(filename) } else { run_console(); } }
76. fn main() { let args: Vec<String> = std::env::args().collect(); if args.len() > 1 { let filename = args.get(1).unwrap(); run_interpreter(filename) } else { run_console(); } }
77. fn main() { let args: Vec<String> = std::env::args().collect(); if args.len() > 2 { let filename = args.get(2).unwrap(); run_interpreter(filename) } else { run_console(); } }
78. fn main() { let args: Vec<String> = std::env::args().collect(); if args.len() >= 3 { let filename = args.get(3).unwrap(); run_interpreter(filename) } else { run_console(); } } // =================== thread 'main' panicked at 'called `Option::unwrap()` on a `None` value', /checkout/src/libcore/option.rs:335:20 note: Run with `RUST_BACKTRACE=1` for a backtrace.
79. fn main() { let args: Vec<String> = std::env::args().collect(); match args.get(0) { Some(filename) => run_interpreter(filename), None => run_console(), } }
80. try!, try! again
81. Learning curve • Ownership • Borrow checker • Mutability • Pattern-matching • Lifetimes
82. Заслужава си • Redox (+ coreutils + terminal + shell) • Игри (ggez, Piston, SHAR) • 100+ “Friends of Rust”
83. Ferris the Crustacean
85. The Rust Book
86. fn main() { let x: String = String::from("forty-two"); let y: String = x; println!("x = {}", x); println!("y = {}", y); } // =================== error[E0382]: use of moved value: `x` --> src/main.rs:5:24 | 3 | let y: String = x; | - value moved here 4 | 5 | println!("x = {}", x); | ^ value used here after move | = note: move occurs because `x` has type `std::string::String`, which does not implement the `Copy` trait
87. ust
88. Благодар