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

KuuShyn

3 hours ago

3.15ms

87.38kb

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

Luigi Terrone

LuigiTer

21 hours ago

4.40ms

87.38kb

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

Karol Płatkowski

spoohie

a day ago

3.15ms

87.38kb

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

Heino Mortensen

hmortensen83

2 days ago

3.79ms

87.38kb

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

Smith Cruise

Smith-Cruise

2 days ago

3.39ms

87.38kb

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

0x0f1

Paul4673

2 days ago

3.44ms

87.38kb

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

noomcreator

3 days ago

4.79ms

87.38kb

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

dattruongdev

3 days ago

3.00ms

87.37kb

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

Kr0wZ

4 days ago

4.19ms

87.38kb

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

silaskoemen

4 days ago

3.21ms

87.37kb

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

Sarthak Mishra

sithtsar

5 days ago

3.23ms

87.38kb


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

Tri Nguyen

nguyentri

5 days ago

3.18ms

87.38kb


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

xxxxsk

7 days ago

3.33ms

87.38kb

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

Rocky.C

cloki0610

7 days ago

3.54ms

87.38kb

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

Rocky.C

cloki0610

7 days ago

3.52ms

87.38kb

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

Pierre Gordo

PierreGordo

8 days ago

3.87ms

87.38kb

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

Gomathi Shankar

gomathishankar37

8 days ago

4.12ms

87.38kb

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

Satya Sundar Sahu

satya200

8 days ago

3.86ms

87.38kb

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

Lucop1911

8 days ago

3.89ms

87.38kb

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

hahu07

10 days ago

3.68ms

87.38kb

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

s.i

ssmi75

11 days ago

3.79ms

87.38kb

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

ikatlinsky

11 days ago

3.26ms

87.38kb

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

Tim

timvyy

13 days ago

3.01ms

87.38kb

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

diucicd

14 days ago

3.03ms

87.38kb

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

Gabriel Menezes

GMNDS

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

HusseinAbdelhamid

15 days ago

3.49ms

87.38kb

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

esl

esl07

15 days ago

3.77ms

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

AQian

AQian0

18 days ago

3.53ms

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

ALDebugs

18 days ago

5.26ms

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

annececiledunand

19 days ago

3.89ms

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

Sergey Matyash

matiaspub

21 days ago

3.44ms

87.37kb

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

Francisco Garau

fgarau

22 days ago

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

GregGorin

22 days ago

3.85ms

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

ycgw

23 days ago

3.59ms

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

zapp42

23 days ago

3.23ms

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

LeonardoPinheiro23

23 days ago

3.32ms

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."),
        Animal::Bird { species, .. } => format!("A {species} that cannot fly."),
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

jbrakmic

23 days ago

4.02ms

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

Hendrik Dreesmann

DeemanOne

24 days ago

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

Saksinkarn Petchkuljinda

dward2nd

24 days ago

4.03ms

87.38kb

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

wry

Liudel

24 days ago

3.58ms

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(n) => format!("A cat named {}.", n),
        Animal::Bird { species, can_fly } => format!("A {} that {} fly.", species, if *can_fly {"can"} else {"cannot"})
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

Anatma2

24 days ago

6.38ms

87.38kb

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

Travis

ttmgraham

25 days ago

4.24ms

87.38kb

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

fomulate

finbaromahony

25 days ago

3.70ms

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 {} that {} fly.", species, if *can_fly { "can" } else { "cannot" }),
        // {
        //     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.");
}

Tommytto

25 days ago

4.68ms

87.38kb

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

Erik Hollembeak

futureperfect

25 days ago

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

AshutoshKumarPatel

a month ago

3.77ms

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

Ajit Kumar

urwithajit9

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

sjmellor

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

AlphaN00mer1cal

a month ago

4.52ms

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(s) => format!("A cat named {}.", s),
        Animal::Bird {species, can_fly} => if *can_fly { format!("A {} that can fly.", species) } else { format!("A {} that cannot fly.", species) }
    }
}
// Example use case
pub fn main() {
    let dog = Animal::Dog;
    assert_eq!(describe_animal(&dog), "A friendly dog.");
    let cat = Animal::Cat("Whiskers".to_string());
    assert_eq!(describe_animal(&cat), "A cat named Whiskers.");
    let bird = Animal::Bird {
        species: "Penguin".to_string(),
        can_fly: false,
    };
    assert_eq!(describe_animal(&bird), "A Penguin that cannot fly.");
}

Maicon Crespo

maiconcrespo

a month ago

4.87ms

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