code-simplifier

Rust Code Simplifier

Proactive pattern guide for writing simple, idiomatic Rust. Apply these patterns whenever writing or modifying Rust code — not only when asked to simplify.

Project rules: These patterns align with .claude/rules/rust-patterns.md. When in doubt, re-read the rules file.

1. Iterator Chains Over Manual Loops

Use iterator chains for transformation logic. Reserve for loops only when the body needs early error returns with ?.

// WRONG
let mut names = Vec::new();
for tool in tools {
    if tool.is_available() {
        names.push(tool.name().to_owned());
    }
}

// RIGHT
let names: Vec<String> = tools
    .iter()
    .filter(|t| t.is_available())
    .map(|t| t.name().to_owned())
    .collect();

When to keep a loop: The body calls fallible operations with ?:

// Loop is correct here — early return on error
for entry in entries {
    let meta = entry.metadata().context("failed to read metadata")?;
    process(&meta).await?;
}

2. Option/Result Chaining

Flatten nested match/if let on Option/Result into chained combinators or ?.

// WRONG — nested match pyramid
match config.project.as_ref() {
    Some(project) => match project.settings.as_ref() {
        Some(settings) => match settings.get("key") {
            Some(val) => Some(val.to_owned()),
            None => None,
        },
        None => None,
    },
    None => None,
}

// RIGHT — ? operator for Option propagation
config
    .project
    .as_ref()?
    .settings
    .as_ref()?
    .get("key")
    .map(|v| v.to_owned())

Combinator quick reference:

Pattern	Use when
?	Propagate None/Err to caller
.map()	Transform inner value
.and_then()	Chain operations that return Option/Result
.unwrap_or_default()	Fallback to Default impl
.unwrap_or_else(|| ...)	Fallback with computation

3. Early Returns

Guard against invalid/empty states at the top. Avoid deep nesting for the main logic.