Idiomatic Rust Snippets

https://idiomatic-rust-snippets.org
Admin
This book provides beginner-friendly, idiomatic Rust code snippets, covering core concepts,...
Tokens:86,570
Snippets:797
Trust Score:3.8
Update:1 month ago
Show doc for...
Tokens:
Raw
### Implementing a basic no_std environment

Source: https://idiomatic-rust-snippets.org/essentials/packaging/no-std.html

This example demonstrates a minimal no_std setup, including a custom struct, a required panic handler, and a custom entry point.

```rust
#![no_std]

use core::fmt;

// A custom struct that we'll make displayable
pub struct MyStruct {
    value: i32,
}

impl MyStruct {
    pub const fn new(value: i32) -> Self {
        MyStruct { value }
    }
    
    pub fn get_value(&self) -> i32 {
        self.value
    }
}

impl fmt::Display for MyStruct {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "MyStruct {{ value: {} }}", self.value)
    }
}

// In no_std environments, you typically provide custom panic handler
#[panic_handler]
fn panic(_info: &core::panic::PanicInfo) -> ! {
    loop {}
}

// For embedded systems, entry point is often different
#[no_mangle]
pub extern "C" fn _start() -> ! {
    let my_struct = MyStruct::new(42);
    // In real embedded code, you'd interact with hardware here
    // No println! available - would use hardware-specific output
    loop {}
}
```

--------------------------------

### cargo install binary installation

Source: https://idiomatic-rust-snippets.org/essentials/packaging/cargo-commands.html

Commands to install binary crates from various sources like crates.io, git repositories, or local paths.

```bash
# Install from crates.io
cargo install ripgrep

# Install from git
cargo install --git https://github.com/user/repo

# Install with specific features
cargo install cargo-edit --features vendored-openssl

# Install local crate
cargo install --path .
```

--------------------------------

### Explicit composition example

Source: https://idiomatic-rust-snippets.org/anti-patterns/type-system/deref-abuse.html

This example shows the idiomatic approach using explicit composition, where Admin methods are clearly defined and access to User data is explicit.

```rust
struct User {
    name: String,
    email: String,
}
struct Admin {
    user: User,
    permissions: Vec<String>,
}
impl User {
    fn display(&self) {
        println!("{} <{}>", self.name, self.email);
    }
}
impl Admin {
    fn user(&self) -> &User {
        &self.user
    }
    
    fn display(&self) {
        self.user.display();
        println!("Permissions: {:?}", self.permissions);
    }
}
fn main() {
    let admin = Admin {
        user: User {
            name: "Alice".to_string(),
            email: "alice@example.com".to_string(),
        },
        permissions: vec!["read".to_string(), "write".to_string()],
    };
    
    admin.display(); // Clearly calls Admin's display
    println!("Name: {}", admin.user().name); // Explicit access to user data
}
```

--------------------------------

### Basic Option Usage

Source: https://idiomatic-rust-snippets.org/essentials/std-lib/option.html

Example of using a function that returns an Option and handling the result with pattern matching.

```rust
fn find_word(word: &str) -> Option<usize> {
    let words = vec!["hello", "world", "rust"];
    words.iter().position(|&w| w == word)
}
fn main() {
    match find_word("rust") {
        Some(index) => println!("Found at index: {}", index),
        None => println!("Not found"),
    }
}
```

--------------------------------

### Shared and local dependencies

Source: https://idiomatic-rust-snippets.org/essentials/packaging/workspaces.html

Examples of defining shared dependencies and local path-based dependencies.

```toml
[workspace]
members = ["crate1", "crate2"]

[workspace.dependencies]
serde = "1.0"
tokio = "1.0"

# In crate1/Cargo.toml and crate2/Cargo.toml:
[dependencies]
serde = { workspace = true }
tokio = { workspace = true }
```

```toml
# In cli/Cargo.toml
[dependencies]
my-core = { path = "../core" }
my-utils = { path = "../utils", version = "0.1.0" }
```

--------------------------------

### Using Some with Option and if let

Source: https://idiomatic-rust-snippets.org/essentials/std-lib/some.html

This example demonstrates how to wrap values in Some and extract them using the if let syntax.

```rust
fn main() {
    let some_number = Some(5);
    let some_string = Some("Hello");
    if let Some(value) = some_number {
        println!("We have a number: {}", value);
    }
    if let Some(text) = some_string {
        println!("We have a string: {}", text);
    }
}
```

--------------------------------

### Safe indexing with get

Source: https://idiomatic-rust-snippets.org/anti-patterns/ownership-memory/unnecessary-unsafe.html

This example replaces the unsafe block with the safe .get() method. It automatically handles bounds checking and returns an Option, eliminating the risk of undefined behavior.

```rust
fn get_middle_element(data: &Vec<i32>) -> Option<i32> {
    let mid = data.len() / 2;
    data.get(mid).copied()
}
fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    if let Some(mid) = get_middle_element(&numbers) {
        println!("Middle: {}", mid); // Prints: Middle: 30
    }
    
    let empty: Vec<i32> = vec![];
    if let Some(mid) = get_middle_element(&empty) {
        println!("Empty vector"); // Prints: Empty vector
    } else {
        println!("No middle element");
    }
}
```

--------------------------------

### Bitwise operations example

Source: https://idiomatic-rust-snippets.org/essentials/operators/bitwise-operations.html

Demonstrates the usage of bitwise AND, OR, XOR, and shift operators on binary literals.

```rust
fn main() {
    let a = 0b1100;
    let b = 0b1010;
    println!("a & b: {:04b}", a & b); // Bitwise AND
    println!("a | b: {:04b}", a | b); // Bitwise OR
    println!("a ^ b: {:04b}", a ^ b); // Bitwise XOR
    println!("a << 1: {:04b}", a << 1); // Left shift
    println!("a >> 1: {:04b}", a >> 1); // Right shift
}
```

