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

Franklin Chen

FranklinChen

20 hours 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_owned(),
        Animal::Cat(name) => format!("A cat named {name}."),
        Animal::Bird { species, can_fly } => {
            let verb = if *can_fly { "can" } else { "cannot" };
            format!("A {species} that {verb} 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éa Narzis

lean-apple

a day ago

4.53ms

87.38kb

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

Tboot

tboot-0510

a day ago

3.82ms

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

Muhammad Najib Bala

NAJIB-B

a day ago

3.48ms

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

vojta stefan

vojtastefan

a day ago

3.18ms

87.38kb

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

Pranav Garg

PranavGarg01

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

Hung Dinh

nhdinh

2 days ago

14.10ms

87.38kb

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

gsspdev

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

AnKarl

Zythophilus

3 days ago

6.47ms

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

amaneru

7ma8no9

3 days ago

3.42ms

87.37kb

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

AKA.MoneyTaker

M4Bo2

5 days ago

4.65ms

87.38kb

// Define the Animal enum with the specified variants
pub enum Animal {
    Dog, // Unit struct variant
    Cat(String), // Tuple struct variant
    Bird { species: String, can_fly: bool }, // Named field struct variant
}
// Function to return a description of the animal
pub fn describe_animal(animal: &Animal) -> String {
    // Match the Animal variant and return the corresponding description
    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.");
}

Artyom Chebotarev

Derik117

5 days ago

3.12ms

87.38kb

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

Kamuran

karapy

5 days ago

4.09ms

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

Dimas Avrian Fachriza.

FForFachriza

5 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 {} that can fly.", species),
                false => format!("A {} that cannot fly.", species),
            }
        },
    }
}

zawwwu

6 days ago

7.72ms

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

Éric Villani

TheTrueCaligari

7 days ago

3.77ms

87.41kb

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

Lê Minh Quân

aleister1102

8 days ago

3.50ms

87.41kb

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

Yi Hao

leongyihao

10 days ago

3.75ms

87.38kb

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

TiagONTOP

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

Dyaa Adel

dyaa-adel

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

Anıl Şenay

anilsenay

11 days ago

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

Vladimir

PavluninVladimir

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

Ayushman Rathore

Spartan09

11 days ago

5.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.".into(),
        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, can_fly: _ } => 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.");
}

norabbito

11 days ago

24.03ms

87.41kb

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

norabbito

11 days ago

3.90ms

87.41kb

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

Christopher Kolbe

chkolbe

12 days ago

2.84ms

87.41kb

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

Jordan

Jordan-Haidee

13 days ago

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

SeinPierre

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

Kyle Diaz

kylediaz

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

Guilherme Cesário Strachan

strachan

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

Guilherme Cesário Strachan

strachan

15 days ago

2.92ms

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

dcodes

dcodesdev

15 days ago

4.58ms

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

McToady.eth

McCoady

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

Kenneth Love

kennethlove

16 days ago

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

Prafful

iamsahu

17 days ago

5.34ms

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

Douglas Campbell

CampbellD84

18 days ago

3.07ms

87.38kb

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

ludovicknecht

18 days ago

2.91ms

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

Whisper_icoma

1378046967

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

Muhammad-Dennis

19 days ago

3.29ms

87.38kb

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

Diego Maia

diegocmsantos

19 days ago

3.15ms

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

automata-studio

20 days ago

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

kosay

sarub0b0

20 days ago

4.10ms

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

Denis SOURON

Brack0

20 days ago

3.10ms

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

Benjamin Falk

lumio

20 days ago

5.10ms

87.37kb

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

Benjamin Falk

lumio

20 days ago

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

manuelmj

21 days ago

3.10ms

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

manuelmj

21 days ago

3.78ms

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

Donald Huber-Youmans

dHuberYoumans

21 days ago

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

alemack17

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

buu

bushuai

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