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

michdorf

5 hours ago

3.18ms

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(mes) = message {
        return format!("Processed Text: {mes}");
    }
    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");
}

vojta stefan

vojtastefan

a day ago

3.87ms

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(a) = message {
        format!("Processed Text: {}",a)
    } 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");
}

vojta stefan

vojtastefan

a day ago

3.82ms

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 {
        format!("Processed Text: {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");
}

AnKarl

Zythophilus

2 days ago

3.24ms

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 {
        format!("Processed Text: {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");
}

Pranav Garg

PranavGarg01

2 days ago

6.80ms

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 {
        return format!("Processed Text: {}", s)
    }
    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");
}

Hung Dinh

nhdinh

2 days ago

3.02ms

86.89kb

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

amaneru

7ma8no9

3 days ago

3.24ms

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 {
        return format!("Processed Text: {s}")
    }
    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");
}

Artyom Chebotarev

Derik117

4 days ago

3.19ms

86.89kb

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

AKA.MoneyTaker

M4Bo2

5 days ago

4.04ms

86.89kb

pub enum Message {
    Text(String),
    Number(i32),
    Quit,
    None,
}
pub fn process_text_message(message: &Message) -> String {
    // Your code here...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".
if let Message::Text(content) = message {
        // Return the processed text message
        return format!("Processed Text: {}", content);
    }
// Try to solve this using the if let construct.
    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");
}

Kamuran

karapy

5 days ago

2.92ms

86.92kb

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

Kamuran

karapy

5 days ago

3.92ms

86.92kb

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

zawwwu

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

Dyaa Adel

dyaa-adel

7 days ago

3.09ms

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(txt) = message {
        return format!("Processed Text: {}", txt);
    }
    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");
}

Éric Villani

TheTrueCaligari

7 days ago

3.90ms

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

Lê Minh Quân

aleister1102

8 days ago

4.30ms

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

Vladimir

PavluninVladimir

10 days ago

3.13ms

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

Yi Hao

leongyihao

10 days ago

3.97ms

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

TiagONTOP

11 days ago

3.26ms

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

Ayushman Rathore

Spartan09

11 days ago

5.05ms

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

Anıl Şenay

anilsenay

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

Guilherme Cesário Strachan

strachan

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

norabbito

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

Jordan

Jordan-Haidee

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

Kyle Diaz

kylediaz

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

McToady.eth

McCoady

16 days ago

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

McToady.eth

McCoady

16 days ago

11.83ms

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

McToady.eth

McCoady

16 days ago

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

Kenneth Love

kennethlove

16 days ago

3.19ms

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

Benjamin Falk

lumio

16 days ago

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

Douglas Campbell

CampbellD84

17 days ago

3.40ms

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

Prafful

iamsahu

17 days ago

3.04ms

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

Diego Maia

diegocmsantos

18 days ago

5.48ms

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

ludovicknecht

18 days ago

3.09ms

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

Joe Schneider

josschne

18 days ago

3.36ms

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

Whisper_icoma

1378046967

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

Muhammad-Dennis

19 days ago

3.28ms

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

manuelmj

20 days ago

3.02ms

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

automata-studio

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

kosay

sarub0b0

20 days ago

4.05ms

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

Denis SOURON

Brack0

20 days ago

2.88ms

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

Donald Huber-Youmans

dHuberYoumans

20 days ago

3.78ms

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

alemack17

21 days ago

3.35ms

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

TeDeMos

22 days ago

3.08ms

86.89kb

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

RiyadDz22

22 days ago

3.45ms

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

Nikita Smirnov

Nismirno

22 days ago

3.09ms

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

Jun Huang

leemars

22 days ago

2.98ms

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

roux g. buciu

adudenamedruby

23 days ago

3.56ms

86.89kb

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

Viktor Merkurev

fennr

23 days ago

3.37ms

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

iamforgettable

23 days ago

3.07ms

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

Kentaro Abe

abekem

24 days ago

3.85ms

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