If Let Enums

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);
}

Your Task

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.

Hints

Click here to reveal hints

You can use the if let construct like this:

if let EnumVariant(value) = &enum_instance {
    // Perform actions with `value`.
}

Ensure you return "Unhandled Message" for all other variants not explicitly matched.

Editor not available on Mobile!

In order to solve the challenge, please visit this page on a desktop computer.

Solutions

Kr0wZ

16 hours ago

2.91ms

86.89kb

pub enum Message {
    Text(String),
    Number(i32),
    Quit,
    None,
}
pub fn process_text_message(message: &Message) -> String {
    // Your code here...
    if let Message::Text(string) = message {
        return format!("Processed Text: {}", string);
    }
    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");
}

Luigi Terrone

LuigiTer

19 hours ago

2.86ms

86.89kb

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");
}

Heino Mortensen

hmortensen83

2 days ago

3.11ms

86.89kb

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");
}

0x0f1

Paul4673

2 days ago

3.16ms

86.89kb

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");
}

Tri Nguyen

nguyentri

3 days ago

3.15ms

86.89kb

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");
}

dattruongdev

3 days ago

3.74ms

86.89kb

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");
}

Satya Sundar Sahu

satya200

4 days ago

2.90ms

86.89kb

pub enum Message {
    Text(String),
    Number(i32),
    Quit,
    None,
}
pub fn process_text_message(message: &Message) -> String {
    // Your code here...
    if let Message::Text(val) = &message {
        return format!("Processed Text: {}", val);
    }
    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");
}

Gomathi Shankar

gomathishankar37

4 days ago

3.20ms

86.89kb

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");
}

silaskoemen

4 days ago

4.03ms

86.89kb

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");
}

Sarthak Mishra

sithtsar

5 days ago

3.32ms

86.89kb

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");
}

xxxxsk

7 days ago

3.08ms

86.89kb

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");
}

hahu07

7 days ago

2.67ms

86.89kb

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");
}

Rocky.C

cloki0610

7 days ago

2.77ms

86.89kb

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");
}

Pierre Gordo

PierreGordo

8 days ago

3.60ms

86.89kb

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");
}

Lucop1911

8 days ago

3.16ms

86.89kb

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");
}

Christopher Kolbe

chkolbe

10 days ago

4.19ms

86.89kb

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");
}

s.i

ssmi75

11 days ago

3.62ms

86.89kb

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");
}

ikatlinsky

11 days ago

4.89ms

86.89kb

pub enum Message {
    Text(String),
    Number(i32),
    Quit,
    None,
}
pub fn process_text_message(message: &Message) -> String {
    if let Message::Text(m) = message {
        return format!("Processed Text: {m}");
    }
    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");
}

Gabriel Menezes

GMNDS

12 days ago

2.90ms

86.89kb

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");
}

diucicd

14 days ago

3.28ms

86.89kb

pub enum Message {
    Text(String),
    Number(i32),
    Quit,
    None,
}
pub fn process_text_message(message: &Message) -> String {
    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");
}

esl

esl07

15 days ago

3.22ms

86.89kb

pub enum Message {
    Text(String),
    Number(i32),
    Quit,
    None,
}
pub fn process_text_message(message: &Message) -> String {
    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");
}

0x90

riccio8

17 days ago

3.10ms

86.89kb

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");
}

AQian

AQian0

18 days ago

3.44ms

86.89kb

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");
}

annececiledunand

19 days ago

3.02ms

86.89kb

pub enum Message {
    Text(String),
    Number(i32),
    Quit,
    None,
}
pub fn process_text_message(message: &Message) -> String {
    if let Message::Text(text) = message { format!("Processed Text: {text}") } 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");
}

annececiledunand

19 days ago

3.70ms

86.89kb

pub enum Message {
    Text(String),
    Number(i32),
    Quit,
    None,
}
pub fn process_text_message(message: &Message) -> String {
    if let Message::Text(text) = message { format!("Processed Text: {text}") } 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");
}

Sergey Matyash

matiaspub

20 days ago

