Две-три думи за Rust (ТърновоКонф 2018)

Две-три думи за Rust (ТърновоКонф 2018)

Демонстрация на това защо Rust е интересен език, който си заслужава да се пробва.

Fc59401781a26b10f5d4fc5b758fb3b7?s=128

Andrew Radev

June 02, 2018
Tweet

Transcript

  1. Две-три думи за ust

  2. @AndrewRadev

  3. “Много е готин”

  4. Ferris the Crustacean

  5. None
  6. None
  7. Какво толкова пренаписват тия ръстаджии?

  8. Redox

  9. Redox

  10. Alacritty

  11. Ripgrep

  12. Ripgrep

  13. Servo

  14. Игрички • Piston • SHAR • ggez

  15. None
  16. Защо?

  17. Защо? • Скорост • Съвместимост • C, Ruby, Python, Erlang

    • Микроконтролери • Web Assembly • Безопасност
  18. Rust винаги шофира

  19. Защо? • Скорост • Съвместимост • Безопасност • Елегантност •

    Общност: документация, конференции, форуми, процес на разработка
  20. Малко код

  21. 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
  22. fn main() { let potato = " Любов, любов, варен

    картоф, разрежеш го, а той суров. "; println!("--\n{}\n--", potato); } // =================== --- Любов, любов, варен картоф, разрежеш го, а той суров. ---
  23. fn main() { let potato = " Любов, любов, варен

    картоф, разрежеш го, а той суров. "; let lines = potato. trim(). lines(). map(|l| l.trim()); println!("---"); for line in lines { println!("{}", line); } println!("---"); } // =================== --- Любов, любов, варен картоф, разрежеш го, а той суров. ---
  24. fn main() { let potato = " Любов, любов, варен

    картоф, разрежеш го, а той суров. "; let lines = potato. trim(). lines(). map(|l| l.trim()); println!("+-------------------------------+"); for line in lines { println!("| {}\t|", line); } println!("+-------------------------------+"); } // =================== +-------------------------------+ | Любов, любов, варен картоф, | | разрежеш го, а той суров. | +-------------------------------+
  25. let lines = potato. trim(). lines(). map(|l| l.trim()); for line

    in lines { println!("{}", line); }
  26. let lines = potato. // => &str trim(). lines(). map(|l|

    l.trim()); for line in lines { println!("{}", line); } fn trim(&self) -> &str { // // " Любов, ала-бала, картоф " // ^___________________________^ -> текущия &str // // " Любов, ала-бала, картоф " // ^_____________________^ -> върнатия &str }
  27. let lines = potato. trim(). lines(). // => Lines (std::str::Lines)

    map(|l| l.trim()); for line in lines { println!("{}", line); }
  28. let lines = potato. trim(). lines(). map(|l| l.trim()); for line

    in lines { println!("{}", line); }
  29. 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); }
  30. let lines = potato. trim(). lines(). map(|l| l.trim()); for line

    in lines { println!("{}", line); }
  31. Zero-cost abstraction • Удобен интерфейс • Ефективна имплементация

  32. Error handling

  33. file, err := os.Open("filename.ext") if err != nil { return

    err } match File::open("filename.ext") { Ok(file) => file, Err(e) => return e, } enum Result<T, E> { Ok(T), Err(E), } Result<File, Error>
  34. let mut fun = try! { File::open("fun.txt"). or_else(|_| File::open("passable.txt")). or_else(|_|

    File::open("okay_i_guess.txt")) };
  35. 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); }
  36. 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); }
  37. macro_rules! try { ($expr:expr) => { match $expr { Ok(result)

    => result, Err(e) => return Err(e), } } }
  38. 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); }
  39. 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); }
  40. 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 = File::open("boring.txt")?; let mut fun = File::open("fun.txt")?; let mut contents = String::new(); boring.read_to_string(&mut contents); fun.read_to_string(&mut contents); return Ok(contents); }
  41. Безопасност

  42. Досадна безопасност • Няма NULL • 3.14 * 2 е

    компилационна грешка • Жонглиране на references (“псевдоними”) • (demo)
  43. Полезна безопасност :) • HashMap.entry() • Има Result, Option –

    по-удобни от NULL • Добре документирани и полезни операции с числа • (demo)
  44. Learning curve • “Това е ужасно, защо не мога да

    направя каквото си знам”? • Крачка назад • Четене на документация • Различен (по-добър) подход
  45. Защо? • Скорост • Съвместимост • Безопасност • Елегантност •

    Общност • Труден, но си заслужава
  46. The Rust Book

  47. ?