Idiomatic Rust - Writing concise and elegant Rust code

Rust is a big language and it gets bigger every day. Many beginners ask: "What is idiomatic Rust?". This talk will highlight simple tips to make your Rust code more elegant and concise, and introduce you to my peer-reviewed collection of articles/talks/repos for writing idiomatic Rust code.

Coming from dynamic languages like Python, JavaScript or Ruby, many Rust beginners are missing some guidelines on how to write elegant and concise Rust code. For this purpose, I started a project called "Idiomatic Rust", which is a peer-reviewed collection of articles/talks/repos which teach the essence of good Rust.

In this talk I will introduce the project and show you some quick tips on how to make your Rust code more idiomatic. I will cover error handling (e.g. Option to Result conversions, the failure crate), efficiently working with (built-in) traits, and some more.

Transcript

1. Idiomatic Rust Writing concise and elegant Rust code
2. ! Düsseldorf, Germany ! Backend Engineer at ! Website performance ! Hot Chocolate matthiasendler mre matthias-endler.de Matthias Endler
3. EXPECTATION... REALITY...
5. Python
6. The Zen f Python Image: Monty Python and the Holy Grail (1975)
7. Beautiful is better than ugly. Explicit is better than implicit. Zen of Python
8. What is
 idiomatic Rust?
9. What is
 idiomatic?
10. The most concise, convenient and common way of accomplishing a task in a programming language. Tim Mansfield
11. public bool IsTrue(bool b) { if (b == true) { return true; } return false; } http://codecrap.com/content/172/
12. syntax
 semantics design patterns Idiomatic Rust
13. use rustfmt ???
 Idiomatic Rust syntax
 semantics design patterns rust-unofficial/patterns
15. https://github.com/mre/idiomatic-rust
16. Case study: Handling money in Rust
17. Task: Parse money, e.g.
 20,42 Dollar or 140 Euro.
18. fn parse_money(input: &str) { let parts: Vec<&str> = input.split_whitespace().collect(); let maybe_amount = parts[0].parse(); if maybe_amount.is_err() { return (-1, "invalid".to_string()); } let currency = parts[1].to_string(); return (maybe_amount.unwrap(), currency); } // TODO 1 2 3 4 5 6 7 8 9
19. fn parse_money(input: &str) -> (i32, String) { let parts: Vec<&str> = input.split_whitespace().collect(); let maybe_amount = parts[0].parse(); if maybe_amount.is_err() { return (-1, "invalid".to_string()); } let currency = parts[1].to_string(); return (maybe_amount.unwrap(), currency); } 1 2 3 4 5 6 7 8 9
20. fn parse_money(input: &str) -> (i32, String) { let parts: Vec<&str> = input.split_whitespace().collect(); let maybe_amount = parts[0].parse(); if maybe_amount.is_err() { return (-1, "invalid".to_string()); } let currency = parts[1].to_string(); return (maybe_amount.unwrap(), currency); } 1 2 3 4 5 6 7 8 9 "magic" error constants
21. use unwrap() fn parse_money(input: &str) -> (i32, String) { let parts: Vec<&str> = input.split_whitespace().collect(); let amount = parts[0].parse().unwrap(); let currency = parts[1].to_string(); return (amount, currency); } 1 2 3 4 5 6
22. parse_money("140 Euro"); (140, "Euro")
23. parse_money("140.01 Euro"); thread 'main' panicked at 'called `Result::unwrap()` on an `Err` value: ParseIntError { kind: InvalidDigit }', src/libcore/result.rs:906:4 note: Run with `RUST_BACKTRACE=1` for a backtrace.
24. fn parse_money(input: &str) -> (i32, String) { let parts: Vec<&str> = input.split_whitespace().collect(); let amount = parts[0].parse().unwrap(); let currency = parts[1].to_string(); return (amount, currency); } 1 2 3 4 5 6 unwrap will panic on error
25. fn parse_money(input: &str) -> Result<(i32, String), ParseIntError> { let parts: Vec<&str> = input.split_whitespace().collect(); let amount = parts[0].parse()?; let currency = parts[1].to_string(); return Ok((amount, currency)); } replace unwrap with ? 1 2 3 4 5 6
26. parse_money("140.01 Euro"); Err(ParseIntError { kind: InvalidDigit }) Bro blem?
27. fn parse_money(input: &str) -> Result<(i32, String), ParseIntError> { let parts: Vec<&str> = input.split_whitespace().collect(); let amount = parts[0].parse()?; let currency = parts[1].to_string(); return Ok((amount, currency)); } Wrong type for parse() 1 2 3 4 5 6
28. fn parse_money(input: &str) -> Result<(f32, String), ParseFloatError> { let parts: Vec<&str> = input.split_whitespace().collect(); let amount = parts[0].parse()?; let currency = parts[1].to_string(); return Ok((amount, currency)); } use float Don't use float for real-world money objects! 1 2 3 4 5 6
29. parse_money("140.01 Euro"); Ok((140.01, "Euro"))
30. thread 'main' panicked at 'index out of bounds: the len is 1 but the index is 1', /Users/travis/build/ rust-lang/rust/src/liballoc/vec.rs:1551:10 note: Run with `RUST_BACKTRACE=1` for a backtrace. parse_money("140.01");
31. fn parse_money(input: &str) -> Result<(f32, String), ParseFloatError> { let parts: Vec<&str> = input.split_whitespace().collect(); let amount = parts[0].parse()?; let currency = parts[1].to_string(); return Ok((amount, currency)); } 1 2 3 4 5 6 Unchecked vector index
32. fn parse_money(input: &str) -> Result<(f32, String), MoneyError> { let parts: Vec<&str> = input.split_whitespace().collect(); if parts.len() != 2 { Err(MoneyError::ParseError) } else { let (amount, currency) = (parts[0], parts[1]); Ok((amount.parse()?, currency.to_string())) } } use custom error 1 2 3 4 5 6 7 8 9
33. #[derive(Debug)]
 pub enum MoneyError {
 ParseError,
 } impl Error for MoneyError {
 fn description(&self) -> &str {
 match *self { MoneyError::ParseError => "Invalid input", } } } impl fmt::Display for MoneyError { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self { MoneyError::ParseError => f.write_str("Invalid input"), } } } impl From<ParseFloatError> for MoneyError { fn from(error: ParseFloatError) -> Self { MoneyError::ParseError } }