--------------------------------

### Complex workspace configuration

Source: https://idiomatic-rust-snippets.org/essentials/packaging/workspaces.html

A multi-package workspace setup with shared dependencies and metadata.

```toml
# Root Cargo.toml
[workspace]
members = [
    "backend",
    "frontend-api",
    "shared-models",
    "database",
]
resolver = "2"

[workspace.dependencies]
serde = { version = "1.0", features = ["derive"] }
tokio = { version = "1", features = ["full"] }
sqlx = { version = "0.7", features = ["postgres"] }

[workspace.package]
edition = "2021"
authors = ["Team <team@company.com>"]
license = "MIT"
```

```toml
# backend/Cargo.toml
[package]
name = "backend"
version = "0.1.0"
edition.workspace = true

[dependencies]
tokio = { workspace = true }
shared-models = { path = "../shared-models" }
database = { path = "../database" }
axum = "0.7"
```

```toml
# shared-models/Cargo.toml
[package]
name = "shared-models"
version = "0.1.0"
edition.workspace = true

[dependencies]
serde = { workspace = true }
```

--------------------------------

### Facade Pattern Implementation in Rust

Source: https://idiomatic-rust-snippets.org/patterns/structural/facade.html

This example demonstrates how to encapsulate multiple subsystems within a single Facade struct to provide a unified interface for client operations.

```rust
struct SubsystemA;
impl SubsystemA {
    fn operation_a1(&self) -> String {
        "Subsystem A, Operation A1".to_string()
    }
    fn operation_a2(&self) -> String {
        "Subsystem A, Operation A2".to_string()
    }
}
struct SubsystemB;
impl SubsystemB {
    fn operation_b1(&self) -> String {
        "Subsystem B, Operation B1".to_string()
    }
    fn operation_b2(&self) -> String {
        "Subsystem B, Operation B2".to_string()
    }
}
struct Facade {
    subsystem_a: SubsystemA,
    subsystem_b: SubsystemB,
}
impl Facade {
    fn new() -> Self {
        Facade {
            subsystem_a: SubsystemA,
            subsystem_b: SubsystemB,
        }
    }
    fn operation(&self) -> String {
        let mut result = String::new();
        result.push_str(&self.subsystem_a.operation_a1());
        result.push_str("\n");
        result.push_str(&self.subsystem_a.operation_a2());
        result.push_str("\n");
        result.push_str(&self.subsystem_b.operation_b1());
        result.push_str("\n");
        result.push_str(&self.subsystem_b.operation_b2());
        result
    }
}
fn main() {
    let facade = Facade::new();
    println!("{}", facade.operation());
}
```

--------------------------------

### Idiomatic approach: Using references

Source: https://idiomatic-rust-snippets.org/anti-patterns/ownership-memory/excessive-cloning.html

This example improves performance by accepting a string slice (&str) instead of taking ownership, eliminating the need for cloning.

```rust
fn analyze_text(text: &str) -> (usize, usize) {
    let word_count = text.split_whitespace().count();
    let char_count = text.chars().count();
    let line_count = text.lines().count();
    (word_count, line_count)
}
fn main() {
    let large_text = "word ".repeat(100_000);
    let (words, lines) = analyze_text(&large_text);
    println!("Words: {}, Lines: {}", words, lines);
}
```

--------------------------------

### Define and implement the Greet trait

Source: https://idiomatic-rust-snippets.org/essentials/types/trait.html

This example defines a Greet trait and implements it for both Person and Dog structs, demonstrating how to use traits for shared behavior.

```rust
// Define a trait named `Greet`
pub trait Greet {
    fn greet(&self);
}
// Define a struct named `Person`
pub struct Person {
    name: String,
}
// Implement the `Greet` trait for the `Person` struct
impl Greet for Person {
    fn greet(&self) {
        println!("Hello, my name is {}!", self.name);
    }
}
// Define a struct named `Dog`
pub struct Dog {
    name: String,
}
// Implement the `Greet` trait for the `Dog` struct
impl Greet for Dog {
    fn greet(&self) {
        println!("Woof! My name is {}!", self.name);
    }
}
fn main() {
    // Create instances of `Person` and `Dog`
    let person = Person {
        name: String::from("Alice"),
    };
    let dog = Dog {
        name: String::from("Buddy"),
    };
    dog.greet();
    person.greet();
}
```

--------------------------------

### View configuration with cargo config get

Source: https://idiomatic-rust-snippets.org/essentials/packaging/cargo-commands.html

Display current Cargo configuration values.

```bash
# Show all config values
cargo config get

# Show specific config
cargo config get build.target
```

--------------------------------

### Implementing and using extension traits

Source: https://idiomatic-rust-snippets.org/patterns/rust-idioms/extension-traits.html

This example demonstrates defining and implementing extension traits for String, Iterator, Option, and Vec types, followed by a main function showing their usage.

