Latest posts tagged with #Rust30by30 on Bluesky
🤝 #Rustlang Tip: Contribute to the Rust community!
❌ DON'T:
- Be afraid to ask for help
- Hesitate to share your knowledge, no matter your skill level
Remember: Every contribution, big or small, helps the Rust ecosystem grow! 🦀
#Rust30by30
![let nums = vec![1, 2, 3, 4, 5];
let sum: i32 = nums.iter().filter(|x| *x % 2 == 0).sum();
println!("Sum: {}", sum);](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:bg2gnrjiv6htfynausierbm2/bafkreib7vuw4csyzbhcf6mov5wszawjyh3p7xp74fkpea4vd26sf2hjqte)
let nums = vec![1, 2, 3, 4, 5]; let sum: i32 = nums.iter().filter(|x| *x % 2 == 0).sum(); println!("Sum: {}", sum);
🔁 #Rustlang Tip: Use the std::iter module for powerful iterator operations.
Docs: https://doc.rust-lang.org/std/iter/
#Rust30by30
![#[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://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:bg2gnrjiv6htfynausierbm2/bafkreihhyk3x36ky6ybe7pbmweylkwaru7r466gtajysjyegaor2th7yny)
#[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!"), } }
🔒 #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.
This attribute forces people to have a _ pattern in their matches that will match any items you add later.
#Rust30by30
/// The `add` function adds two numbers /// /// # Examples /// /// let result = add(2, 3); /// assert_eq!(result, 5); /// pub fn add(a: i32, b: i32) -> i32 { a + b }
📚 #Rustlang Tip: Use cargo doc to generate docs for your project
Doc comments use three slashes /// and support Markdown
They appear in the generated documentation
Regular won't be included in the documentation.
example:
Run `cargo doc --open` to generate and view your documentation!
#Rust30by30
✅ 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 #Rust30by30
struct Person { name: String, age: u32 } impl std::fmt::Display for Person { fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { write!(f, "{} ({} years old)", self.name, self.age) } } fn main() { let person = Person { name: "Alice".to_string(), age: 30 }; println!("{}", person); // Output: Alice (30 years old) }
🔍 #Rustlang Tip: Use the std::fmt::Display trait to customize how your structs are printed!
#RustFormatting #Rust30by30 #Day18
println!("Size of i32: {}", std::mem::size_of::<i32>()); //output: Size of i32: 4 println!("Size of i64: {}", std::mem::size_of::<i64>()); //output: Size of i64: 8 println!("Size of String: {}", std::mem::size_of::<String>()); //output: Size of String: 24
🔍 #Rustlang Tip: Use std::mem::size_of::<T>() to check the size of types at compile-time.
#RustPerformance #Rust30by30 #Day17
let mut vec = Vec::with_capacity(10); for i in 0..10 { vec.push(i); }
🔍 #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.
Be careful though, if you overestimate the size of the vector you will waste memory!
#RustCollections #Rust30by30 #Day16
![#[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://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:bg2gnrjiv6htfynausierbm2/bafkreia37tsxvjyfrz2owftdr2ulsf62llebc4wp2gfo33oqs5bm7jsnde)
#[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); } }
🧪 #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!
#RustTesting #Rust30by30 #Day15
"rust-analyzer.check.command": "clippy"
🔍 #Rustlang Tip: Use cargo clippy to catch common mistakes and improve your code!
It's also a great learning tool! It will show you best practices to follow, and by reading and understanding the suggestions you can improve your skills as a Rust developer!
#Rust30by30 #Day14
macro_rules! create_function { ($func_name:ident) => { fn $func_name() { println!("You called {:?}()", stringify!($func_name)); } }; } create_function!(foo); create_function!(bar); fn main() { foo(); bar(); }
![// 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://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:bg2gnrjiv6htfynausierbm2/bafkreihprptu2nrnous4qiabtdish7vuazg4k7uxkwqjzrkbkgeoq2tzhe)
// 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(); }
⚡ #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: docs.rs/crate/cargo-expand/0.1.3...
#RustMacros #Rust30by30 #Day13
🎨 Rust Tip: Use cargo fmt to automatically format your code!
📝 You can even setup your editor to Auto-Format on save!
VS Code Instructions:
- Install the Rust Analyzer extension
- Open settings
- Search for "Format on Save" and enable it
#RustTips #Rust30by30 #Day12
struct Person { name: String, age: u32, } fn main() { let person = Person { name: "rust biggest fan".to_string(), ..Default::default() }; println!("{:?}", person); // Output: Person { name: "rust biggest fan", age: 0 } }
🏗️ #Rustlang Hack: Use the ..Default::default() syntax to initialize structs with some default values while customizing others.
This is also not limited to Default::default() it will work with any instance of your struct!
#Rust30by30 #Day11
![#[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://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:bg2gnrjiv6htfynausierbm2/bafkreib54dboyb33nprjikdzr3s4yak7onvugsi34hvkdykm4qes2owbv4)
#[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 } }
🏗️ #Rustlang Tip: Use the #[derive(Default)] attribute for struct initialization if all your fields have a Default implementation.
Be careful though, for Strings field, the default implementation will create an empty string!
#RustTricks #Rust30by30 #Day10
struct Animal { name: String, age: u32, fav_treat: Option<String> } fn print_treat(animal: Animal) { // println!("{} loves {}", animal.name, animal.fav_treat) // This line ^^ wouldn't compile because fav_treat is an Option<String> // and can't be printed directly. Instead lets use a match statement! match &animal.fav_treat { Some(treat) => println!("{} loves {}", animal.name, treat), None => println!("{} doesn't have a favorite treat", animal.name), } }
⚡ #Rustlang Tip: use Option<T> for values that might be absent.
Rust doesn't have null values, but it does have Option<T>
This lets the compiler help check for those pesky "null" cases for you, and make sure you handle the Option::None case!
#RustTricks #Rust30by30 #Day9
⚡ #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!
#RustTricks #Rust30by30 #Day8
![#[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://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:bg2gnrjiv6htfynausierbm2/bafkreiggprps5yexbviu54sxksvn3rmnogjeexlvbhd6myexrwabi3w7my)
#[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 } }
🔧 #Rustlang Tip
Use the #[derive(Debug, Clone)] attribute to automatically generate implementations for the Debug and Clone traits.
💡 Clone is useful when you need a copy of the struct
💡 Debug is useful for printing the struct for debugging, try with dbg!
#Rust30by30 #Day6
🔍 Better alternatives:
• ❓ ? operator, to forward the error up the call stack
• 🧩 match
📚 Read more: doc.rust-lang.org/book/ch09-02-recoverable...
#ErrorHandling #Rust30by30 #Day5
2/2
trait Printable { fn print(&self); } struct NewsArticleTitle(String); impl Printable for NewsArticleTitle { fn print(&self) { println!("News Article: {}", self.0); } } struct BlogPostTitle(String); impl Printable for BlogPostTitle { fn print(&self) { println!("Blog Post: {}", self.0); } } fn print_me<P: Printable>(item: P) { item.print(); } fn main() { let article = NewsArticleTitle("Breaking News - Rust is fun!".to_string()); let post = BlogPostTitle("Why I love Rust!".to_string()); print_me(article); print_me(post); } // Outputs: // News Article: Breaking News - Rust is fun! // Blog Post: Why I love Rust!
🧩 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!
#Rust30by30 #Rustlang #Day4
![fn fibonacci(n: u64) -> u64 { if n <= 1 { return n; } fibonacci(n - 1) + fibonacci(n - 2) } #[cfg(test)] mod tests { use super::*; #[test] fn test_fibonacci() { assert_eq!(fibonacci(0), 0); assert_eq!(fibonacci(1), 1); assert_eq!(fibonacci(2), 1); assert_eq!(fibonacci(10), 55); } }](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:bg2gnrjiv6htfynausierbm2/bafkreiefvyvdbahjcd52sig3nnfhussc3eek342v6jawna667z73ahnpd4)
fn fibonacci(n: u64) -> u64 { if n <= 1 { return n; } fibonacci(n - 1) + fibonacci(n - 2) } #[cfg(test)] mod tests { use super::*; #[test] fn test_fibonacci() { assert_eq!(fibonacci(0), 0); assert_eq!(fibonacci(1), 1); assert_eq!(fibonacci(2), 1); assert_eq!(fibonacci(10), 55); } }
🧪 #RustLang Tip
✅ DO: Use Rust's built-in testing framework to write unit tests and integration tests.
❌ DON'T: Skip testing, it's crucial for maintainable code! #RustTesting #TDD
Run `cargo test` to see the output!
Learn more: https://buff.ly/3XZHtbu
#Rust30by30 #Day3
![let x = 5; let y = 10; dbg!(x + y); //output: [src/main.rs:3] x + y = 15](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:bg2gnrjiv6htfynausierbm2/bafkreih7mze7iud5z7hi6veptty6lbf5lqoz6eedhy23x4zegzu2gtkgfm)
let x = 5; let y = 10; dbg!(x + y); //output: [src/main.rs:3] x + y = 15
🐞 Rust Hack: Use the `dbg!` macro to print variables and expressions during debugging. No more `println!` with manual variable names!
You even get the file and line number, for free!
#Rustlang #Debugging #Rust30by30 #Day2
let a = 1; let b = 2; let (a, b) = (b, a); println!("{}, {}",a,b); //output: 2, 1
🔄 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 #Rustc #Rustlang #Day1
