#Rustlang Tip: Use the #[non_exhaustive] attribute for future-proofing your enums and structs.
This allows you to add new variants later without breaking existing code.
Sidenote: The #[non_exhaustive] attribute forces people to have a _ pattern in their matches that will match any new items you add later.
![#[non_exhaustive]
pub enum Color {
Red,
Green,
Blue,
}
fn main() {
let color = Color::Red;
match color {
Color::Red => println!("It's red!"),
Color::Green => println!("It's green!"),
Color::Blue => println!("It's blue!"),
_ => println!("It's a new color!"),
}
}](https://pool.jortage.com/tootcat/media_attachments/files/113/613/522/949/889/357/original/14bb85f6af86db07.png)
#Rustlang Tip: Use cargo doc to generate documentation for your project.
Doc comments use three slashes /// and support Markdown
They appear in the generated documentation
Regular double line comments // won't be included in the documentation.
example:
Run cargo doc --open to generate and view your documentation!
DO: Use std::collections::HashSet for storing unique values.
DON'T: Reinvent the wheel with custom data structures.
Sidenote: A HashSet is implemented as a HashMap where the value is the empty tuple (). So HashSet<String> is essentially the same as HashMap<String, ()>!
#Rustlang Tip: Use std::mem::size_of::<T>() to check the size of types at compile-time.
#Rustlang Tip: Use Vec::with_capacity(n) when you know the approximate size of your vector beforehand. This will reserve memory for the vector to avoid multiple allocations.
This is a performance optimization and shouldn't change the behavior of the code in most situations.
Be careful though, if you overestimate the size of the vector you will waste memory!
#Rustlang Tip: Use #[test] with #[ignore] for long-running or resource-intensive tests.
Run all tests: cargo test
Run ignored tests: cargo test -- --ignored
This helps keep your test suite fast while still allowing those long running tests when needed!
![#[cfg(test)] mod tests { use std::thread; use std::time::Duration; #[test] fn quick_test() { assert_eq!(2 + 2, 4); } #[test] #[ignore] fn slow_test() { // Simulate a long-running test thread::sleep(Duration::from_secs(5)); assert!(true); } }](https://pool.jortage.com/tootcat/media_attachments/files/113/278/357/450/365/405/original/a98fbad76c90b195.png)
#Rustlang Tip: cargo expand - Your X-ray Vision for Macros!
cargo expand allows you to see the expanded code generated by macros, providing more insight into what's happening under the hood.
Learn more here: https://docs.rs/crate/cargo-expand/0.1.3/source/README.md
![// notice how all the imports are revealed! #![feature(prelude_import)] #[prelude_import] use std::prelude::rust_2021::*; #[macro_use] extern crate std; // notice how the function bodies are shown! fn foo() { { ::std::io::_print(format_args!("You called {0:?}()\n", "foo")); }; } fn bar() { { ::std::io::_print(format_args!("You called {0:?}()\n", "bar")); }; } fn main() { foo(); bar(); }](https://pool.jortage.com/tootcat/media_attachments/files/113/267/032/814/893/970/original/7d19bd9217e1a677.png)
#Rustlang Tip: Use the #[derive(Default)] attribute for struct initialization if all your fields have a Default implementation.
Be careful though, sometimes the Default implementation is not what you want!
For instance, if you have a String field, the default implementation will create an empty string, which if often not what I want.
In those cases you can implement Default manually for custom behavior.
![#[derive(Default, Debug)] struct Person { name: String, age: u32, } #[derive(Debug)] struct PersonWithCustomDefault { name: String, age: u32, } impl Default for PersonWithCustomDefault { fn default() -> Self { PersonWithCustomDefault { name: "Unknown".to_string(), age: 10 } } } fn main() { let person = Person::default(); println!("{:?}", person); // Output: Person { name: "", age: 0 } let person_with_custom_default = PersonWithCustomDefault::default(); println!("{:?}", person_with_custom_default); // Output: PersonWithCustomDefault { name: "Unknown", age: 10 } }](https://pool.jortage.com/tootcat/media_attachments/files/113/250/045/912/786/321/original/a5cabb5441862aaa.png)
#Rustlang Tip: use Option<T> for values that might be absent.
Rust doesn't have null values, but it does have Option<T>, which is an enum that represents a value that might be present or absent.
This lets the compiler help check for those pesky "null" cases for you, and make sure you handle the Option::None case!
#Rustlang Tip: Speed up dev cycles by using cargo check instead of cargo build during development.
It skips building everything but still checks your code for any compilation errors!
You can also use cargo watch to automatically run cargo check when you make changes to your code.
#Rustlang Tip
Use the #[derive(Debug, Clone)] attribute to automatically generate implementations for the Debug and Clone traits for your structs and enums!
Clone is useful when you need a copy of the struct Debug is useful for printing the struct for debugging purposes, and can be used with the dbg! macro
![#[derive(Debug, Clone)] struct Person { name: String, age: u32, } fn main() { let alice = Person { name: "Alice".into(), age: 30 }; let mut bob = alice.clone(); bob.name = "Bob".to_string(); dbg!(alice); dbg!(bob); // Outputs: // alice = Person { name: "Alice", age: 30 } // bob = Person { name: "Bob", age: 30 } }](https://pool.jortage.com/tootcat/media_attachments/files/113/227/396/643/883/467/original/cd33e347d7fab10c.png)
#RustLang Tip: Don't use .unwrap()!
Use expect() instead in tests or when you're absolutely sure a Result/Option is Some/Ok but you can't convey that in the type system. DON'T: Use either in production code where errors are possible.
expect() is like unwrap() but with a custom message!
Better alternatives:
• 
? operator, to forward the error up the call stack
• 
match
Read more: https://doc.rust-lang.org/book/ch09-02-recoverable-errors-with-result.html
Traits are not for method overloading.
They are a way to define methods that multiple types can implement, enabling polymorphism!
With traits you can write functions that accept different types, that all have a common behavior.
All while maintaining type safety!
You even get the file and line number, for free!
![let x = 5; let y = 10; dbg!(x + y); //output: [src/main.rs:3] x + y = 15](https://pool.jortage.com/tootcat/media_attachments/files/113/205/600/663/839/936/original/739073952c59cfae.png)
You can swap two values with creating a temp variable!
```rust
let a = 1;
let b = 2;
let (a, b) = (b, a);
println!("{}, {}",a,b);
//output: 2, 1
```
#Rust30by30 #Rust #Rustlang #Day1
