Default Generic Parameters

In this lesson, you will learn how to reduce boilerplate code in your Rust programs by assigning sensible default types to your generic parameters.

Simplifying Generic Definitions

When you define a generic struct or function, Rust usually requires you to specify every type parameter every time you use it. However, if a specific type is used in the vast majority of your use cases, you can provide a "fallback" type. This is known as a default generic parameter.

Imagine you are building a data processing pipeline where most users will process data as Strings, but you want to allow for flexibility:

// We define T, but set it to String by default
struct DataProcessor<T = String> {
    data: T,
}

fn main() {
    // We don't need to specify <String>, the compiler assumes it!
    let default_proc = DataProcessor { data: String::from("Hello") };
    
    // We can still override it if we need to use a different type
    let custom_proc = DataProcessor::<i32> { data: 42 };
}

Why Use Defaults?

Default generic parameters are essentially "syntactic sugar" that makes your library code much friendlier to use. By providing a default, you hide complexity from the user until they actually need to do something advanced.

This works for structs, enums, and even trait definitions. When you define a type like struct MyStruct<T = i32>, the compiler knows that if the user doesn't provide a type, they mean i32. If the user does provide a type, the compiler respects that choice and ignores the default.

Note that once you provide a default for a generic parameter, all subsequent generic parameters in that list must also have defaults. This ensures that the compiler always knows how to resolve the remaining types if the user provides only some of the parameters.

Key Takeaway: Default generic parameters allow you to simplify your API by providing common-sense type defaults while maintaining full flexibility for advanced users.