Sometimes, you only need to handle a specific case of an enum variant, in this case using a match
statement can be overkill. Rust provides a more concise way to handle such cases using the if let
construct. This allows you to match a single variant of an enum and extract its value in a single line.
Here's an example:
enum Ip {
V4(String),
V6(String),
}
if let Ip::V4(ip) = &ip {
println!("IPv4 address: {}", ip);
}
You are provided an enum called Message
with the following variants:
Text(String)
: Represents a textual message.Number(i32)
: Represents a numerical message.Quit
: Represents a command to quit.None
: Represents no message.Your task is to implement the function process_text_message
that takes a reference to a Message
enum. For the Text
variant, the function should return "Processed Text: <content>"
, replacing <content>
with the actual string.
If the input is any other variant of the enum, the function should return "Unhandled Message"
.
Try to solve this using the if let
construct.
if let
construct like this:
if let EnumVariant(value) = &enum_instance {
// Perform actions with `value`.
}
"Unhandled Message"
for all other variants not explicitly matched.pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { // Your code here... if let Message::Text(s) = message { format!("Processed Text: {}", s) } else { String::from("Unhandled Message") }}pub fn main() { assert_eq!( process_text_message(&Message::Text(String::from("Hello"))), "Processed Text: Hello" ); assert_eq!( process_text_message(&Message::Number(42)), "Unhandled Message" ); assert_eq!(process_text_message(&Message::Quit), "Unhandled Message"); assert_eq!(process_text_message(&Message::None), "Unhandled Message");}
pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { if let Message::Text(content) = message { return format!("Processed Text: {}", content) } String::from("Unhandled Message")}pub fn main() { assert_eq!( process_text_message(&Message::Text(String::from("Hello"))), "Processed Text: Hello" ); assert_eq!( process_text_message(&Message::Number(42)), "Unhandled Message" ); assert_eq!(process_text_message(&Message::Quit), "Unhandled Message"); assert_eq!(process_text_message(&Message::None), "Unhandled Message");}
pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { // Your code here... if let Message::Text(content) = &message { return format!("Processed Text: {}", content); } String::from("Unhandled Message")}pub fn main() { assert_eq!( process_text_message(&Message::Text(String::from("Hello"))), "Processed Text: Hello" ); assert_eq!( process_text_message(&Message::Number(42)), "Unhandled Message" ); assert_eq!(process_text_message(&Message::Quit), "Unhandled Message"); assert_eq!(process_text_message(&Message::None), "Unhandled Message");}
pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { // Your code here... if let Message::Text(content) = &message { return format!("Processed Text: {}", content); } String::from("Unhandled Message")}pub fn main() { assert_eq!( process_text_message(&Message::Text(String::from("Hello"))), "Processed Text: Hello" ); assert_eq!( process_text_message(&Message::Number(42)), "Unhandled Message" ); assert_eq!(process_text_message(&Message::Quit), "Unhandled Message"); assert_eq!(process_text_message(&Message::None), "Unhandled Message");}
pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { // Your code here... if let Message::Text(content) = &message { format!("Processed Text: {}", content) } else { String::from("Unhandled Message") }}pub fn main() { assert_eq!( process_text_message(&Message::Text(String::from("Hello"))), "Processed Text: Hello" ); assert_eq!( process_text_message(&Message::Number(42)), "Unhandled Message" ); assert_eq!(process_text_message(&Message::Quit), "Unhandled Message"); assert_eq!(process_text_message(&Message::None), "Unhandled Message");}
pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { if let Message::Text(message) = message { return format!("Processed Text: {message}") } String::from("Unhandled Message")}pub fn main() { assert_eq!( process_text_message(&Message::Text(String::from("Hello"))), "Processed Text: Hello" ); assert_eq!( process_text_message(&Message::Number(42)), "Unhandled Message" ); assert_eq!(process_text_message(&Message::Quit), "Unhandled Message"); assert_eq!(process_text_message(&Message::None), "Unhandled Message");}
pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { if let Message::Text(content) = &message { return format!("Processed Text: {content}"); } String::from("Unhandled Message")}pub fn main() { assert_eq!( process_text_message(&Message::Text(String::from("Hello"))), "Processed Text: Hello" ); assert_eq!( process_text_message(&Message::Number(42)), "Unhandled Message" ); assert_eq!(process_text_message(&Message::Quit), "Unhandled Message"); assert_eq!(process_text_message(&Message::None), "Unhandled Message");}
pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { if let Message::Text(msg) = message { return format!("Processed Text: {msg}"); } String::from("Unhandled Message")}pub fn main() { assert_eq!( process_text_message(&Message::Text(String::from("Hello"))), "Processed Text: Hello" ); assert_eq!( process_text_message(&Message::Number(42)), "Unhandled Message" ); assert_eq!(process_text_message(&Message::Quit), "Unhandled Message"); assert_eq!(process_text_message(&Message::None), "Unhandled Message");}
pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { // Your code here... if let Message::Text(message) = message { return format!("Processed Text: {message}") } String::from("Unhandled Message")}pub fn main() { assert_eq!( process_text_message(&Message::Text(String::from("Hello"))), "Processed Text: Hello" ); assert_eq!( process_text_message(&Message::Number(42)), "Unhandled Message" ); assert_eq!(process_text_message(&Message::Quit), "Unhandled Message"); assert_eq!(process_text_message(&Message::None), "Unhandled Message");}
pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { if let Message::Text(m) = message { format!("Processed Text: {m}") } else { String::from("Unhandled Message") }}pub fn main() { assert_eq!( process_text_message(&Message::Text(String::from("Hello"))), "Processed Text: Hello" ); assert_eq!( process_text_message(&Message::Number(42)), "Unhandled Message" ); assert_eq!(process_text_message(&Message::Quit), "Unhandled Message"); assert_eq!(process_text_message(&Message::None), "Unhandled Message");}
pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { if let Message::Text(content) = message { return format!("Processed Text: {content}").into(); } String::from("Unhandled Message")}pub fn main() { assert_eq!( process_text_message(&Message::Text(String::from("Hello"))), "Processed Text: Hello" ); assert_eq!( process_text_message(&Message::Number(42)), "Unhandled Message" ); assert_eq!(process_text_message(&Message::Quit), "Unhandled Message"); assert_eq!(process_text_message(&Message::None), "Unhandled Message");}
pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { if let Message::Text(msg) = message { return format!("Processed Text: {}", msg); } String::from("Unhandled Message")}pub fn main() { assert_eq!( process_text_message(&Message::Text(String::from("Hello"))), "Processed Text: Hello" ); assert_eq!( process_text_message(&Message::Number(42)), "Unhandled Message" ); assert_eq!(process_text_message(&Message::Quit), "Unhandled Message"); assert_eq!(process_text_message(&Message::None), "Unhandled Message");}
pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { // Your code here... if let Message::Text(content) = message { return format!("Processed Text: {}", content) } String::from("Unhandled Message")}pub fn main() { assert_eq!( process_text_message(&Message::Text(String::from("Hello"))), "Processed Text: Hello" ); assert_eq!( process_text_message(&Message::Number(42)), "Unhandled Message" ); assert_eq!(process_text_message(&Message::Quit), "Unhandled Message"); assert_eq!(process_text_message(&Message::None), "Unhandled Message");}
pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { // Your code here... if let Message::Text(content) = message { return format!("Processed Text: {}", content) } String::from("Unhandled Message")}pub fn main() { assert_eq!( process_text_message(&Message::Text(String::from("Hello"))), "Processed Text: Hello" ); assert_eq!( process_text_message(&Message::Number(42)), "Unhandled Message" ); assert_eq!(process_text_message(&Message::Quit), "Unhandled Message"); assert_eq!(process_text_message(&Message::None), "Unhandled Message");}
pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { // Your code here... if let Message::Text(text) = message{ return format!("Processed Text: {}", text); } String::from("Unhandled Message")}pub fn main() { assert_eq!( process_text_message(&Message::Text(String::from("Hello"))), "Processed Text: Hello" ); assert_eq!( process_text_message(&Message::Number(42)), "Unhandled Message" ); assert_eq!(process_text_message(&Message::Quit), "Unhandled Message"); assert_eq!(process_text_message(&Message::None), "Unhandled Message");}
pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { if let Message::Text(content) = &message { return format!("Processed Text: {content}"); } String::from("Unhandled Message")}pub fn main() { assert_eq!( process_text_message(&Message::Text(String::from("Hello"))), "Processed Text: Hello" ); assert_eq!( process_text_message(&Message::Number(42)), "Unhandled Message" ); assert_eq!(process_text_message(&Message::Quit), "Unhandled Message"); assert_eq!(process_text_message(&Message::None), "Unhandled Message");}
pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { if let Message::Text(content) = message { format!("Processed Text: {content}") } else { String::from("Unhandled Message") }}pub fn main() { assert_eq!( process_text_message(&Message::Text(String::from("Hello"))), "Processed Text: Hello" ); assert_eq!( process_text_message(&Message::Number(42)), "Unhandled Message" ); assert_eq!(process_text_message(&Message::Quit), "Unhandled Message"); assert_eq!(process_text_message(&Message::None), "Unhandled Message");}
pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { if let Message::Text(text) = message { return format!("Processed Text: {text}"); } String::from("Unhandled Message")}
pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { // Your code here... if let Message::Text(msg) = message { return format!("Processed Text: {}",msg); } String::from("Unhandled Message")}pub fn main() { assert_eq!( process_text_message(&Message::Text(String::from("Hello"))), "Processed Text: Hello" ); assert_eq!( process_text_message(&Message::Number(42)), "Unhandled Message" ); assert_eq!(process_text_message(&Message::Quit), "Unhandled Message"); assert_eq!(process_text_message(&Message::None), "Unhandled Message");}
pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { // Your code here... if let Message::Text(content)=message{ format!("Processed Text: {content}") }else{ String::from("Unhandled Message") }}pub fn main() { assert_eq!( process_text_message(&Message::Text(String::from("Hello"))), "Processed Text: Hello" ); assert_eq!( process_text_message(&Message::Number(42)), "Unhandled Message" ); assert_eq!(process_text_message(&Message::Quit), "Unhandled Message"); assert_eq!(process_text_message(&Message::None), "Unhandled Message");}
pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { if let Message::Text(t) = message { return format!("Processed Text: {t}"); } String::from("Unhandled Message")}pub fn main() { assert_eq!( process_text_message(&Message::Text(String::from("Hello"))), "Processed Text: Hello" ); assert_eq!( process_text_message(&Message::Number(42)), "Unhandled Message" ); assert_eq!(process_text_message(&Message::Quit), "Unhandled Message"); assert_eq!(process_text_message(&Message::None), "Unhandled Message");}
pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { if let Message::Text(content) = message { return format!("Processed Text: {}", content); } String::from("Unhandled Message")}pub fn main() { assert_eq!( process_text_message(&Message::Text(String::from("Hello"))), "Processed Text: Hello" ); assert_eq!( process_text_message(&Message::Number(42)), "Unhandled Message" ); assert_eq!(process_text_message(&Message::Quit), "Unhandled Message"); assert_eq!(process_text_message(&Message::None), "Unhandled Message");}
pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { if let Message::Text(msg) = message { return format!("Processed Text: {msg}"); } String::from("Unhandled Message")}pub fn main() { assert_eq!( process_text_message(&Message::Text(String::from("Hello"))), "Processed Text: Hello" ); assert_eq!( process_text_message(&Message::Number(42)), "Unhandled Message" ); assert_eq!(process_text_message(&Message::Quit), "Unhandled Message"); assert_eq!(process_text_message(&Message::None), "Unhandled Message");}
pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { // Your code here... if let Message::Text(content) = message { format!("Processed Text: {content}") } else { String::from("Unhandled Message") }}pub fn main() { assert_eq!( process_text_message(&Message::Text(String::from("Hello"))), "Processed Text: Hello" ); assert_eq!( process_text_message(&Message::Number(42)), "Unhandled Message" ); assert_eq!(process_text_message(&Message::Quit), "Unhandled Message"); assert_eq!(process_text_message(&Message::None), "Unhandled Message");}
pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { if let Message::Text(value) = &message { return format!("Processed Text: {}", value); } String::from("Unhandled Message")}pub fn main() { assert_eq!( process_text_message(&Message::Text(String::from("Hello"))), "Processed Text: Hello" ); assert_eq!( process_text_message(&Message::Number(42)), "Unhandled Message" ); assert_eq!(process_text_message(&Message::Quit), "Unhandled Message"); assert_eq!(process_text_message(&Message::None), "Unhandled Message");}
pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { // Your code here... if let Message::Text(ref content) = message { format!("Processed Text: {content}") } else { String::from("Unhandled Message") } }pub fn main() { assert_eq!( process_text_message(&Message::Text(String::from("Hello"))), "Processed Text: Hello" ); assert_eq!( process_text_message(&Message::Number(42)), "Unhandled Message" ); assert_eq!(process_text_message(&Message::Quit), "Unhandled Message"); assert_eq!(process_text_message(&Message::None), "Unhandled Message");}
pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { if let Message::Text(text) = &message { return format!("Processed Text: {}", text); } String::from("Unhandled Message")}pub fn main() { assert_eq!( process_text_message(&Message::Text(String::from("Hello"))), "Processed Text: Hello" ); assert_eq!( process_text_message(&Message::Number(42)), "Unhandled Message" ); assert_eq!(process_text_message(&Message::Quit), "Unhandled Message"); assert_eq!(process_text_message(&Message::None), "Unhandled Message");}
pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { if let Message::Text(content) = &message { return format!("Processed Text: {}", content); } String::from("Unhandled Message")}pub fn main() { assert_eq!( process_text_message(&Message::Text(String::from("Hello"))), "Processed Text: Hello" ); assert_eq!( process_text_message(&Message::Number(42)), "Unhandled Message" ); assert_eq!(process_text_message(&Message::Quit), "Unhandled Message"); assert_eq!(process_text_message(&Message::None), "Unhandled Message");}
pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { // Your code here... if let Message::Text(message) = &message { return format!("Processed Text: {}", message) } String::from("Unhandled Message")}pub fn main() { assert_eq!( process_text_message(&Message::Text(String::from("Hello"))), "Processed Text: Hello" ); assert_eq!( process_text_message(&Message::Number(42)), "Unhandled Message" ); assert_eq!(process_text_message(&Message::Quit), "Unhandled Message"); assert_eq!(process_text_message(&Message::None), "Unhandled Message");}
pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { if let Message::Text(msg) = message { return format!("Processed Text: {}", msg); } String::from("Unhandled Message")}pub fn main() { assert_eq!( process_text_message(&Message::Text(String::from("Hello"))), "Processed Text: Hello" ); assert_eq!( process_text_message(&Message::Number(42)), "Unhandled Message" ); assert_eq!(process_text_message(&Message::Quit), "Unhandled Message"); assert_eq!(process_text_message(&Message::None), "Unhandled Message");}
pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { // Your code here... if let Message::Text(text_value) = message { return format!("Processed Text: {}", text_value); } String::from("Unhandled Message")}pub fn main() { assert_eq!( process_text_message(&Message::Text(String::from("Hello"))), "Processed Text: Hello" ); assert_eq!( process_text_message(&Message::Number(42)), "Unhandled Message" ); assert_eq!(process_text_message(&Message::Quit), "Unhandled Message"); assert_eq!(process_text_message(&Message::None), "Unhandled Message");}
pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { // Your code here... if let Message::Text(text_value) = message { return format!("Processed Text: {}", text_value); } String::from("Unhandled Message")}pub fn main() { assert_eq!( process_text_message(&Message::Text(String::from("Hello"))), "Processed Text: Hello" ); assert_eq!( process_text_message(&Message::Number(42)), "Unhandled Message" ); assert_eq!(process_text_message(&Message::Quit), "Unhandled Message"); assert_eq!(process_text_message(&Message::None), "Unhandled Message");}
pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { // Your code here... if let Message::Text(text) = &message { return format!("Processed Text: {text}"); } String::from("Unhandled Message")}pub fn main() { assert_eq!( process_text_message(&Message::Text(String::from("Hello"))), "Processed Text: Hello" ); assert_eq!( process_text_message(&Message::Number(42)), "Unhandled Message" ); assert_eq!(process_text_message(&Message::Quit), "Unhandled Message"); assert_eq!(process_text_message(&Message::None), "Unhandled Message");}
pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { // Your code here... if let Message::Text(message) = message { return format!("Processed Text: {message}"); } String::from("Unhandled Message")}pub fn main() { assert_eq!( process_text_message(&Message::Text(String::from("Hello"))), "Processed Text: Hello" ); assert_eq!( process_text_message(&Message::Number(42)), "Unhandled Message" ); assert_eq!(process_text_message(&Message::Quit), "Unhandled Message"); assert_eq!(process_text_message(&Message::None), "Unhandled Message");}
pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { // Your code here... if let Message::Text(v) = message { return format!("Processed Text: {v}"); } String::from("Unhandled Message")}pub fn main() { assert_eq!( process_text_message(&Message::Text(String::from("Hello"))), "Processed Text: Hello" ); assert_eq!( process_text_message(&Message::Number(42)), "Unhandled Message" ); assert_eq!(process_text_message(&Message::Quit), "Unhandled Message"); assert_eq!(process_text_message(&Message::None), "Unhandled Message");}
pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { if let Message::Text(content) = message { format!("Processed Text: {content}") }else{ String::from("Unhandled Message") }}pub fn main() { assert_eq!( process_text_message(&Message::Text(String::from("Hello"))), "Processed Text: Hello" ); assert_eq!( process_text_message(&Message::Number(42)), "Unhandled Message" ); assert_eq!(process_text_message(&Message::Quit), "Unhandled Message"); assert_eq!(process_text_message(&Message::None), "Unhandled Message");}
pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { if let Message::Text(text) = message { return format!("Processed Text: {}", text); } String::from("Unhandled Message")}pub fn main() { assert_eq!( process_text_message(&Message::Text(String::from("Hello"))), "Processed Text: Hello" ); assert_eq!( process_text_message(&Message::Number(42)), "Unhandled Message" ); assert_eq!(process_text_message(&Message::Quit), "Unhandled Message"); assert_eq!(process_text_message(&Message::None), "Unhandled Message");}
pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { // Your code here... if let Message::Text(x) = message { return format!("Processed Text: {x}"); } String::from("Unhandled Message")}pub fn main() { assert_eq!( process_text_message(&Message::Text(String::from("Hello"))), "Processed Text: Hello" ); assert_eq!( process_text_message(&Message::Number(42)), "Unhandled Message" ); assert_eq!(process_text_message(&Message::Quit), "Unhandled Message"); assert_eq!(process_text_message(&Message::None), "Unhandled Message");}
pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { // Your code here... if let Message::Text(content) = message { format!("Processed Text: {content}") } else { String::from("Unhandled Message") }}pub fn main() { assert_eq!( process_text_message(&Message::Text(String::from("Hello"))), "Processed Text: Hello" ); assert_eq!( process_text_message(&Message::Number(42)), "Unhandled Message" ); assert_eq!(process_text_message(&Message::Quit), "Unhandled Message"); assert_eq!(process_text_message(&Message::None), "Unhandled Message");}
pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { if let Message::Text(context) = message { return format!("Processed Text: {context}") } else { String::from("Unhandled Message") }}pub fn main() { assert_eq!( process_text_message(&Message::Text(String::from("Hello"))), "Processed Text: Hello" ); assert_eq!( process_text_message(&Message::Number(42)), "Unhandled Message" ); assert_eq!(process_text_message(&Message::Quit), "Unhandled Message"); assert_eq!(process_text_message(&Message::None), "Unhandled Message");}
pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { // Your code here... match message { Message::Text(message) => format!("Processed Text: {message}"), _ => "Unhandled Message".to_string() }}pub fn main() { assert_eq!( process_text_message(&Message::Text(String::from("Hello"))), "Processed Text: Hello" ); assert_eq!( process_text_message(&Message::Number(42)), "Unhandled Message" ); assert_eq!(process_text_message(&Message::Quit), "Unhandled Message"); assert_eq!(process_text_message(&Message::None), "Unhandled Message");}
pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { match message { Message::Text(message) => format!("Processed Text: {message}"), _ => String::from("Unhandled Message"), }}pub fn main() { assert_eq!( process_text_message(&Message::Text(String::from("Hello"))), "Processed Text: Hello" ); assert_eq!( process_text_message(&Message::Number(42)), "Unhandled Message" ); assert_eq!(process_text_message(&Message::Quit), "Unhandled Message"); assert_eq!(process_text_message(&Message::None), "Unhandled Message");}
pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { // Your code here... if let Message::Text(message) = &message { return format!("Processed Text: {message}") } String::from("Unhandled Message")}pub fn main() { assert_eq!( process_text_message(&Message::Text(String::from("Hello"))), "Processed Text: Hello" ); assert_eq!( process_text_message(&Message::Number(42)), "Unhandled Message" ); assert_eq!(process_text_message(&Message::Quit), "Unhandled Message"); assert_eq!(process_text_message(&Message::None), "Unhandled Message");}
pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { // Your code here... if let Message::Text(msg) = message { return format!("Processed Text: {msg}"); } String::from("Unhandled Message")}pub fn main() { assert_eq!( process_text_message(&Message::Text(String::from("Hello"))), "Processed Text: Hello" ); assert_eq!( process_text_message(&Message::Number(42)), "Unhandled Message" ); assert_eq!(process_text_message(&Message::Quit), "Unhandled Message"); assert_eq!(process_text_message(&Message::None), "Unhandled Message");}
pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { // Your code here... if let Message::Text(message) = &message{ format!("Processed Text: {message}") }else{ String::from("Unhandled Message") }}pub fn main() { assert_eq!( process_text_message(&Message::Text(String::from("Hello"))), "Processed Text: Hello" ); assert_eq!( process_text_message(&Message::Number(42)), "Unhandled Message" ); assert_eq!(process_text_message(&Message::Quit), "Unhandled Message"); assert_eq!(process_text_message(&Message::None), "Unhandled Message");}
pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { // Your code here... if let Message::Text(msg) = message { format!("Processed Text: {}", msg) }else{ String::from("Unhandled Message") }}pub fn main() { assert_eq!( process_text_message(&Message::Text(String::from("Hello"))), "Processed Text: Hello" ); assert_eq!( process_text_message(&Message::Number(42)), "Unhandled Message" ); assert_eq!(process_text_message(&Message::Quit), "Unhandled Message"); assert_eq!(process_text_message(&Message::None), "Unhandled Message");}
pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { if let Message::Text(str) = message { format!("Processed Text: {str}") } else { String::from("Unhandled Message") }}pub fn main() { assert_eq!( process_text_message(&Message::Text(String::from("Hello"))), "Processed Text: Hello" ); assert_eq!( process_text_message(&Message::Number(42)), "Unhandled Message" ); assert_eq!(process_text_message(&Message::Quit), "Unhandled Message"); assert_eq!(process_text_message(&Message::None), "Unhandled Message");}
pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { // Your code here... if let Message::Text(content) = message { format!("Processed Text: {content}") } else { String::from("Unhandled Message") }}pub fn main() { assert_eq!( process_text_message(&Message::Text(String::from("Hello"))), "Processed Text: Hello" ); assert_eq!( process_text_message(&Message::Number(42)), "Unhandled Message" ); assert_eq!(process_text_message(&Message::Quit), "Unhandled Message"); assert_eq!(process_text_message(&Message::None), "Unhandled Message");}
pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { // Your code here... if let Message::Text(msg) = message { return format!("Processed Text: {msg}"); } String::from("Unhandled Message")}pub fn main() { assert_eq!( process_text_message(&Message::Text(String::from("Hello"))), "Processed Text: Hello" ); assert_eq!( process_text_message(&Message::Number(42)), "Unhandled Message" ); assert_eq!(process_text_message(&Message::Quit), "Unhandled Message"); assert_eq!(process_text_message(&Message::None), "Unhandled Message");}
pub enum Message { Text(String), Number(i32), Quit, None,}pub fn process_text_message(message: &Message) -> String { // Your code here... if let Message::Text(s) = message { format!("Processed Text: {}", s) } else { String::from("Unhandled Message") }}pub fn main() { assert_eq!( process_text_message(&Message::Text(String::from("Hello"))), "Processed Text: Hello" ); assert_eq!( process_text_message(&Message::Number(42)), "Unhandled Message" ); assert_eq!(process_text_message(&Message::Quit), "Unhandled Message"); assert_eq!(process_text_message(&Message::None), "Unhandled Message");}