Rust for C-Programmers

8.6 Default Parameters and Named Arguments

Rust does not provide built-in support for default function parameters or named arguments, in contrast to some other languages. All function arguments must be explicitly provided in the exact order defined by the function signature.

8.6.1 Alternative Approaches Using Option<T> or the Builder Pattern

Although Rust lacks default parameters, you can simulate similar behavior using techniques such as Option<T> or the builder pattern.

Using Option<T> for Optional Arguments

fn display(message: &str, repeat: Option<u32>) {
    let count = repeat.unwrap_or(1);
    for _ in 0..count {
        println!("{}", message);
    }
}

fn main() {
    display("Hello", None);      // Defaults to 1 repetition
    display("Goodbye", Some(3)); // Repeats 3 times
}

The Option<T> type allows you to omit an argument by passing None, while Some(value) provides an alternative. If None is passed, the function substitutes a default value using unwrap_or(1). Option is discussed in detail in Chapter 15.

Implementing a Builder Pattern

struct DisplayConfig {
    message: String,
    repeat: u32,
}

impl DisplayConfig {
    fn new(msg: &str) -> Self {
        DisplayConfig {
            message: msg.to_string(),
            repeat: 1, // Default value
        }
    }

    fn repeat(mut self, times: u32) -> Self {
        self.repeat = times;
        self
    }

    fn show(&self) {
        for _ in 0..self.repeat {
            println!("{}", self.message);
        }
    }
}

fn main() {
    DisplayConfig::new("Hello").show();         // Defaults to 1 repetition
    DisplayConfig::new("Hi").repeat(3).show();  // Repeats 3 times
}

The builder pattern provides flexibility through method chaining. It initializes a struct with default values and allows further modifications using methods that take ownership (self) and return the updated struct. Methods and struct usage are covered in later sections.

Both approaches allow configurable function parameters while preserving Rust’s strict type and ownership guarantees.