34. #[derive(Debug, Fail)] enum MoneyError { #[fail(display = "Invalid input: {}", _0)]
 ParseAmount(ParseFloatError),
 #[fail(display = "{}", _0)]
 ParseFormatting(String), } impl From<ParseFloatError> for MoneyError { fn from(e: ParseFloatError) -> Self { MoneyError::ParseAmount(e) } } https://github.com/withoutboats/failure
35. println!("{:?}", parse_money("140.01"));
 Err(ParseFormatting("Expecting amount and currency")) println!("{:?}", parse_money("OneMillion Euro"));
 Err(ParseAmount(ParseFloatError { kind: Invalid })) println!("{:?}", parse_money("100 Euro"));
 Ok((100, "Euro"))
36. fn parse_money(input: &str) -> Result<(f32, String), MoneyError> { let parts: Vec<&str> = input.split_whitespace().collect(); if parts.len() != 2 { Err(MoneyError::ParseFormatting( "Expecting amount and currency".into(), )) } else { let (amount, currency) = (parts[0], parts[1]); Ok((amount.parse()?, currency.to_string())) } } explicit length check 1 2 3 4 5 6 7 8 9
 10 11
37. slice patterns fn parse_money(input: &str) -> Result<(f32, String), MoneyError> { let parts: Vec<&str> = input.split_whitespace().collect(); match parts[..] { [amount, currency] => Ok((amount.parse()?, currency.to_string())), _ => Err(MoneyError::ParseFormatting( "Expecting amount and currency".into(), )), } } #![feature(slice_patterns)] 1 2 3 4 5 6 7 8 9
 10
38. fn parse_money(input: &str) -> Result<Money, MoneyError> { let parts: Vec<&str> = input.split_whitespace().collect(); match parts[..] { [amount, curr] => Ok(Money::new(amount.parse()?, curr.parse()?)), _ => Err(MoneyError::ParseFormatting( "Expecting amount and currency".into(), )), } } #![feature(slice_patterns)] 1 2 3 4 5 6 7 8 9
 10 use own type for money
39. #[derive(Debug)] struct Money { amount: f32, currency: Currency, } impl Money { fn new(amount: f32, currency: Currency) -> Self { Money { amount, currency } } } use own type for money
40. #[derive(Debug)] enum Currency { Dollar, Euro, } impl std::str::FromStr for Currency { type Err = MoneyError; fn from_str(s: &str) -> Result<Self, Self::Err> { match s.to_lowercase().as_ref() { "dollar" | "$" => Ok(Currency::Dollar), "euro" | "eur" | "€" => Ok(Currency::Euro), _ => Err(MoneyError::ParseCurrency("Unknown currency".into())), } } } use own type for money 1 2 3 4 5 6 7 8 9
 10 11 12
41. impl std::str::FromStr for Money { type Err = MoneyError; fn from_str(s: &str) -> Result<Self, Self::Err> { let parts: Vec<&str> = s.split_whitespace().collect(); match parts[..] { [amount, currency] => Ok(Money::new(amount.parse()?, currency.parse()?)), _ => Err(MoneyError::ParseFormatting( "Expecting amount and currency".into(), )), } } } use own type for money
42. "140.01".parse::<Money>()
 Err(ParseFormatting("Expecting amount and currency")) "OneMillion Bitcoin".parse::<Money>() Err(ParseAmount(ParseFloatError { kind: Invalid })) "100 €".parse::<Money>() Ok(Money { amount: 100.0, currency: Euro }) "42.24 Dollar".parse::<Money>() Ok(Money { amount: 42.42, currency: Dollar })
43. matthias-endler.de github.com/mre/idiomatic-rust ...use clippy! Thank you! Crab title image designed by freepik