Complex Enums

Now that you have an overview of enums and it's possible variants, let's have a more complex example.

In this challenge, you will create an Animal enum that demonstrates all three types of variants.

Your Task

Create an enum Animal with the following variants:

Unit Struct Variant:
- Dog — represents a generic dog.
Tuple Struct Variant:
- Cat(String) — represents a cat, where the String contains the cat's name.
Named Field Struct Variant:
- Bird { species: String, can_fly: bool } — represents a bird with its species and whether it can fly.

Write a function describe_animal that takes a reference to an Animal and returns a String description based on the variant:

For Dog, return "A friendly dog.".
For Cat(name), return "A cat named {name}.".
For Bird { species, can_fly }, return:
- "A {species} that can fly." if can_fly is true.
- "A {species} that cannot fly." if can_fly is false.

Hints

Click here to reveal hints

Use the match statement to destructure tuple and named field variants.
String formatting with format! makes it easy to include dynamic values in your description.

Editor not available on Mobile!

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

Solutions

Javets70

12 hours ago

3.16ms

87.39kb

pub enum Animal {
    // Define the Animal variants here
    Dog,
    Cat(String),
    Bird{
        species : String,
        can_fly:bool,
    }
}
pub fn describe_animal(animal: &Animal) -> String {
    // Your code here...
    match animal{
        Animal::Dog=> "A friendly dog.".to_string(),
        Animal::Cat(name) => format!("A cat named {}." , name).to_string(),
        Animal::Bird{ species, can_fly } => {
            if *can_fly{
                return format!("A {} that can fly." , species)
            } else {
                return format!("A {} that cannot fly." , species)
            }
        }
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

Noxyss

18 hours ago

3.89ms

87.38kb

pub enum Animal {
    // Define the Animal variants here
    Dog,
    Cat(String),
    Bird { species: String, can_fly: bool }
}
pub fn describe_animal(animal: &Animal) -> String {
    // Your code here...
    match animal {
        Animal::Dog => return String::from("A friendly dog."),
        Animal::Cat(name) => return format!("A cat named {}.", name),
        Animal::Bird{ species, can_fly } => {
            if *can_fly {return format!("A {} that can fly.", species)}
            return format!("A {} that cannot fly.", species);
        }
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

Harsh Ranjan

harshRn

20 hours ago

3.24ms

87.38kb

pub enum Animal {
    // Define the Animal variants here
    Dog,
    Cat(String),
    Bird{ species: String, can_fly: bool}
}
pub fn describe_animal(animal: &Animal) -> String {
    // Your code here...
    match animal {
        Animal::Dog => "A friendly dog.".to_string(),
        Animal::Cat(v) => format!("A cat named {}.", v),
        Animal::Bird {species, can_fly} => {
            if *can_fly {
                format!("A {} that can fly.", species)
            } else {
                format!("A {} that cannot fly.", species)
            }
        }
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

bernardoLY19

a day ago

3.74ms

87.41kb

pub enum Animal {
    // Define the Animal variants here
    Dog,
    Cat(String),
    Bird { species: String, can_fly: bool },
}
pub fn describe_animal(animal: &Animal) -> String {
    // Your code here...
    match animal {
        Animal::Dog => "A friendly dog.".to_string(),
        Animal::Cat(name) => format!("A cat named {}.", name).to_string(),
        Animal::Bird{species, can_fly} => {
            if *can_fly {
                return format!("A {} that can fly.", species).to_string();
            }
            return format!("A {} that cannot fly.", species).to_string();
        }
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

Artem Nistuley

artemnistuley

2 days ago

3.19ms

87.38kb

pub enum Animal {
    Dog,
    Cat(String),
    Bird {
        species: String,
        can_fly: bool,
    }
}
pub fn describe_animal(animal: &Animal) -> String {
    match animal {
        Animal::Dog => String::from("A friendly dog."),
        Animal::Cat(name) => format!("A cat named {name}."),
        Animal::Bird { species, can_fly } => if *can_fly { format!("A {species} that can fly.") } else { format!("A {species} that cannot fly.") }
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

Baron Curtin

baroncurtin2

3 days ago

3.52ms

87.38kb

pub enum Animal {
    // Define the Animal variants here
    Dog,
    Cat(String),
    Bird {
        species: String,
        can_fly: bool,
    },
}
pub fn describe_animal(animal: &Animal) -> String {
    match animal {
        Animal::Dog => String::from("A friendly dog."),
        Animal::Cat(name) => format!("A cat named {}.", name),
        Animal::Bird{species, can_fly} => {
            if *can_fly {
                format!("A {} that can fly.", species)
            } else {
                format!("A {} that cannot fly.", species)
            }
        },
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

xvzhang

xvzhnang

3 days ago

3.22ms

87.38kb

pub enum Animal {
    // Define the Animal variants here
    Dog,
    Cat(String),
    Bird { species: String, can_fly: bool },
}
pub fn describe_animal(animal: &Animal) -> String {
    // Your code here...
    match animal {
        Animal::Dog => "A friendly dog.".to_string(),
        Animal::Cat(name) => format!("A cat named {}.", name),
        Animal::Bird { species, can_fly } => {
            if *can_fly {
                format!("A {} that can fly.", species)
            } else {
                format!("A {} that cannot fly.", species)
            }
        },
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

Jai

jsat97

4 days ago

2.95ms

87.38kb

pub enum Animal {
    Dog,
    Cat(String),
    Bird{species: String, can_fly: bool},
    // Define the Animal variants here
}
pub fn describe_animal(animal: &Animal) -> String {
    // Your code here...
    match animal {
        Animal::Dog => "A friendly dog.".to_string(),
        Animal::Cat(name) => format!("A cat named {name}."),
        Animal::Bird{species, can_fly} => {
                let flies_or_not = 
                    if *can_fly {"can fly"} else {"cannot fly"}; 
            format!("A {species} that {flies_or_not}.")
        },
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

Cobran53

4 days ago

3.51ms

87.37kb

pub enum Animal {
    Dog,
    Cat(String),
    Bird { species: String, can_fly: bool }
}
pub fn describe_animal(animal: &Animal) -> String {
    match animal { 
        Animal::Dog => "A friendly dog.".to_string(),
        Animal::Cat(name) => format!("A cat named {name}."),
        Animal::Bird{species, can_fly}=> format!("A {species} that {} fly.", if *can_fly {"can"} else {"cannot"}),
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

Tommy

verse215

5 days ago

3.14ms

87.41kb

pub enum Animal {
    // Define the Animal variants here
    Dog,
    Cat(String),
    Bird{species: String, can_fly: bool},
}
pub fn describe_animal(animal: &Animal) -> String {
    // Your code here...
    match animal {
        Animal::Dog => "A friendly dog.".to_string(),
        Animal::Cat(n) => format!("A cat named {n}.").to_string(),
        Animal::Bird{species, can_fly} => {
            if *can_fly {
                format!("A {species} that can fly.").to_string()
            } else {
                format!("A {species} that cannot fly.").to_string()
            }
    }
}
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

alexsavio

6 days ago

3.56ms

87.38kb

pub enum Animal {
    // Define the Animal variants here
    Dog,
    Cat(String),
    Bird{ species: String, can_fly: bool },
}
pub fn describe_animal(animal: &Animal) -> String {
    match animal {
        Animal::Dog => "A friendly dog.".to_string(),
        Animal::Cat(name) => format!("A cat named {name}."),
        Animal::Bird{ species, can_fly } => {
            if *can_fly { 
                format!("A {species} that can fly.") 
            }
            else { 
                format!("A {species} that cannot fly.") 
            }
        }
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

baschdik

8 days ago

3.51ms

87.38kb

pub enum Animal {
    // Define the Animal variants here
    Dog,
    Cat (String),
    Bird { species: String, can_fly: bool },
}
pub fn describe_animal(animal: &Animal) -> String {
    // Your code here...
    match animal {
        Animal::Dog => "A friendly dog.".to_string(),
        Animal::Cat(name) => format!("A cat named {}.", name),
        Animal::Bird{species, can_fly} => if *can_fly {
            format!("A {species} that can fly.")
        } else {
            format!("A {species} that cannot fly.")
        },
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

medzernik

8 days ago

3.13ms

87.37kb

pub enum Animal {
    Dog, 
    Cat(String),
    Bird{species: String, can_fly: bool}
}
pub fn describe_animal(animal: &Animal) -> String {
    match animal {
        Animal::Dog => "A friendly dog.".to_string(),
        Animal::Cat(name) => format!("A cat named {name}."),
        Animal::Bird{species, can_fly} => format!("A {} that {} fly.", species, if *can_fly {"can"} else {"cannot"}),
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

coreyralph

8 days ago

4.87ms

87.38kb

pub enum Animal {
    Dog,
    Cat(String),
    Bird { species: String, can_fly: bool }
}
pub fn describe_animal(animal: &Animal) -> String {
    match animal {
        Animal::Dog => "A friendly dog.".to_string(),
        Animal::Cat(name) => format!("A cat named {name}."),
        Animal::Bird{species,can_fly} if *can_fly => format!("A {species} that can fly."),
        Animal::Bird{species,..} => format!("A {species} that cannot fly.")
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

Herman effendi

hrmneffdii

8 days ago

3.13ms

87.38kb

pub enum Animal {
    Dog,
    Cat (String),
    Bird { species: String, can_fly: bool}
}
pub fn describe_animal(animal: &Animal) -> String {
    // Your code here...
    match animal {
        Animal::Dog => return "A friendly dog.".to_string(),
        Animal::Cat(name) => return format!("A cat named {}.", name),
        Animal::Bird{species, can_fly} => {
            if *can_fly {
                return format!("A {} that can fly.", species);
            } else {
                return format!("A {} that cannot fly.", species);
            }
        }
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

Miguel Ángel Allende

maallende

10 days ago

4.28ms

87.38kb

pub enum Animal {
    // Define the Animal variants here
    Dog,
    Cat(String),
    Bird { species: String, can_fly: bool }
}
pub fn describe_animal(animal: &Animal) -> String {
    // Your code here...
    match animal{
        Animal::Dog => "A friendly dog.".to_string(),
        Animal::Cat(name) => format!("A cat named {}.", name),
        Animal::Bird{species, can_fly} => if *can_fly{ format!("A {} that can fly.", species)} else{ format!("A {} that cannot fly.", species)},
    }
    
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

Ushakov Andrey

stdstring

10 days ago

3.10ms

87.38kb

pub enum Animal {
    // Define the Animal variants here
    Dog,
    Cat(String),
    Bird { species: String, can_fly: bool },
}
pub fn describe_animal(animal: &Animal) -> String {
    // Your code here...
    match animal {
        Animal::Dog => "A friendly dog.".to_string(),
        Animal::Cat(name) => format!("A cat named {name}."),
        Animal::Bird { species, can_fly: true } => format!("A {species} that can fly."),
        Animal::Bird { species, can_fly: false } => format!("A {species} that cannot fly."),
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

zzispp

10 days ago

2.97ms

87.38kb

pub enum Animal {
    // Define the Animal variants here
    Dog,
    Cat(String),
    Bird { species: String, can_fly: bool },
}
pub fn describe_animal(animal: &Animal) -> String {
    match animal {
        Animal::Dog => "A friendly dog.".into(),
        Animal::Cat(name) => format!("A cat named {}.",name),
        Animal::Bird {
            species,
            can_fly: true,
        } => format!("A {species} that can fly."),
        Animal::Bird {
            species,
            can_fly: false,
        } => format!("A {species} that cannot fly."),
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

Philippe Massicotte

PMassicotte

11 days ago

3.76ms

87.38kb

pub enum Animal {
    Dog,
    Cat(String),
    Bird { species: String, can_fly: bool },
}
pub fn describe_animal(animal: &Animal) -> String {
    match animal {
        Animal::Dog => "A friendly dog.".to_string(),
        Animal::Cat(name) => format!("A cat named {name}."),
        Animal::Bird {
            species,
            can_fly: true,
        } => format!("A {species} that can fly."),
        Animal::Bird {
            species,
            can_fly: false,
        } => format!("A {species} that cannot fly."),
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

CDzungx

11 days ago

3.37ms

87.38kb

pub enum Animal {
    // Define the Animal variants here
    Dog,
    Cat(String),
    Bird { 
        species: String,
        can_fly: bool
    }
}
pub fn describe_animal(animal: &Animal) -> String {
    match animal{
        Animal::Dog => {"A friendly dog.".to_string()}
        Animal::Cat(name) => format!("A cat named {}.", name),
        Animal::Bird{species, can_fly} => {
            if *can_fly {format!("A {} that can fly.", species)}
            else {format!("A {} that cannot fly.", species)}
        }
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

kcoolio

chrisjude254

11 days ago

3.29ms

87.38kb

pub enum Animal {
    Dog, 
    Cat(String),
    Bird {species: String, can_fly: bool}
}
pub fn describe_animal(animal: &Animal) -> String {
    return match animal { 
        Animal::Dog => format!("A friendly dog."),
        Animal::Cat(name) => format!("A cat named {name}."),
        Animal::Bird{species, can_fly} => if *can_fly == true {format!("A {species} that can fly.")} else {format!("A {species} that cannot fly.")} 
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

Camiam144

11 days ago

3.13ms

87.37kb

pub enum Animal {
    // Define the Animal variants here
    Dog,
    Cat(String),
    Bird{ species: String, can_fly: bool }
}
pub fn describe_animal(animal: &Animal) -> String {
    // Your code here...
    match animal {
        Animal::Dog => "A friendly dog.".to_string(),
        Animal::Cat(name) => format!{"A cat named {name}."}, 
        Animal::Bird{species, can_fly} => 
            format!{"A {spec} that {fly} fly.", spec = species, fly = if *can_fly == true {"can"} else {"cannot"}}
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

vanos001

12 days ago

3.29ms

87.38kb

pub enum Animal {
    // Define the Animal variants here
    Dog,
    Cat(String),
    Bird{
        species : String,
        can_fly : bool,
    },
}
pub fn describe_animal(animal: &Animal) -> String {
    // Your code here...
    return match animal{
        Animal::Dog => "A friendly dog.".to_string(),
        Animal::Cat(t) => format!("A cat named {t}."),
        Animal::Bird{species : s,can_fly : b} => {
            if *b {
                format!("A {s} that can fly.")
            }else{
                format!("A {s} that cannot fly.")
            }
        },
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

Enes

enesscevik

13 days ago

3.32ms

87.38kb

pub enum Animal {
    // Define the Animal variants here
    Dog,
    Cat(String),
    Bird{species:String, can_fly:bool}
}
pub fn describe_animal(animal: &Animal) -> String {
    // Your code here...
    match animal {
        Animal::Dog => "A friendly dog.".to_owned(),
        Animal::Cat(st) => format!("A cat named {st}."),
        Animal::Bird{species, can_fly} => match can_fly {
            true => format!("A {species} that can fly."),
            false => format!("A {species} that cannot fly.")
        }
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

KuuShyn

13 days ago

3.15ms

87.38kb

pub enum Animal {
    // Define the Animal variants here
    Dog,
    Cat(String),
    Bird { species: String, can_fly: bool },
}
pub fn describe_animal(animal: &Animal) -> String {
    // Your code here...
    match animal {
        Animal::Dog => "A friendly dog.".to_string(),
        Animal::Cat(name) => format!("A cat named {name}."),
        Animal::Bird { species, can_fly } => {
            if *can_fly {
                format!("A {species} that can fly.")
            } else {
                format!("A {species} that cannot fly.")
            }
        }
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

Luigi Terrone

LuigiTer

14 days ago

4.40ms

87.38kb

pub enum Animal {
    // Define the Animal variants here
    Dog,
    Cat(String),
    Bird { species: String, can_fly: bool },
}
pub fn describe_animal(animal: &Animal) -> String {
    // Your code here...
    match animal {
        Animal::Dog => "A friendly dog.".to_string(),
        Animal::Cat(name) => format!("A cat named {}.", name),
        Animal::Bird{species, can_fly} => { 
            if *can_fly {
                format!("A {} that can fly.", species) 
            }
            else {
                 format!("A {} that cannot fly.", species) 
            }
        },
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

Karol Płatkowski

spoohie

15 days ago

3.15ms

87.38kb

pub enum Animal {
    Dog,
    Cat(String),
    Bird {species: String, can_fly: bool}
}
pub fn describe_animal(animal: &Animal) -> String {
    match animal {
        Animal::Dog => "A friendly dog.".to_string(),
        Animal::Cat(name) => format!("A cat named {name}."),
        Animal::Bird {species, can_fly: true} => format!("A {species} that can fly."),
        Animal::Bird {species, can_fly: false} => format!("A {species} that cannot fly."),
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

Heino Mortensen

hmortensen83

15 days ago

3.79ms

87.38kb

pub enum Animal {
    Dog,
    Cat(String),
    Bird { species: String, can_fly: bool }
}
pub fn describe_animal(animal: &Animal) -> String {
    match animal {
        Animal::Dog => "A friendly dog.".to_string(),
        Animal::Cat(name) => format!("A cat named {name}."),
        Animal::Bird {species, can_fly} => {
            if *can_fly {
                format!("A {species} that can fly.")
            } else {
                format!("A {species} that cannot fly.")
            }
        }
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

Smith Cruise

Smith-Cruise

15 days ago

3.39ms

87.38kb

pub enum Animal {
    // Define the Animal variants here
    Dog,
    Cat(String),
    Bird{species: String, can_fly: bool}
}
pub fn describe_animal(animal: &Animal) -> String {
    // Your code here...
    match animal {
        Animal::Dog => String::from("A friendly dog."),
        Animal::Cat(s) => format!("A cat named {}.", s),
        Animal::Bird{species, can_fly} => {
            if *can_fly {
                format!("A {} that can fly.", species)
            } else {
                format!("A {} that cannot fly.", species)
            }
        }
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

0x0f1

Paul4673

15 days ago

3.44ms

87.38kb

pub enum Animal {
    Dog, Cat(String), Bird { species: String, can_fly: bool }
}
pub fn describe_animal(animal: &Animal) -> String {
    match animal {
        Animal::Dog => "A friendly dog.".to_string(),
        Animal::Cat(name) => format!("A cat named {name}."),
        Animal::Bird {species, can_fly} =>
            match can_fly {
                true => format!("A {species} that can fly."), 
                false => format!("A {species} that cannot fly.")
            }
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

noomcreator

16 days ago

4.79ms

87.38kb

pub enum Animal {
    // Define the Animal variants here
    Dog,
    Cat(String),
    Bird{ species: String, can_fly: bool},
}
pub fn describe_animal(animal: &Animal) -> String {
    // Your code here...
    match animal {
        Animal::Dog => "A friendly dog.".to_string(),
        Animal::Cat(name) => format!("A cat named {name}."),
        Animal::Bird{ species, can_fly} => match can_fly {
           true => format!("A {species} that can fly."),
           false => format!("A {species} that cannot fly.")
        } 
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

dattruongdev

16 days ago

3.00ms

87.37kb

pub enum Animal {
    // Define the Animal variants here
    Dog, Cat(String), Bird {species: String, can_fly: bool}
}
pub fn describe_animal(animal: &Animal) -> String {
    // Your code here...
    match animal {
        Animal::Dog => "A friendly dog.".to_string(),
        Animal::Cat(name) => format!("A cat named {}.", name),
        Animal::Bird {species, can_fly} => format!("A {} that {} fly.",*species, if *can_fly { "can"} else {"cannot"} ),
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

Kr0wZ

17 days ago

4.19ms

87.38kb

pub enum Animal {
    // Define the Animal variants here
    Dog,
    Cat(String),
    Bird {
        species: String,
        can_fly: bool,
    },
}
pub fn describe_animal(animal: &Animal) -> String {
    // Your code here...
    match animal {
        Animal::Dog => String::from("A friendly dog."),
        Animal::Cat(name) => format!("A cat named {}.", name),
        Animal::Bird{species, can_fly} => {
            if *can_fly { format!("A {} that can fly.", species) }
            else { format!("A {} that cannot fly.", species) }
        },
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

silaskoemen

18 days ago

3.21ms

87.37kb

pub enum Animal {
    Dog,
    Cat(String),
    Bird { species: String, can_fly: bool }
}
pub fn describe_animal(animal: &Animal) -> String {
    match animal {
        Animal::Dog => "A friendly dog.".to_string(),
        Animal::Cat(name) => format!("A cat named {}.", name),
        Animal::Bird { species, can_fly } => format!("A {species} that {} fly.", if *can_fly {"can"} else {"cannot"}),
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

Sarthak Mishra

sithtsar

18 days ago

3.23ms

87.38kb


pub enum Animal {
    // Define the Animal variants here
    Dog,
    Cat(String),
    Bird{species : String , can_fly : bool},
}
pub fn describe_animal(animal: &Animal) -> String {
    // Your code here...
    let res = match animal{
        Animal::Dog => "A friendly dog.".to_string(), 
        Animal::Cat(name) => format!("A cat named {}.",name),
        Animal::Bird{species, can_fly : true } => format!("A {} that can fly.", species),
        Animal::Bird{species, can_fly : false} => format!("A {} that cannot fly.", species),
    };
    res
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

Tri Nguyen

nguyentri

18 days ago

3.18ms

87.38kb


pub enum Animal {
    // Define the Animal variants here
    Dog,
    Cat(String),
    Bird {
        species: String,
        can_fly: bool,
    },
}
pub fn describe_animal(animal: &Animal) -> String {
    // Your code here...
    match animal {
        Animal::Dog => "A friendly dog.".to_string(),
        Animal::Cat(name) => format!("A cat named {}.", name.to_string()),
        Animal::Bird{species, can_fly} => {
            match can_fly{
                true => format!("A {} that can fly.", species), 
                false => format!("A {} that cannot fly.", species),
            }
        }
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

xxxxsk

20 days ago

3.33ms

87.38kb

pub enum Animal {
    // Define the Animal variants here
    Dog,
    Cat(String),
    Bird {
        species: String,
        can_fly: bool,
    },
}
pub fn describe_animal(animal: &Animal) -> String {
    // Your code here...
    match animal {
        Animal::Dog => "A friendly dog.".to_string(),
        Animal::Cat(name) => format!("A cat named {}.", name),
        Animal::Bird { species, can_fly } => {
            if *can_fly {
                format!("A {} that can fly.", species)
            } else {
                format!("A {} that cannot fly.", species)
            }
        }
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

Rocky.C

cloki0610

20 days ago

3.54ms

87.38kb

pub enum Animal {
    // Define the Animal variants here
    Dog,
    Cat(String),
    Bird { species: String, can_fly: bool},
}
pub fn describe_animal(animal: &Animal) -> String {
    // Your code here...
    match animal {
        Animal::Dog => String::from("A friendly dog."),
        Animal::Cat(name) => format!("A cat named {name}."),
        Animal::Bird{ species, can_fly } => {
            if *can_fly {
                format!("A {species} that can fly.")
            } else {
                format!("A {species} that cannot fly.")
            }
        }
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

Rocky.C

cloki0610

20 days ago

3.52ms

87.38kb

pub enum Animal {
    // Define the Animal variants here
    Dog,
    Cat(String),
    Bird { species: String, can_fly: bool},
}
pub fn describe_animal(animal: &Animal) -> String {
    // Your code here...
    match animal {
        Animal::Dog => "A friendly dog.".to_string(),
        Animal::Cat(name) => format!("A cat named {name}."),
        Animal::Bird{ species, can_fly } => {
            if *can_fly {
                format!("A {species} that can fly.")
            } else {
                format!("A {species} that cannot fly.")
            }
        }
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

Pierre Gordo

PierreGordo

21 days ago

3.87ms

87.38kb

pub enum Animal {
    // Define the Animal variants here
    Dog,
    Cat(String),
    Bird{species: String, can_fly: bool},
}
pub fn describe_animal(animal: &Animal) -> String{
    match animal{
        Animal::Dog => "A friendly dog.".to_string(),
        Animal::Cat(name) => format!("A cat named {name}."),
        Animal::Bird{species, can_fly} => {
            if *can_fly{
                format!("A {species} that can fly.")
            }
            else{
                format!("A {species} that cannot fly.")
            }
        },
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

Gomathi Shankar

gomathishankar37

21 days ago

4.12ms

87.38kb

pub enum Animal {
    Dog,
    Cat(String),
    Bird {
        species: String,
        can_fly: bool,
    },
}
pub fn describe_animal(animal: &Animal) -> String {
    // Your code here...
    match animal {
        Animal::Dog => String::from("A friendly dog."),
        Animal::Cat(name) => format!("A cat named {}.", name),
        Animal::Bird { species, can_fly } => if *can_fly {
            format!("A {} that can fly.", species)
        } else {
            format!("A {} that cannot fly.", species)
        }
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

Satya Sundar Sahu

satya200

21 days ago

3.86ms

87.38kb

pub enum Animal {
    // Define the Animal variants here
    Dog,
    Cat(String),
    Bird { species: String, can_fly: bool }
}
pub fn describe_animal(animal: &Animal) -> String {
    // Your code here...
    match animal {
        Animal::Dog => "A friendly dog.".to_string(),
        Animal::Cat(name) => format!("A cat named {name}."),
        Animal::Bird{species, can_fly} => if *can_fly == true {
            format!("A {species} that can fly.")
        }
        else {
            format!("A {species} that cannot fly.")
        }
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

Lucop1911

21 days ago

3.89ms

87.38kb

pub enum Animal {
    // Define the Animal variants here
    Dog,
    Cat(String),
    Bird {species: String, can_fly: bool}
}
pub fn describe_animal(animal: &Animal) -> String {
    // Your code here...
    match animal {
        Animal::Dog => format!("A friendly dog."),
        Animal::Cat(name) => format!("A cat named {name}."),
        Animal::Bird{ species, can_fly } => {
            if *can_fly {
                format!("A {species} that can fly.")
            } else {
                format!("A {species} that cannot fly.")
            }
        }
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

hahu07

23 days ago

3.68ms

87.38kb

pub enum Animal {
    Dog,
    Cat(String),
    Bird{species: String, can_fly: bool},
}
pub fn describe_animal(animal: &Animal) -> String {
    match animal {
        Animal::Dog => String::from("A friendly dog."),
        Animal::Cat(name) => format!("A cat named {name}."),
        Animal::Bird{species, can_fly} => {
            if *can_fly {
                format!("A {species} that can fly.")
             } else {
                format!("A {species} that cannot fly.")
             }
        }
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

s.i

ssmi75

24 days ago

3.79ms

87.38kb

pub enum Animal {
    Dog,
    Cat(String),
    Bird{species: String, can_fly: bool},
}
pub fn describe_animal(animal: &Animal) -> String {
    match animal {
        Animal::Dog => String::from("A friendly dog."),
        Animal::Cat(name) => format!("A cat named {name}."),
        Animal::Bird{species, can_fly} => {
            if *can_fly {
                format!("A {species} that can fly.")
             } else {
                format!("A {species} that cannot fly.")
             }
        }
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

ikatlinsky

24 days ago

3.26ms

87.38kb

pub enum Animal {
    Dog,
    Cat(String),
    Bird {species: String, can_fly: bool},
}
pub fn describe_animal(animal: &Animal) -> String {
    match animal {
        Animal::Dog => String::from("A friendly dog."),
        Animal::Cat(name) => format!("A cat named {name}."),
        Animal::Bird {species, can_fly} => if *can_fly {
            format!("A {species} that can fly.")
        } else {
            format!("A {species} that cannot fly.")
        }
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

Tim

timvyy

a month ago

3.01ms

87.38kb

pub enum Animal {
    // Define the Animal variants here
    Dog,
    Cat(String),
    Bird {
        species: String,
        can_fly: bool,
    },
}
pub fn describe_animal(animal: &Animal) -> String {
    // Your code here...
    match animal {
        Animal::Dog => String::from("A friendly dog."),
        Animal::Cat(name) => format!("A cat named {name}."),
        Animal::Bird { species, can_fly } => {
            if *can_fly {
                format!("A {species} that can fly.")
            } else {
                format!("A {species} that cannot fly.")
            }
        },
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

diucicd

a month ago

3.03ms

87.38kb

pub enum Animal {
    // Define the Animal variants here
    Dog,
    Cat(String),
    Bird {species: String, can_fly: bool},
}
pub fn describe_animal(animal: &Animal) -> String {
    // Your code here...
    match animal {
        Animal::Dog => "A friendly dog.".to_string(),
        Animal::Cat(name) => format!("A cat named {name}."),
        Animal::Bird{species, can_fly} => {
            if *can_fly {
                format!("A {species} that can fly.")
            } else {
                format!("A {species} that cannot fly.")
            }
        }
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

Gabriel Menezes

GMNDS

a month ago

3.24ms

87.38kb

pub enum Animal {
    Dog,
    Cat(String),
    Bird {species: String, can_fly: bool}
}
pub fn describe_animal(animal: &Animal) -> String {
    match animal {
        Animal::Dog => "A friendly dog.".to_string(),
        Animal::Cat(name) => format!("A cat named {name}."),
        Animal::Bird {species, can_fly} => {
            if *can_fly {
                format!("A {species} that can fly.")
            } else {
                format!("A {species} that cannot fly.")
            }
        }
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

HusseinAbdelhamid

a month ago

3.49ms

87.38kb

pub enum Animal {
    // Define the Animal variants here
    Dog,
    Cat(String),
    Bird{species: String,can_fly: bool},
}
pub fn describe_animal(animal: &Animal) -> String {
    // Your code here...
    match animal{
        Animal::Dog => "A friendly dog.".to_string(),
        Animal::Cat(name) => format!("A cat named {name}."),
        Animal::Bird{species,can_fly} => {
            if *can_fly{
                format!("A {} that can fly.",species)
            }else{
                format!("A {} that cannot fly.",species)
            }
        }
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}