```rust
// Extension trait for String/&str
trait StringExt {
    fn is_blank(&self) -> bool;
    fn truncate_with_ellipsis(&self, max_len: usize) -> String;
}
impl StringExt for str {
    fn is_blank(&self) -> bool {
        self.trim().is_empty()
    }
    
    fn truncate_with_ellipsis(&self, max_len: usize) -> String {
        if self.len() <= max_len {
            self.to_string()
        } else if max_len <= 3 {
            "...".to_string()
        } else {
            format!("{}...", &self[..max_len - 3])
        }
    }
}
// Extension trait for iterators
trait IteratorExt: Iterator {
    fn sum_by<B, F>(self, f: F) -> B
    where
        Self: Sized,
        B: std::iter::Sum,
        F: FnMut(Self::Item) -> B;
}
impl<I: Iterator> IteratorExt for I {
    fn sum_by<B, F>(self, mut f: F) -> B
    where
        B: std::iter::Sum,
        F: FnMut(Self::Item) -> B,
    {
        self.map(|item| f(item)).sum()
    }
}
// Extension trait for Option
trait OptionExt<T> {
    fn ok_or_else_log<E, F>(self, err: F) -> Result<T, E>
    where
        F: FnOnce() -> E,
        E: std::fmt::Display;
}
impl<T> OptionExt<T> for Option<T> {
    fn ok_or_else_log<E, F>(self, err: F) -> Result<T, E>
    where
        F: FnOnce() -> E,
        E: std::fmt::Display,
    {
        match self {
            Some(v) => Ok(v),
            None => {
                let e = err();
                eprintln!("Warning: {}", e);
                Err(e)
            }
        }
    }
}
// Extension trait for Vec
trait VecExt<T> {
    fn push_if_not_exists(&mut self, value: T)
    where
        T: PartialEq;
}
impl<T> VecExt<T> for Vec<T> {
    fn push_if_not_exists(&mut self, value: T)
    where
        T: PartialEq,
    {
        if !self.contains(&value) {
            self.push(value);
        }
    }
}
fn main() {
    // Using StringExt
    println!("=== StringExt ===");
    let text = "   ";
    println!("'{}' is blank: {}", text, text.is_blank());
    
    let long_text = "This is a very long string that needs truncation";
    println!("Truncated: {}", long_text.truncate_with_ellipsis(20));
    
    // Using IteratorExt
    println!("\n=== IteratorExt ===");
    struct Item { price: i32 }
    let items = vec![
        Item { price: 10 },
        Item { price: 20 },
        Item { price: 30 },
    ];
    let total: i32 = items.iter().sum_by(|item| item.price);
    println!("Total price: {}", total);
    
    // Using OptionExt
    println!("\n=== OptionExt ===");
    let value: Option<i32> = None;
    let result = value.ok_or_else_log(|| "Value was not found");
    println!("Result: {:?}", result);
    
    // Using VecExt
    println!("\n=== VecExt ===");
    let mut numbers = vec![1, 2, 3];
    numbers.push_if_not_exists(2); // Won't add - already exists
    numbers.push_if_not_exists(4); // Will add
    println!("Numbers: {:?}", numbers);
}
```

--------------------------------

### Implementing the Adapter Pattern

Source: https://idiomatic-rust-snippets.org/patterns/structural/adapter.html

This example demonstrates how to wrap an Adaptee struct that has a specific_request method to implement the Target trait, allowing it to be used via the request method.

```rust
// The existing interface that we want to adapt
trait Target {
    fn request(&self) -> String;
}
// The adaptee class with a different interface
struct Adaptee;
impl Adaptee {
    fn specific_request(&self) -> String {
        "specific request".to_string()
    }
}
// The adapter class that makes Adaptee compatible with Target
struct Adapter {
    adaptee: Adaptee,
}
impl Adapter {
    fn new(adaptee: Adaptee) -> Self {
        Adapter { adaptee }
    }
}
impl Target for Adapter {
    fn request(&self) -> String {
        // Translate the interface of Adaptee to the Target interface
        self.adaptee.specific_request()
    }
}
fn main() {
    let adaptee = Adaptee;
    let adapter = Adapter::new(adaptee);
    // Client code can use the adapter as if it were a Target
    println!("Adapter request: {}", adapter.request());
}
```

--------------------------------

### Define modules in separate files

Source: https://idiomatic-rust-snippets.org/essentials/core-concepts/module.html

Organize code by splitting modules into separate files. This example shows the directory structure and the contents of main.rs and my_module.rs.

```text
src/
├── main.rs
└── my_module.rs
```

```rust
mod my_module;

fn main() {
    my_module::say_hello();
}
```

```rust
pub fn say_hello() {
    println!("Hello from my_module!");
}
```

--------------------------------

### Compound Assignment Operators Example

Source: https://idiomatic-rust-snippets.org/essentials/operators/assignement-operations.html

Demonstrates the use of various compound assignment operators including addition, subtraction, multiplication, division, and remainder assignment.

```rust
fn main() {
    let mut a = 10;
    a += 5; // Addition assignment
    println!("a += 5: {}", a);
    a -= 3; // Subtraction assignment
    println!("a -= 3: {}", a);
    a *= 2; // Multiplication assignment
    println!("a *= 2: {}", a);
    a /= 4; // Division assignment
    println!("a /= 4: {}", a);
    a %= 3; // Remainder assignment
    println!("a %= 3: {}", a);
}
```

--------------------------------

### Compare Traditional Decorator and Idiomatic Builder Pattern

Source: https://idiomatic-rust-snippets.org/patterns/structural/builder-pattern.html

This example demonstrates the difference between using heap-allocated trait objects for decoration and using the builder pattern for zero-cost, stack-based composition.