3.33ms

86.89kb

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");
}

GregGorin

21 days ago

3.25ms

86.89kb

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");
}

Francisco Garau

fgarau

22 days ago

2.84ms

86.89kb

pub enum Message {
    Text(String),
    Number(i32),
    Quit,
    None,
}
pub fn process_text_message(message: &Message) -> String {
    // match message {
    //     Message::Text(msg) => format!("Processed Text: {msg}"),
    //     _ => String::from("Unhandled Message")
    // }
    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");
}

Francisco Garau

fgarau

22 days ago

2.99ms

86.89kb

pub enum Message {
    Text(String),
    Number(i32),
    Quit,
    None,
}
pub fn process_text_message(message: &Message) -> String {
    // match message {
    //     Message::Text(msg) => format!("Processed Text: {msg}"),
    //     _ => String::from("Unhandled Message")
    // }
    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");
}

Hendrik Dreesmann

DeemanOne

22 days ago

2.96ms

86.89kb

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");
}

Timothy Z.

kKaskak

22 days ago

3.23ms

86.89kb

pub enum Message {
    Text(String),
    Number(i32),
    Quit,
    None,
}
pub fn process_text_message(message: &Message) -> String {
    if let Message::Text(text) = message {
        format!("Processed Text: {}", text)
    } 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");
}

zapp42

23 days ago

3.35ms

86.89kb

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");
}

ycgw

23 days ago

3.22ms

86.89kb

pub enum Message {
    Text(String),
    Number(i32),
    Quit,
    None,
}
pub fn process_text_message(message: &Message) -> String {
    if let Message::Text(txt) = message {
        format!("Processed Text: {txt}")
    } 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");
}

LeonardoPinheiro23

23 days ago

3.12ms

86.89kb

pub enum Message {
    Text(String),
    Number(i32),
    Quit,
    None,
}
pub fn process_text_message(message: &Message) -> String {
    if let Message::Text(message_string) = message {
        return format!("Processed Text: {message_string}");
    }
    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");
}

jbrakmic

23 days ago

4.37ms

86.89kb

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");
}

Saksinkarn Petchkuljinda

dward2nd

24 days ago

30.67ms

86.89kb

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");
}

Anatma2

24 days ago

3.04ms

86.92kb

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).to_string()}
    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");
}

wry

Liudel

24 days ago

4.89ms

86.89kb

pub enum Message {
    Text(String),
    Number(i32),
    Quit,
    None,
}
pub fn process_text_message(message: &Message) -> String {
    // Your code here...
    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");
}

Travis

ttmgraham

25 days ago

5.54ms

86.89kb

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");
}

Tommytto

25 days ago

4.68ms

86.89kb

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");
}

Erik Hollembeak

futureperfect

25 days ago

6.96ms

86.89kb

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}")
    }
    return 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");
}

Ajit Kumar

urwithajit9

a month ago

5.53ms

86.89kb

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");
}

AshutoshKumarPatel

a month ago

6.66ms

86.89kb

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");
}

Maicon Crespo

maiconcrespo

a month ago

3.45ms

86.89kb

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");
}

sjmellor

a month ago

3.90ms

86.89kb

pub enum Message {
    Text(String),
    Number(i32),
    Quit,
    None,
}
pub fn process_text_message(message: &Message) -> String {
    // Your code here...
    if let Message::Text(string) = message {
        return format!("Processed Text: {string}")
    }
    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");
}

4itech-micky

a month ago

3.64ms

86.89kb

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");
}

4itech-micky

a month ago

5.75ms

86.89kb

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");
}

4itech-micky

a month ago

3.41ms

86.89kb

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");
}

4itech-micky

a month ago

4.01ms

86.89kb

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");
}

AlphaN00mer1cal

a month ago

4.23ms

86.89kb

pub enum Message {
    Text(String),
    Number(i32),
    Quit,
    None,
}
pub fn process_text_message(message: &Message) -> String {
    if let Message::Text(info) = message {
        return format!("Processed Text: {}", info )
    }
    
    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");
}