Clean Function Design in Rust

Welcome to your next step in mastering Clean Code! 🚀 In previous lessons, we discussed the importance of meaningful naming conventions. Now, we move into the realm of functions, which are the backbone of application logic and essential for code organization and execution. Structuring these functions effectively is vital for enhancing the clarity and maintainability of a codebase. In this lesson, we will explore best practices and techniques to ensure our code remains clean, efficient, and readable, leveraging Rust's powerful features.

Below are the key principles for writing clean functions in Rust:

• Keep functions small. Small functions are easier to read, comprehend, and maintain.
• Focus on a single task (Single Responsibility Principle). A function dedicated to one task is more reliable and easier to debug.
• Limit arguments to three or fewer. Excessive arguments make function signatures complicated and functions difficult to understand and use.
• Avoid boolean flags. Boolean flags can obscure the code's purpose; consider using enums to represent different behaviors more expressively.
• Eliminate side effects. Rust's default immutability helps prevent unintended side effects, making code more predictable and easier to understand; more generally, avoid altering external state or relying on external changes.
• Implement the DRY principle. Employ helper functions and leverage traits to reduce redundancy, enhance maintainability, and enable polymorphism.

Let's dive deeper into each of these principles.

Functions should remain small. If they become too large, consider splitting them into multiple, focused functions: while there's no strict limit on lines of code, maintaining readability and manageability is key.

Consider the process_order function below, which is manageable but has the potential to become unwieldy:

use log::{error, info};

// Not Clean - Overly Complex Function
fn process_order(order: &mut Order, inventory: &mut Inventory) {
    // Step 1: Validate the order
    if !order.is_valid() {
        error!("Invalid Order");
        return;
    }
    // Step 2: Process payment
    if !order.process_payment() {
        error!("Payment failed");
        return;
    }
    // Step 3: Update inventory
    inventory.update(order.get_items());

    // Step 4: Notify customer
    order.notify_customer();

    // Step 5: Log order processing
    info!("Order processed successfully");
}

To improve this process, we can extract each step into dedicated functions and handle errors idiomatically using the Result type and the ? operator:

use log::{error, info};

// Clean - Using Small Functions and Idiomatic Error Handling 🌟

fn process_order(order: &mut Order, inventory: &mut Inventory) -> Result<(), OrderError> {
    validate_order(order)?;
    process_payment(order)?;
    update_inventory(order, inventory)?;
    notify_customer(order)?;
    log_order_processing()?;
    Ok(())
}

fn validate_order(order: &Order) -> Result<(), OrderError> {
    if order.is_valid() {
        Ok(())
    } else {
        error!("Invalid Order");
        Err(OrderError::InvalidOrder)
    }
}

fn process_payment(order: &mut Order) -> Result<(), OrderError> {
    if order.process_payment() {
        Ok(())
    } else {
        error!("Payment failed");
        Err(OrderError::PaymentFailed)
    }
}

fn update_inventory(order: &Order, inventory: &mut Inventory) -> Result<(), InventoryError> {
    inventory.update(order.get_items())
}

fn notify_customer(order: &Order) -> Result<(), NotificationError> {
    order.notify_customer()
}

fn log_order_processing() -> Result<(), LogError> {
    info!("Order processed successfully");
    Ok(())
}

By breaking down process_order into smaller functions and using Result with the ? operator, we make error handling more idiomatic and the codebase cleaner. This approach also leverages Rust's powerful type system for better error management.