```rust
// Approach 1: Traditional Decorator with trait objects
// Works but requires heap allocations and dynamic dispatch
trait Coffee {
    fn cost(&self) -> f64;
    fn description(&self) -> String;
}
struct SimpleCoffee;
impl Coffee for SimpleCoffee {
    fn cost(&self) -> f64 {
        5.0
    }
    fn description(&self) -> String {
        "Simple coffee".to_string()
    }
}
struct MilkDecorator {
    coffee: Box<dyn Coffee>,
}
impl MilkDecorator {
    fn new(coffee: Box<dyn Coffee>) -> Self {
        MilkDecorator { coffee }
    }
}
impl Coffee for MilkDecorator {
    fn cost(&self) -> f64 {
        self.coffee.cost() + 1.5
    }
    fn description(&self) -> String {
        format!("{}, with milk", self.coffee.description())
    }
}
struct SugarDecorator {
    coffee: Box<dyn Coffee>,
}
impl SugarDecorator {
    fn new(coffee: Box<dyn Coffee>) -> Self {
        SugarDecorator { coffee }
    }
}
impl Coffee for SugarDecorator {
    fn cost(&self) -> f64 {
        self.coffee.cost() + 0.5
    }
    fn description(&self) -> String {
        format!("{}, with sugar", self.coffee.description())
    }
}
// Approach 2: Idiomatic Rust using Newtype pattern
// Zero-cost abstraction with compile-time guarantees
struct BaseCoffee {
    cost: f64,
    description: String,
}
impl BaseCoffee {
    fn simple() -> Self {
        BaseCoffee {
            cost: 5.0,
            description: "Simple coffee".to_string(),
        }
    }
    fn with_milk(mut self) -> Self {
        self.cost += 1.5;
        self.description.push_str(", with milk");
        self
    }
    fn with_sugar(mut self) -> Self {
        self.cost += 0.5;
        self.description.push_str(", with sugar");
        self
    }
    fn cost(&self) -> f64 {
        self.cost
    }
    fn description(&self) -> &str {
        &self.description
    }
}
fn main() {
    println!("=== Traditional Decorator (heap allocated) ===");
    let simple_coffee = Box::new(SimpleCoffee);
    println!("Cost: ${}, Description: {}", 
        simple_coffee.cost(), 
        simple_coffee.description()
    );
    let milk_coffee = Box::new(MilkDecorator::new(simple_coffee));
    println!("Cost: ${}, Description: {}", 
        milk_coffee.cost(), 
        milk_coffee.description()
    );
    let sugar_milk_coffee = Box::new(SugarDecorator::new(milk_coffee));
    println!("Cost: ${}, Description: {}", 
        sugar_milk_coffee.cost(), 
        sugar_milk_coffee.description()
    );
    println!("\n=== Idiomatic Rust (builder pattern, zero-cost) ===");
    let coffee = BaseCoffee::simple();
    println!("Cost: ${}, Description: {}", 
        coffee.cost(), 
        coffee.description()
    );
    let coffee = coffee.with_milk();
    println!("Cost: ${}, Description: {}", 
        coffee.cost(), 
        coffee.description()
    );
    let coffee = coffee.with_sugar();
    println!("Cost: ${}, Description: {}", 
        coffee.cost(), 
        coffee.description()
    );
    // Can also chain methods
    let fancy_coffee = BaseCoffee::simple()
        .with_milk()
        .with_sugar();
    println!("\nChained: Cost: ${}, Description: {}",
        fancy_coffee.cost(),
        fancy_coffee.description()
    );
}
```

--------------------------------

### Good Library Practice: Returning Result

Source: https://idiomatic-rust-snippets.org/anti-patterns/error-handling/panic-in-libraries.html

This example shows the idiomatic approach of returning a Result type, allowing the application to handle errors gracefully without crashing.

```rust
// Library code - GOOD
pub fn parse_port(s: &str) -> Result<u16, String> {
    if s.is_empty() {
        return Err("Port string cannot be empty".to_string());
    }
    
    match s.parse::<u16>() {
        Ok(port) if port > 0 => Ok(port),
        Ok(_) => Err("Port must be greater than 0".to_string()),
        Err(_) => Err(format!("Invalid port number: {}", s)),
    }
}
// Application code
fn main() {
    let ports = vec!["8080", "0", "invalid", "3000"];
    
    for port_str in ports {
        match parse_port(port_str) {
            Ok(port) => println!("Using port: {}", port),
            Err(e) => eprintln!("Skipping invalid port '{}': {}", port_str, e),
        }
    }
    // Prints:
    // Using port: 8080
    // Skipping invalid port '0': Port must be greater than 0
    // Skipping invalid port 'invalid': Invalid port number: invalid
    // Using port: 3000
}
```

--------------------------------

### Implement Flyweight Pattern with Factory

Source: https://idiomatic-rust-snippets.org/patterns/structural/flyweight.html

This example demonstrates a Flyweight struct for shared state and a FlyweightFactory to manage instances using a HashMap and Rc for shared ownership.

```rust
use std::collections::HashMap;
use std::rc::Rc;
// The Flyweight struct that contains the shared state
struct Flyweight {
    shared_state: String,
}
impl Flyweight {
    fn new(shared_state: &str) -> Self {
        Flyweight {
            shared_state: shared_state.to_string(),
        }
    }
    fn operation(&self, unique_state: &str) {
        println!(
            "Flyweight: Displaying shared ({}) and unique ({}) state.",
            self.shared_state, unique_state
        );
    }
}
// The FlyweightFactory that creates and manages Flyweight objects
struct FlyweightFactory {
    flyweights: HashMap<String, Rc<Flyweight>>,
}
impl FlyweightFactory {
    fn new() -> Self {
        FlyweightFactory {
            flyweights: HashMap::new(),
        }
    }
    fn get_flyweight(&mut self, shared_state: &str) -> Rc<Flyweight> {
        if !self.flyweights.contains_key(shared_state) {
            println!("FlyweightFactory: Creating new flyweight for state '{}'.", shared_state);
            let flyweight = Rc::new(Flyweight::new(shared_state));
            self.flyweights.insert(shared_state.to_string(), flyweight);
        } else {
            println!("FlyweightFactory: Reusing existing flyweight for state '{}'.", shared_state);
        }
        Rc::clone(self.flyweights.get(shared_state).unwrap())
    }
}
fn main() {
    let mut factory = FlyweightFactory::new();
    let flyweight1 = factory.get_flyweight("shared1");
    flyweight1.operation("unique1");
    let flyweight2 = factory.get_flyweight("shared2");
    flyweight2.operation("unique2");
    let flyweight3 = factory.get_flyweight("shared1");
    flyweight3.operation("unique3");
}
```

