Safely Extracting Data with Option using if let

Rust's Option enum is crucial for handling the potential absence of a value. Often, you'll want to perform an action only if a value is present. This challenge focuses on using the if let construct to elegantly and safely unwrap Option types, a fundamental pattern in idiomatic Rust.

Problem Description

You will be given a function that processes an Option<String>. Your task is to implement this function using if let to conditionally execute code only when the Option contains a Some value. Specifically, if the Option is Some(value), you should print the value. If the Option is None, you should do nothing.

Requirements:

• Use if let to pattern match on the Option<String>.
• If the Option is Some(s), print the string s.
• If the Option is None, the function should simply return without printing anything.

Expected Behavior:

• When provided with Some("Hello, Rust!"), the output should be Hello, Rust!.
• When provided with None, there should be no output.

Examples

Example 1:

Input: Some("Coding Challenge")
Output: Coding Challenge
Explanation: The `if let` statement matches `Some("Coding Challenge")`, so the inner code block is executed, printing the contained string.

Example 2:

Input: None
Output: (no output)
Explanation: The `if let` statement does not match `None`, so the inner code block is skipped, and nothing is printed.

Example 3:

Input: Some("  Extra Spaces  ")
Output:   Extra Spaces
Explanation: The `if let` correctly extracts the string, including leading and trailing whitespace, and prints it as is.

Constraints

• The input to the function will always be of type Option<String>.
• The output should be printed to standard output.
• Performance is not a critical concern for this challenge; clarity and correctness are prioritized.

Notes

The if let syntax is a powerful tool for concisely handling enum variants. Think about how if let allows you to destructure the Some variant and bind its inner value to a variable, making it immediately available within the conditional block. Consider how this differs from a full match statement for this specific scenario where you only care about one variant.