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

JesAlbLop

JesAlblop

6 days ago

3.16ms

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}=>{
            let mut ex = "";
            if !can_fly {ex="not"}
            format!("A {} that can{} fly.", species,ex)
            }
    }
}
// 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.");
}

Octavian

orouwk

6 days ago

4.09ms

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}=>{
            let mut ex = "";
            if !can_fly {ex="not"}
            format!("A {} that can{} fly.", species,ex)
            }
    }
}
// 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.");
}

anhdoo

TuanAnhDoHoang

9 days ago

4.71ms

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 => {return "A friendly dog.".to_string();}
        Animal::Cat(cat_name) => {
            let ret_val = format!("A cat named {}.", cat_name);
            return String::from(ret_val);
        }
        Animal::Bird{species, can_fly} => {
            if *can_fly{
               return format!("A {} that can fly.", species).to_string();
            }
            else{
               return format!("A {} that cannot fly.", species).to_string();
            }
        }
        _ => {return "".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.");
}

Stas

nevmstas

11 days ago

3.36ms

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

Gurneet singh

GS-Jatt

11 days ago

3.83ms

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(n)=>format!("A cat named {n}."),
        Animal::Bird{species,can_fly}=>{
            let a = if *can_fly {
                "can fly"
            }else{
                "cannot fly"
            };
            
            format!("A {species} that {a}.")}
    }
}
// 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.");
}

Tristan Young

DragonBeast829

12 days ago

3.57ms

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

Wenceslas E. Jonah

WencesJ

12 days ago

4.60ms

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 } => {
            let verb = if *can_fly { "can" }
            else { "cannot" };
            format!("A {} that {} fly.", species, verb)
        },
    }
}
// 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.");
}

Teimur Gasanov

teimurjan

13 days ago

3.51ms

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,
        } => {
            let verb = if *can_fly { "can" } else { "cannot" };
            format!("A {} that {} fly.", species, verb)
        },
    }
}
// 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.");
}

Kanak Shilledar

kanakshilledar

13 days ago

4.08ms

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),
        Animal::Bird{species, can_fly} => {
            match can_fly {
                true => format!("A {species} that can fly.").to_string(),
                false => 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.");
}

Dante Kelly

dantekelly

15 days ago

3.80ms

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) => String::from(format!("A cat named {name}.")),
        Animal::Bird{species, can_fly} => {
            match can_fly {
                true => String::from(format!("A {species} that can fly.")),
                false => String::from(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.");
}

zazapalm3012

15 days ago

4.21ms

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 == &true {
                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.");
}

Nicolai

Posmac

16 days ago

6.08ms

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(s) => return String::from(format!("A cat named {}.", s)),
        Animal::Bird{ species, can_fly } => {
            match can_fly {
                true => String::from(format!("A {} that can fly.", species)),
                false => String::from(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.");
}

LLukeDB

17 days ago

3.21ms

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

Elizabeth Doughty

Thymelizabeth

18 days ago

3.69ms

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

Health-Care-Movie

18 days ago

4.08ms

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::Bird{species, can_fly} => if *can_fly {format!("A {species} that can fly.")} else {format!("A {species} that cannot fly.")},
        Animal::Cat(name) => format!("A cat named {name}."),
        _ => "A friendly dog.".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.");
}

Thomastienn

18 days ago

3.07ms

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

Splatrac

splatrac

18 days ago

6.12ms

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

Trịnh Chấn Duy

Duyyy123

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

Najib-Kassab

23 days ago

4.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 => "A friendly dog.".to_string(),
        Animal::Cat(name) => format!("A cat named {}.", name),
        Animal::Bird{species,can_fly}  => {
            if *can_fly ==true{
            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.");
}

Liyqq

23 days ago

3.66ms

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

adamegao

24 days ago

3.22ms

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

cyberspace lee

cyberspacelee

25 days ago

3.90ms

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

nabil-Tounarti

a month ago

5.16ms

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

agamaontherock

a month ago

5.46ms

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

Neel Knight

NeelKnight

a month ago

4.55ms

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 } => { 
            format!("A {species} that can{} fly.", if !*can_fly {"not"} else { "" })
        },
    }
}
// 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.");
}