--------------------------------

### Manual Indexing Anti-Pattern

Source: https://idiomatic-rust-snippets.org/anti-patterns/code-structure/manual-indexing.html

This example demonstrates manual indexing using a range loop, which causes a runtime panic when accessing the last element plus one.

```rust
fn sum_adjacent_pairs(numbers: Vec<i32>) -> Vec<i32> {
    let mut sums = Vec::new();
    
    for i in 0..numbers.len() {
        let sum = numbers[i] + numbers[i + 1]; // Panics when i = numbers.len() - 1
        sums.push(sum);
    }
    
    sums
}
fn main() {
    let numbers = vec![1, 2, 3, 4, 5];
    let sums = sum_adjacent_pairs(numbers);
    println!("Adjacent sums: {:?}", sums);
}
```

--------------------------------

### Bad Library Practice: Panicking on Invalid Input

Source: https://idiomatic-rust-snippets.org/anti-patterns/error-handling/panic-in-libraries.html

This example demonstrates a library function that panics when it encounters invalid input, causing the entire application to crash.

```rust
// Library code - BAD
pub fn parse_port(s: &str) -> u16 {
    if s.is_empty() {
        panic!("Port string cannot be empty");
    }
    
    match s.parse::<u16>() {
        Ok(port) if port > 0 => port,
        Ok(_) => panic!("Port must be greater than 0"),
        Err(_) => panic!("Invalid port number: {}", s),
    }
}
// Application code
fn main() {
    let ports = vec!["8080", "0", "invalid", "3000"];
    
    for port_str in ports {
        let port = parse_port(port_str); // Panics on "0" - crashes the entire app
        println!("Using port: {}", port);
    }
}
```

--------------------------------

### Implementing the Builder Pattern for a House struct

Source: https://idiomatic-rust-snippets.org/patterns/creational/builder.html

This example demonstrates a HouseBuilder struct that uses method chaining to configure properties before consuming the builder to create a final House instance.

```rust
#[derive(Debug)]
struct House {
    walls: u8,
    doors: u8,
    windows: u8,
    has_garage: bool,
    has_swimming_pool: bool,
}
struct HouseBuilder {
    walls: u8,
    doors: u8,
    windows: u8,
    has_garage: bool,
    has_swimming_pool: bool,
}
impl HouseBuilder {
    fn new() -> Self {
        HouseBuilder {
            walls: 0,
            doors: 0,
            windows: 0,
            has_garage: false,
            has_swimming_pool: false,
        }
    }
    fn walls(mut self, count: u8) -> Self {
        self.walls = count;
        self
    }
    fn doors(mut self, count: u8) -> Self {
        self.doors = count;
        self
    }
    fn windows(mut self, count: u8) -> Self {
        self.windows = count;
        self
    }
    fn garage(mut self, has_garage: bool) -> Self {
        self.has_garage = has_garage;
        self
    }
    fn swimming_pool(mut self, has_swimming_pool: bool) -> Self {
        self.has_swimming_pool = has_swimming_pool;
        self
    }
    fn build(self) -> House {
        House {
            walls: self.walls,
            doors: self.doors,
            windows: self.windows,
            has_garage: self.has_garage,
            has_swimming_pool: self.has_swimming_pool,
        }
    }
}
fn main() {
    let house = HouseBuilder::new()
        .walls(4)
        .doors(2)
        .windows(6)
        .garage(true)
        .swimming_pool(false)
        .build();
    println!("{:?}", house);
}
```

--------------------------------

### Create a library crate with --lib flag

Source: https://idiomatic-rust-snippets.org/essentials/core-concepts/crate.html

Use the --lib flag with cargo new to initialize a library crate.

```bash
cargo new my_library_crate --lib
```

--------------------------------

### Create a binary crate with cargo new

Source: https://idiomatic-rust-snippets.org/essentials/core-concepts/crate.html

Use the cargo new command to initialize a new binary crate project.

```bash
cargo new my_binary_crate
```

--------------------------------

### Idiomatic Immutability Example

Source: https://idiomatic-rust-snippets.org/anti-patterns/ownership-memory/excessive-mutability.html

This example shows the corrected version using immutability by default. Any attempt to reassign an immutable variable results in a compiler error, preventing the logic bug seen in the previous example.

```rust
fn calculate_price(base_price: f64, quantity: u32) -> f64 {
    let price = base_price;
    let qty = quantity;
    let tax_rate = 0.08;
    
    let subtotal = price * qty as f64;
    // tax_rate = 0.1; // Compiler error: cannot assign twice to immutable variable
    
    subtotal * (1.0 + tax_rate)
}
fn main() {
    let total = calculate_price(10.0, 5);
    println!("Total: ${:.2}", total); // Prints: $54.00 (correct)
    
    let expected = 10.0 * 5.0 * 1.08;
    println!("Expected: ${:.2}", expected); // Prints: $54.00
}
```

--------------------------------

### Anti-pattern: Using unwrap() for configuration loading

Source: https://idiomatic-rust-snippets.org/anti-patterns/error-handling/unwrap-abuse.html

This example demonstrates code that panics if the environment variable is missing or the file cannot be read. It results in generic, unhelpful panic messages instead of graceful error handling.

