E0131 in Rust: Non-exhaustive patterns when matching a type with `#[non_exhaustive]`

When working with the Rust programming language, especially when harnessing the power of enums and struct variants, one might encounter the compiler error E0131. This error indicates that a pattern used in a match expression or an if let statement does not account for all possible forms of a non-exhaustive enum or struct. Understanding and resolving this error is crucial for any Rustacean, especially if you are dealing with types marked with #[non_exhaustive].

Understanding #[non_exhaustive]

The #[non_exhaustive] attribute is used in Rust to indicate that there might be future extensions or additional variants in an enum or struct. By marking something as non-exhaustive, library authors signal that more variants might be added over time, which is a good practice for maintaining library versioning and API stability.

Here is a simple example of how a non-exhaustive enum might look:

#[non_exhaustive]
enum AppError {
    NotFound,
    Unauthorized,
    InternalError,
}

When using this enum in match expressions, you must include a wildcard arm (_) to handle any future variants:

fn handle_error(err: AppError) {
    match err {
        AppError::NotFound => println!("Error: Not Found"),
        AppError::Unauthorized => println!("Error: Unauthorized"),
        AppError::InternalError => println!("Error: Internal Error"),
        _ => println!("Error: Unknown"),
    }
}

The Significance of E0131

Error code E0131 appears when the match arms do not cover all possibilities of the non-exhaustive type. It signifies compiler checks that prevent assumptions about future versions of the enum. Here's what happens when such checks aren't meticulously accounted for:

fn handle_other_error(err: AppError) {
    match err {
        AppError::NotFound => println!("Error: Not Found"),
        AppError::Unauthorized => println!("Error: Unauthorized"),
        // missing the catch-all pattern
    }
}
// This code will trigger E0131 because the match arms are not exhaustive.

Strategies to Resolve E0131

To resolve Error E0131, ensure you're covering all possible cases by using the wildcard _ arm:

• Add a Wildcard Pattern: This is the most straightforward fix—a catch-all branch for anything unexpected or new:

fn handle_error_with_catchall(err: AppError) {
    match err {
        AppError::NotFound => println!("Error: Not Found"),
        AppError::Unauthorized => println!("Error: Unauthorized"),
        AppError::InternalError => println!("Error: Internal Error"),
        _ => println!("Error: Unrecognized or internal error"),
    }
}

• Refactor to Handle Changes: In some cases, consider refactoring your approach or accepting the responsibility of catching future variants through more general logic.
• Understand the Contract: When consuming APIs with #[non_exhaustive], embrace the traditional adjustment period with your code so as to prevent future errors and embrace newer versions.