TestingPurpose14

a month ago

7.43ms

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(cat) => format!("A cat named {}.", cat),
        Animal::Bird{ species, can_fly} => format!("A {} that can{} fly.", species, if !*can_fly {"not"} else { "" }),
    }
}
// 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.");
}

Sergey

Themelok

a month ago

4.16ms

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 } => format!("A {species} that can{} fly.", if !*can_fly { "not" } else {""}),
    }
}
// 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.");
}

Sergey Zubkov

ksevelyar

a month ago

3.36ms

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

Nathan GAUD

Natchica

a month ago

3.40ms

87.38kb

#![allow(dead_code)]
struct Dog;
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 {} 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.");
}

mishbah

a month ago

3.39ms

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(x) => format!("A cat named {x}."),
        Animal::Bird{ species, can_fly } => format!("A {species} that {}.", if *can_fly { "can fly" } else { "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.");
}

Anderson

Anderon-hk

a month ago

4.05ms

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),
        Animal::Bird { species, can_fly } => {
            let start = format!("A {} that", species);
            if *can_fly {
                return format!("{} can fly.", start);
            } else {
                return format!("{} cannot fly.", start);
            }
        }
    }
}
// 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.");
}

torbenhardt

a month ago

3.71ms

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} => {
            let mut can_cannot = "";
            if !can_fly { can_cannot = "not"; }
            format!("A {} that can{} fly.", species, can_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.");
}

RASHMOR

RASHMOR1

a month ago

4.99ms

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

Maintain

duonghb53

a month ago

3.16ms

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

Deepanshu Mishra

DeepanshuMishraa

a month ago

3.54ms

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

Pycub

pycub

a month ago

2.94ms

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 } => {
            let verb: String;
            match can_fly {
                true => { verb = "can".to_string(); },
                false => { verb = "cannot".to_string(); },
            }
            format!("A {} that {} fly.", species, verb)
        }
    }
}
// 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.");
}

Pycub

pycub

a month ago

4.70ms

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 } => {
            let can_fly_verb: String;
            if *can_fly {
                can_fly_verb = "can".to_string();
            } else {
                can_fly_verb = "cannot".to_string();
            }
            format!("A {} that {} fly.", species, can_fly_verb)
        }
    }
}
// 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.");
}

Jakub Wiśniewski

wisniewskij

a month ago

3.98ms

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

Jakub Wiśniewski

wisniewskij

a month ago

4.56ms

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

Paolo Cancedda

Pac72

a month ago

3.42ms

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

Jason

Jason-fy-wang

a month ago

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

Nguyen Vo Hoang Son

sonmessia

a month 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 => "A friendly dog.".to_string(),
        Animal::Cat(name) => format!("A cat named {}.", name),
        Animal::Bird {species, can_fly} => {
            if *can_fly == true {
                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.");
}

Nhat Vu

NhatTinyVu

a month ago

4.76ms

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

Leo Phạm

HongThaiPham

a month ago

3.84ms

87.41kb

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) => format!("A cat named {}.", name).to_string(),
        Animal::Bird { species, can_fly } => {
            match can_fly {
                true => format!("A {} that can fly.", species).to_string(),
                false => 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.");
}

pop_eax

pop-eax

a month ago

6.69ms

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

vijayabhaskar badireddi

ptcte

a month ago

4.41ms

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

Seth Wood

seth-wood

a month ago

3.06ms

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

Levio-z

2 months ago

3.09ms

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.".into(),
       Animal:: Cat(name) => format!("A cat named {}.",name),
       Animal:: Bird { species, can_fly} => {
        let can_fly = if *can_fly { "" } else { "not" };
        format!("A {} that can{} fly.",species,can_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.");
}

Max

maxemontio

2 months ago

4.07ms

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 == true {
                    format!("A {species} that can fly.")
                } else {
                    format!("A {species} that cannot fly.")
                }
            }
    }
}
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.");
}

EduardoFernandess

2 months ago

3.27ms

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