```rust
use std::fs;
use std::env;
fn read_config() -> String {
    let path = env::var("CONFIG_PATH").unwrap(); // Panics if env var not set
    let contents = fs::read_to_string(&path).unwrap(); // Panics if file doesn't exist
    contents
}
fn main() {
    let config = read_config();
    println!("Config loaded: {} bytes", config.len());
}
```

--------------------------------

### Diffie-Hellman Key Exchange Implementation

Source: https://idiomatic-rust-snippets.org/algorithms/cryptographic/diffie-hellman.html

This example demonstrates the full Diffie-Hellman workflow, including key generation, public key computation, and shared secret derivation. It includes a modular exponentiation helper function to perform the necessary calculations.

```rust
fn main() {
    // Step 1: Agree on a prime number p and base g
    let p: u64 = 23; // A small prime number for simplicity
    let g: u64 = 5;  // A primitive root modulo p
    // Step 2: Each party generates a private key (using fixed values for demonstration)
    let private_key_a = 6;
    let private_key_b = 15;
    // Step 3: Compute public keys
    let public_key_a = mod_exp(g, private_key_a, p);
    let public_key_b = mod_exp(g, private_key_b, p);
    // Step 4: Exchange public keys (simulated here)
    println!("Public Key A: {}", public_key_a);
    println!("Public Key B: {}", public_key_b);
    // Step 5: Compute shared secret
    let shared_secret_a = mod_exp(public_key_b, private_key_a, p);
    let shared_secret_b = mod_exp(public_key_a, private_key_b, p);
    // Both shared secrets should be the same
    println!("Shared Secret A: {}", shared_secret_a);
    println!("Shared Secret B: {}", shared_secret_b);
    
    assert_eq!(shared_secret_a, shared_secret_b);
    println!("Key exchange successful!");
}
fn mod_exp(base: u64, exp: u64, modulus: u64) -> u64 {
    let mut result = 1;
    let mut base = base % modulus;
    let mut exp = exp;
    while exp > 0 {
        if exp % 2 == 1 {
            result = (result * base) % modulus;
        }
        exp = exp >> 1;
        base = (base * base) % modulus;
    }
    result
}
```

--------------------------------

### Deref abuse example

Source: https://idiomatic-rust-snippets.org/anti-patterns/type-system/deref-abuse.html

This example demonstrates the anti-pattern where Admin implements Deref to User, creating an implicit and confusing 'is-a' relationship.

```rust
use std::ops::Deref;
struct User {
    name: String,
    email: String,
}
struct Admin {
    user: User,
    permissions: Vec<String>,
}
impl Deref for Admin {
    type Target = User;
    
    fn deref(&self) -> &Self::Target {
        &self.user
    }
}
impl User {
    fn display(&self) {
        println!("{} <{}>", self.name, self.email);
    }
}
fn main() {
    let admin = Admin {
        user: User {
            name: "Alice".to_string(),
            email: "alice@example.com".to_string(),
        },
        permissions: vec!["read".to_string(), "write".to_string()],
    };
    
    admin.display(); // Works via Deref, but confusing
    println!("Name: {}", admin.name); // Also works via Deref coercion
}
```

--------------------------------

### RAII Implementation and Usage

Source: https://idiomatic-rust-snippets.org/patterns/rust-idioms/raii.html

This example demonstrates standard library RAII, custom RAII using the Drop trait for a database connection, and the RAII guard pattern. It shows how resources are cleaned up automatically even during nested scopes or early returns.

```rust
use std::fs::File;
use std::io::{Write, BufWriter};
// Standard library types implement RAII automatically
#[allow(dead_code)]
fn write_to_file() -> std::io::Result<()> {
    let file = File::create("example.txt")?;
    let mut writer = BufWriter::new(file);
    
    writer.write_all(b"Hello, RAII!")?;
    
    // File and buffer are automatically closed and flushed when they go out of scope
    Ok(())
}
// Custom RAII: Implementing Drop for automatic cleanup
struct DatabaseConnection {
    connection_id: u32,
    is_connected: bool,
}
impl DatabaseConnection {
    fn new(id: u32) -> Self {
        println!("Opening database connection {}", id);
        DatabaseConnection {
            connection_id: id,
            is_connected: true,
        }
    }
    
    fn query(&self, sql: &str) -> String {
        if self.is_connected {
            format!("Result from connection {}: executed '{}'", self.connection_id, sql)
        } else {
            "Not connected".to_string()
        }
    }
}
impl Drop for DatabaseConnection {
    fn drop(&mut self) {
        println!("Closing database connection {}", self.connection_id);
        self.is_connected = false;
        // In real code: close connection, release resources, etc.
    }
}
// RAII Guard pattern for scoped behavior
#[allow(dead_code)]
struct MutexGuard<'a, T> {
    data: &'a mut T,
    // In real implementation: reference to the mutex
}
impl<T> Drop for MutexGuard<'_, T> {
    fn drop(&mut self) {
        println!("Releasing lock");
        // In real implementation: release the mutex
    }
}
fn main() {
    println!("=== Database Connection RAII ===");
    {
        let conn = DatabaseConnection::new(1);
        println!("{}", conn.query("SELECT * FROM users"));
        // Connection automatically closed here when conn goes out of scope
    }
    println!("Connection is now closed\n");
    
    println!("=== Nested RAII ===");
    {
        let conn1 = DatabaseConnection::new(1);
        {
            let conn2 = DatabaseConnection::new(2);
            println!("{}", conn1.query("Query 1"));
            println!("{}", conn2.query("Query 2"));
            // conn2 dropped here (LIFO order)
        }
        println!("{}", conn1.query("Query 3"));
        // conn1 dropped here
    }
    
    println!("\n=== RAII even with early returns ===");
    fn might_fail(should_fail: bool) -> Result<(), &'static str> {
        let _conn = DatabaseConnection::new(99);
        
        if should_fail {
            return Err("Something went wrong");
            // Connection STILL gets closed!
        }
        
        println!("Success path");
        Ok(())
    }
    
    let _ = might_fail(true);  // Connection closed even on error
    let _ = might_fail(false); // Connection closed normally
}
```

