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

Smith, Taylor

a647965_fidelity

2 hours ago

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

Vitalol

4 hours ago

3.62ms

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

Selim Gökmen

sgoekmen

6 hours ago

3.41ms

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

Raj

irajgill

20 hours ago

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

greg95000

a day ago

3.64ms

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

AyotuntosimiLoye

2 days ago

4.20ms

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...
    use crate::Animal::*;
    match animal {
        Dog => "A friendly dog.".to_string(),
        Cat(name) => format!("A cat named {name}."),
        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.");
}

Yury

Just-Captain

3 days ago

5.33ms

87.38kb

pub enum Animal {
    // Define the Animal variants here
    Dog,
    Cat(String),
    Bird{
        species: String,
        can_fly: bool
    },
}
pub struct Bird {
    species: String,
    can_fly: bool,
}
pub fn describe_animal(animal: &Animal) -> String {
    match animal {
        Animal::Dog => format!("A friendly dog."),
        Animal::Cat(name) => 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.");
}

Christophe Mohimont

mohic

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

JIA

bytesxz

4 days ago

4.42ms

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(x) => format!("A cat named {x}."),
       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.");
}

Muhammad Rizki Rijal

eezhal92

4 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 {
                return format!("A {} that cannot fly.", species);
            }
            return format!("A {} that can 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.");
}

RaccoonDX

4 days ago

2.98ms

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

mickaelactel

4 days ago

3.62ms

87.41kb

pub enum Animal {
    Dog,
    Cat(String),
    Bird { species: String, can_fly: bool }
}
pub fn describe_animal(animal: &Animal) -> String {
    return 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.");
}

Paolo Deidda

DePoli97

5 days ago

3.00ms

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

Paolo Deidda

DePoli97

5 days ago

4.94ms

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

Paolo Deidda

DePoli97

5 days ago

3.06ms

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

Paolo Deidda

DePoli97

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

Paolo Deidda

DePoli97

5 days ago

3.20ms

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

Connor States

ConnorStates0

6 days ago

3.46ms

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

Heorhii

Kagev

6 days ago

3.54ms

87.38kb

pub enum Animal {
    // Define the Animal variants he
    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 == false {
                format!("A {} that cannot fly.", species)
            } else {
                format!("A {} that can 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.");
}

amdfxlucas

6 days ago

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

bryan-pignerol

6 days ago

3.39ms

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

firefly

KamisAyaka

7 days ago

3.71ms

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

Solange

SolangeLL

7 days ago

28.01ms

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

L. Gasc

L-GASC

8 days ago

3.18ms

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

P S

psvr

8 days ago

4.57ms

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

Varun D

varun-d

9 days ago

3.35ms

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 {} that can fly.", species)
    },
    Animal::Bird { species, can_fly: 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.");
}

ashishkr2912

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

Phong H.

doivjpxx

10 days ago

3.61ms

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 {
                return format!("A {} that can fly.", {species});
            }
            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.");
}

Juan Mejia

juan-mejia

11 days ago

3.25ms

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

Jean-Luc Brouillet

jeanlucbr

11 days ago

3.32ms

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

Siallus

12 days ago

3.61ms

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

Sasank Yadavalli

sasankyadavalli

12 days ago

5.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 => String::from("A friendly dog."),
        Animal::Cat(text) => format!("A cat named {}.", text),
        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.");
}

RASOANOMENJANAHARY Matio Mamy Nantenaina

devlucazh

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

LewkowskiArkadiusz

13 days ago

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

Bryan

yuyangchen23

14 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 {} that can fly.", species),
        Animal::Bird {species, can_fly: 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.");
}

Cristian Banu

cbanu96

14 days ago

3.35ms

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 {} that can fly.", species),
        Animal::Bird { species, can_fly: 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.");
}

Sergei Kaznakhovskii

fredeastside

14 days ago

3.75ms

87.37kb

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

StevenCanDrink

15 days ago

3.13ms

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 {} that can fly.", species),
        Animal::Bird { species, can_fly: 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.");
}

Felipe Marques de Almeida

fmalmeida

15 days ago

3.31ms

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

Fanzzzd

16 days ago

3.18ms

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

achla95

16 days ago

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

Lvfalue

17 days ago

3.71ms

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(c) => format!("A cat named {c}."),
        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.");
}

lurah11

18 days ago

3.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} => format!("A {} that {}.",species,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.");
}

David Rasch

dcrasch

18 days ago

3.38ms

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(description) => format!("A cat named {description}."),
        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.");
}

NotQuiteHere

notquitehere

19 days ago

4.50ms

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

GunGraveCpp

19 days ago

3.28ms

87.39kb

pub enum Animal {
    Dog,
    Cat(String),
    Bird { species: String, can_fly: bool } 
}
pub fn describe_animal(animal: &Animal) -> String {
    match animal {
        Animal::Dog => return "A friendly dog.".to_string(),
        Animal::Cat(name) => return format!("A cat named {name}.").to_string(),
        Animal::Bird{species, can_fly } if *can_fly => return format!("A {species} that can fly."),
        Animal::Bird{species, can_fly } => return 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.");
}

GunGraveCpp

19 days ago

2.91ms

87.39kb

pub enum Animal {
    Dog,
    Cat(String),
    Bird { species: String, can_fly: bool } 
}
pub fn describe_animal(animal: &Animal) -> String {
    match animal {
        Animal::Dog => return "A friendly dog.".to_string(),
        Animal::Cat(name) => return format!("A cat named {name}.").to_string(),
        Animal::Bird{species, can_fly } if *can_fly => return format!("A {species} that can fly."),
        Animal::Bird{species, can_fly } => return 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.");
}

Harold Indra

hindra2

19 days ago

4.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_string(),
        Animal::Cat(name) => 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.");
}

Christophe Pronier

chrpron

19 days ago

3.91ms

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

johnson

ssebide

19 days ago

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