WeReply: Skill for Claude Code

Rust Optimization Skill

Advanced Rust optimization techniques for high-performance feed formula calculation and linear programming.

Performance Optimization Strategies

1. Caching Strategy (Moka)

Use moka::future::Cache for frequently accessed data:

use moka::future::Cache;
use std::time::Duration;

pub struct MaterialService {
    cache: Cache<String, Material>,
}

impl MaterialService {
    pub fn new() -> Self {
        Self {
            cache: Cache::builder()
                .max_capacity(1000)
                .time_to_live(Duration::from_secs(3600))
                .build(),
        }
    }

    pub async fn get_material(&self, code: &str) -> Result<Material> {
        self.cache
            .try_get_with(code.to_string(), async {
                self.repository.find_by_code(code).await
            })
            .await
    }
}

When to cache:

• Database query results that don't change often
• Computed nutrition values
• Expensive calculation results
• Reference data (materials, species standards)

2. Parallel Processing (Rayon)

Use rayon for CPU-intensive parallel computations:

use rayon::prelude::*;

pub fn calculate_nutrition_batch(
    materials: &[Material],
    proportions: &[f64],
) -> Vec<NutritionResult> {
    materials
        .par_iter()  // Parallel iterator
        .zip(proportions.par_iter())
        .map(|(material, proportion)| {
            calculate_material_nutrition(material, *proportion)
        })
        .collect()
}

Best practices:

• Use parallel iterators for embarrassingly parallel problems
• Benchmark to verify performance gains
• Avoid parallelizing small operations (overhead costs)
• Consider memory bandwidth limitations

3. Memory Optimization

Avoid Unnecessary Clones

// ❌ Bad - unnecessary clone
fn process(data: Vec<String>) -> Vec<String> {
    data.clone()
}

// ✅ Good - transfer ownership
fn process(data: Vec<String>) -> Vec<String> {
    data
}

Use References Where Possible

// ❌ Bad - takes ownership
fn calculate(materials: Vec<Material>) -> f64 {
    // ...
}

// ✅ Good - borrows data
fn calculate(materials: &[Material]) -> f64 {
    // ...
}