--------------------------------

### Excessive Mutability Anti-pattern Example

Source: https://idiomatic-rust-snippets.org/anti-patterns/ownership-memory/excessive-mutability.html

This example demonstrates the anti-pattern where variables are unnecessarily marked as 'mut', leading to an accidental and silent modification of the 'tax_rate' variable.

```rust
fn calculate_price(base_price: f64, quantity: u32) -> f64 {
    let mut price = base_price;
    let mut qty = quantity;
    let mut tax_rate = 0.08;
    
    let subtotal = price * qty as f64;
    tax_rate = 0.1; // Accidental modification - should have stayed 0.08
    
    subtotal * (1.0 + tax_rate)
}
fn main() {
    let total = calculate_price(10.0, 5);
    println!("Total: ${:.2}", total); // Prints: $55.00 (wrong, should be $54.00)
    
    let expected = 10.0 * 5.0 * 1.08;
    println!("Expected: ${:.2}", expected); // Prints: $54.00
}
```

--------------------------------

### Basic HashMap operations

Source: https://idiomatic-rust-snippets.org/essentials/std-lib/hashmap.html

Demonstrates creating a HashMap, inserting values, retrieving values with pattern matching, updating values, and using the entry API to insert only if a key is missing.

```rust
use std::collections::HashMap;
fn main() {
    // Create a new HashMap
    let mut scores = HashMap::new();
    // Insert some key-value pairs
    scores.insert("Blue", 10);
    scores.insert("Red", 50);
    // Get a value
    match scores.get("Blue") {
        Some(score) => println!("Blue team's score: {}", score),
        None => println!("Blue team not found"),
    }
    // Update a value
    scores.insert("Blue", 25); // This will overwrite the previous value
    // Insert only if key doesn't exist
    scores.entry("Yellow").or_insert(5);
    // Iterate over key-value pairs
    for (key, value) in &scores {
        println!("{}: {}", key, value);
    }
}
```

--------------------------------

### cargo uninstall binary removal

Source: https://idiomatic-rust-snippets.org/essentials/packaging/cargo-commands.html

Command to remove an installed binary crate.

```bash
# Uninstall
cargo uninstall ripgrep
```

--------------------------------

### RSA implementation in Rust

Source: https://idiomatic-rust-snippets.org/algorithms/cryptographic/rsa.html

A complete example demonstrating key generation, encryption, and decryption using small prime numbers. It includes helper functions for modular exponentiation, modular inverse, and the extended Euclidean algorithm.

```rust
extern crate num_bigint as bigint;
extern crate num_traits;
extern crate rand;
use bigint::{BigInt, ToBigInt};
use num_traits::{One, Zero};
use rand::Rng;
fn main() {
     // Generate two large prime numbers (for simplicity, small primes are used here)
     let p = 61.to_bigint().unwrap();
     let q = 53.to_bigint().unwrap();
     
     // Compute n = p * q
     let n = &p * &q;
     
     // Compute φ(n) = (p-1) * (q-1)
     let phi = (&p - 1) * (&q - 1);
     
     // Choose e such that 1 < e < φ(n) and e is coprime with φ(n)
     let e = 17.to_bigint().unwrap();
     
     // Compute d as d ≡ e^(-1) (mod φ(n))
     let d = mod_inverse(&e, &phi).unwrap();
     
     // Public key (e, n) and private key (d, n)
     println!("Public Key: (e: {}, n: {})", e, n);
     println!("Private Key: (d: {}, n: {})", d, n);
     
     // Encrypt a message
     let message = 42.to_bigint().unwrap();
     let ciphertext = mod_exp(&message, &e, &n);
     println!("Encrypted message: {}", ciphertext);
     
     // Decrypt the message
     let decrypted_message = mod_exp(&ciphertext, &d, &n);
     println!("Decrypted message: {}", decrypted_message);
}
// Function to compute modular exponentiation
fn mod_exp(base: &BigInt, exp: &BigInt, modulus: &BigInt) -> BigInt {
     base.modpow(exp, modulus)
}
// Function to compute modular inverse
fn mod_inverse(a: &BigInt, m: &BigInt) -> Option<BigInt> {
     let (g, x, _) = extended_gcd(a, m);
     if g.is_one() {
          Some((x % m + m) % m)
     } else {
          None
     }
}
// Function to compute extended GCD
fn extended_gcd(a: &BigInt, b: &BigInt) -> (BigInt, BigInt, BigInt) {
     if b.is_zero() {
          (a.clone(), BigInt::one(), BigInt::zero())
     } else {
          let (g, x, y) = extended_gcd(b, &(a % b));
          (g, y.clone(), x - (a / b) * y)
     }
}
```

--------------------------------

### Mutable Borrowing Example

Source: https://idiomatic-rust-snippets.org/essentials/core-concepts/borrow.html

Demonstrates passing a mutable reference to a function to modify the original value.

```rust
fn main() {
    let mut s = String::from("hello");
    change(&mut s); // Borrow s mutably
    println!("{}", s); // s is still valid here and has been modified
}
fn change(some_string: &mut String) {
    some_string.push_str(", world"); // Modify the borrowed value
}
```

--------------------------------

### Library crate lib.rs entry point

Source: https://idiomatic-rust-snippets.org/essentials/core-concepts/crate.html

The standard lib.rs file for a library crate containing public functions.

```rust
pub fn hello() {
    println!("Hello, library!");
}
```

--------------------------------

### FFI and Low-Level Pointer Management with Box

Source: https://idiomatic-rust-snippets.org/essentials/std-lib/box.html

Shows how to convert a Box to a raw pointer and back, which is useful for FFI. Note that manual management is required when using raw pointers.

```rust
fn main() {
    let boxed = Box::new(42);
    
    // Convert to raw pointer (leaks, manual management needed)
    let raw = Box::into_raw(boxed);
    
    // Use raw pointer
    unsafe {
        println!("Value: {}", *raw);
        
        // Convert back to Box (now it will be properly dropped)
        let boxed_again = Box::from_raw(raw);
    }
}
```

--------------------------------

### Watch for changes with cargo watch

Source: https://idiomatic-rust-snippets.org/essentials/packaging/cargo-commands.html

Automatically run commands when files change. Requires installation of cargo-watch.

```bash
# Install cargo-watch
cargo install cargo-watch

# Watch and run checks
cargo watch -x check

# Watch and run tests
cargo watch -x test

# Chain commands
cargo watch -x check -x test -x run
```

--------------------------------

### Expand macros with cargo expand

Source: https://idiomatic-rust-snippets.org/essentials/packaging/cargo-commands.html

View expanded macro code. Requires the cargo-expand tool to be installed.

```bash
# Expand macros in current crate
cargo expand

# Expand specific module
cargo expand module::path
```

--------------------------------

### Simplified Bcrypt Implementation

Source: https://idiomatic-rust-snippets.org/algorithms/cryptographic/bcrypt.html

A demonstration of password hashing using a salt and cost factor. This implementation is for educational purposes only and should not be used in production environments.

```rust
use std::time::{SystemTime, UNIX_EPOCH};
const BCRYPT_COST: u32 = 12;
const BCRYPT_HASH_LEN: usize = 24;
fn generate_salt() -> String {
    // Generate a simple salt based on timestamp for demonstration
    let timestamp = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap()
        .as_nanos();
    
    format!("{:016x}", timestamp % (1u128 << 64))
}
fn bcrypt_hash(password: &str, salt: &str) -> String {
    let mut hash = vec![0u8; BCRYPT_HASH_LEN];
    let cost = BCRYPT_COST;
    let password_bytes = password.as_bytes();
    let salt_bytes = salt.as_bytes();
    // Simulate bcrypt hashing (this is a simplified version)
    for i in 0..BCRYPT_HASH_LEN {
        hash[i] = password_bytes[i % password_bytes.len()] 
                ^ salt_bytes[i % salt_bytes.len()] 
                ^ (cost as u8)
                ^ ((i * 7) as u8); // Add some variation
    }
    // Simple base64-like encoding
    hash.iter()
        .map(|&b| format!("{:02x}", b))
        .collect::<String>()
}
fn main() {
    let password = "my_secure_password";
    let salt = generate_salt();
    let hashed_password = bcrypt_hash(password, &salt);
    println!("Password: {}", password);
    println!("Salt: {}", salt);
    println!("Hashed Password: {}", hashed_password);
    
    // Verify that same password with same salt produces same hash
    let verify_hash = bcrypt_hash(password, &salt);
    assert_eq!(hashed_password, verify_hash);
    println!("Hash verification successful!");
}
```

--------------------------------

### Immutable Borrowing Example

Source: https://idiomatic-rust-snippets.org/essentials/core-concepts/borrow.html

Demonstrates passing a reference to a function to read its length without taking ownership.

```rust
fn main() {
    let s1 = String::from("hello");
    let len = calculate_length(&s1); // Borrow s1 immutably
    println!("The length of '{}' is {}.", s1, len); // s1 is still valid here
}
fn calculate_length(s: &String) -> usize {
    s.len() // Use the borrowed value
}
```

--------------------------------

### Get current system time

Source: https://idiomatic-rust-snippets.org/essentials/packaging/modules.html

Retrieves the current system time and calculates the duration since the UNIX epoch.

```rust
use std::time::{SystemTime, UNIX_EPOCH};
fn main() {
    // Get the current system time
    match SystemTime::now().duration_since(UNIX_EPOCH) {
        Ok(n) => println!("Current time since UNIX EPOCH: {} seconds", n.as_secs()),
        Err(_) => println!("SystemTime before UNIX EPOCH!"),
    }
}
```

--------------------------------

### Basic Box usage

Source: https://idiomatic-rust-snippets.org/essentials/std-lib/box.html

Demonstrates storing an integer on the heap using Box::new.

```rust
fn main() {
    // Store an integer on the heap
    let boxed_int = Box::new(5);
    
    println!("Boxed value: {}", boxed_int);
    
    // Automatically deallocated when boxed_int goes out of scope
}
```

--------------------------------

### Declare and initialize scalar types

Source: https://idiomatic-rust-snippets.org/essentials/types/scalar.html

This example shows the declaration and initialization of i32, f64, bool, and char types in a main function.

```rust
fn main() {
    let x: i32 = 42; // Integer
    let y: f64 = 3.14; // Floating-point number
    let is_active: bool = true; // Boolean
    let letter: char = 'A'; // Character
    println!("x: {}, y: {}, is_active: {}, letter: {}", x, y, is_active, letter);
}
```

--------------------------------

### Define a basic closure

Source: https://idiomatic-rust-snippets.org/essentials/core-concepts/closure.html

Closures are defined using the pipe syntax. This example demonstrates a simple closure that adds two numbers.

```rust
fn main() {
    let add = |a, b| a + b;
    println!("Sum: {}", add(2, 3)); // Output: Sum: 5
}
```
Tokens:
Raw