Return Trait Objects

Sometimes, the Rust compiler cannot determine the size of a trait object at compile time. For example, if a function returns a trait object based on a condition, in such cases, impl Trait is not going to work. This is because the size of the trait object is not known at compile time. In such cases, you can use Box<dyn Trait> to return a trait object.

Box<T> lets you allocate memory on the heap and store the value of T in that memory. Box<dyn Trait> is a trait object that allows you to store a value of any type that implements Trait in the heap.

This is called dynamic dispatch because the method to call is determined at runtime, not at compile time. This is in contrast to static dispatch, where the method to call is determined at compile time.

Your Task

You need to define a function that returns a Box<dyn Speakable> based on a condition.

Here is what you need to do:

Define the Speakable trait with a method speak that returns a String.
Define a struct Dog with two fields: name and breed, both of type String.
Implement the Speakable trait for Dog to return a string Woof.
Define a struct Robot with two fields: model and purpose, both of type String.
Implement the Speakable trait for Robot to return a string Beep boop.
Finish the function get_speaker that takes a &str parameter and returns either a Dog or a Robot based on the parameter.
The parameter can either be dog or robot.

Editor not available on Mobile!

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

Solutions

amaneru

7ma8no9

12 hours ago

3.29ms

87.38kb

pub trait Speakable {
    fn speak(&self) -> String;
}
pub struct Dog {
    pub name: String,
    pub breed: String,
}
pub struct Robot {
    pub model: String,
    pub purpose: String,
}
impl Speakable for Dog {
    fn speak(&self) -> String {
        "Woof".to_string()
    }
}
impl Speakable for Robot {
    fn speak(&self) -> String {
        "Beep boop".to_string()
    }
}
pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
            // Return a Dog instance here
            Box::new(Dog {
                name: "doggy".to_string(),
                breed: "".to_string(),
            })
        }
        "robot" => {
            // Return a Robot instance here
            Box::new(Robot {
                model: "deepseek".to_string(),
                purpose: "".to_string(),
            })
        }
        _ => panic!("Unknown speaker type"),
    }
}
// Example usage
pub fn main() {
    let dog_speaker = get_speaker("dog");
    println!("{}", dog_speaker.speak()); // Expected output: Woof
    let robot_speaker = get_speaker("robot");
    println!("{}", robot_speaker.speak()); // Expected output: Beep boop
}

AKA.MoneyTaker

M4Bo2

2 days ago

4.79ms

87.39kb

pub trait Speakable {
    fn speak(&self) -> String;
}
pub struct Dog {
    pub name: String,
    pub breed: String,
}
impl Speakable for Dog {
    fn speak(&self) -> String {
        "Woof".to_string()
    }
}
pub struct Robot {
    pub model: String,
    pub purpose: String,
}
impl Speakable for Robot {
    fn speak(&self) -> String {
        "Beep boop".to_string()
    }
}
pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => Box::new(Dog {
            name: "Doggie".to_string(),
            breed: "Frenchie".to_string(),
        }),
        "robot" => Box::new(Robot {
            model: "RSX".to_string(),
            purpose: "Cleaning".to_string(),
        }),
        _ => panic!("Unknown speaker type"),
    }
}
// Example usage
pub fn main() {
    let dog_speaker = get_speaker("dog");
    println!("{}", dog_speaker.speak()); // Expected output: Woof
    let robot_speaker = get_speaker("robot");
    println!("{}", robot_speaker.speak()); // Expected output: Beep boop
}

Guilherme Cesário Strachan

strachan

3 days ago

3.37ms

87.39kb

pub trait Speakable {
    fn speak(&self) -> String;
}
pub struct Dog {
    pub name: String,
    pub breed: String,
}
impl Speakable for Dog {
    fn speak(&self) -> String {
        "Woof".to_string()
    }
}
pub struct Robot {
    pub model: String,
    pub purpose: String,
}
impl Speakable for Robot {
    fn speak(&self) -> String {
        "Beep boop".to_string()
    }
}
pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => Box::new(Dog {
            name: "Doggie".to_string(),
            breed: "Frenchie".to_string(),
        }),
        "robot" => Box::new(Robot {
            model: "RSX".to_string(),
            purpose: "Cleaning".to_string(),
        }),
        _ => panic!("Unknown speaker type"),
    }
}
// Example usage
pub fn main() {
    let dog_speaker = get_speaker("dog");
    println!("{}", dog_speaker.speak()); // Expected output: Woof
    let robot_speaker = get_speaker("robot");
    println!("{}", robot_speaker.speak()); // Expected output: Beep boop
}

Muhammad-Dennis

4 days ago

4.19ms

87.40kb

pub trait Speakable {
    fn speak(&self) -> String;
}
pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
            // Return a Dog instance here
            Box::new(Dog {
                name: String::from("Netanyahu"),
                breed: String::from("Dog of hell")
            })
        }
        "robot" => {
            // Return a Robot instance here
            Box::new(Robot {
                model: String::from("T1000"),
                purpose: String::from("To destroy humanity")
            })
        }
        _ => panic!("Unknown speaker type"),
    }
}
pub struct Dog {
    pub name: String,
    pub breed: String,
}
impl Speakable for Dog {
    fn speak(&self) -> String {
        String::from("Woof")
    }
}
pub struct Robot {
    pub model: String,
    pub purpose: String
}
impl Speakable for Robot {
    fn speak(&self) -> String {
        String::from("Beep boop")
    }
}
// Example usage
pub fn main() {
    let dog_speaker = get_speaker("dog");
    println!("{}", dog_speaker.speak()); // Expected output: Woof
    let robot_speaker = get_speaker("robot");
    println!("{}", robot_speaker.speak()); // Expected output: Beep boop
}

Anıl Şenay

anilsenay

5 days ago

4.11ms

87.39kb

pub trait Speakable {
    fn speak(&self) -> String;
}
pub struct Dog {
    pub name: String,
    pub breed: String,
}
impl Speakable for Dog {
    fn speak(&self) -> String {
        "Woof".to_string()
    }
}
pub struct Robot {
    pub model: String,
    pub purpose: String,
}
impl Speakable for Robot {
    fn speak(&self) -> String {
        "Beep boop".to_string()
    }
}
pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => Box::new(Dog {
            name: "Unknown".to_string(),
            breed: "Unknown".to_string(),
        }),
        "robot" => Box::new(Robot {
            model: "Unknown".to_string(),
            purpose: "Unknown".to_string(),
        }),
        _ => panic!("Unknown speaker type"),
    }
}
// Example usage
pub fn main() {
    let dog_speaker = get_speaker("dog");
    println!("{}", dog_speaker.speak()); // Expected output: Woof
    let robot_speaker = get_speaker("robot");
    println!("{}", robot_speaker.speak()); // Expected output: Beep boop
}

Dyaa Adel

dyaa-adel

6 days ago

3.26ms

87.40kb

pub trait Speakable {
    fn speak(&self) -> String;
}
pub struct Dog {
    pub name : String,
    pub breed: String
}
impl Speakable for Dog {
     fn speak(&self) -> String {
        String::from("Woof")
     }
}
pub struct Robot {
    pub model : String,
    pub purpose: String
}
impl Speakable for Robot {
     fn speak(&self) -> String {
        String::from("Beep boop")
     }
}
pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
            Box::new(Dog {
                name : String::from("dog_name"),
                breed : String::from("breed_name")
            })
        }
        "robot" => {
            Box::new(Robot {
                model : String::from("dog_name"),
                purpose : String::from("breed_name")
            })
            // Return a Robot instance here
        }
        _ => panic!("Unknown speaker type"),
    }
}
// Example usage
pub fn main() {
    let dog_speaker = get_speaker("dog");
    println!("{}", dog_speaker.speak()); // Expected output: Woof
    let robot_speaker = get_speaker("robot");
    println!("{}", robot_speaker.speak()); // Expected output: Beep boop
}

manuelmj

8 days ago

3.70ms

87.38kb


pub trait Speakable{
    fn speak(&self)->String;
}
pub struct Dog{
    pub name: String, 
    pub breed: String
}
impl Dog {
    fn new()-> Dog{
        Dog {name:String::new(),
        breed: String::new()
        }
    }
}
impl Speakable for Dog{
    fn speak(&self)->String{
        String::from("Woof")
    }
}
pub struct Robot{
    pub model: String, 
    pub purpose: String
}
impl Robot {
    fn new()->Robot{
        Robot{
            model: String::new(),
            purpose: String::new()
        }
    }
}
impl Speakable for Robot{
    fn speak(&self)->String{
        String::from("Beep boop")
    }
}
pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
            // Return a Dog instance here
            Box::new(Dog::new())             
                    
        }
        "robot" => {
            // Return a Robot instance here
            Box::new(Robot::new()) 
        }
        _ => panic!("Unknown speaker type"),
    }
}
// Example usage
pub fn main() {
    let dog_speaker = get_speaker("dog");
    println!("{}", dog_speaker.speak()); // Expected output: Woof
    let robot_speaker = get_speaker("robot");
    println!("{}", robot_speaker.speak()); // Expected output: Beep boop
}

manuelmj

8 days ago

5.50ms

87.38kb


pub trait Speakable{
    fn speak(&self)->String;
}
pub struct Dog{
    pub name: String, 
    pub breed: String
}
impl Dog {
    fn new()-> Dog{
        Dog {name:String::new(),
        breed: String::new()
        }
    }
}
impl Speakable for Dog{
    fn speak(&self)->String{
        String::from("Woof")
    }
}
pub struct Robot{
    pub model: String, 
    pub purpose: String
}
impl Robot {
    fn new()->Robot{
        Robot{
            model: String::new(),
            purpose: String::new()
        }
    }
}
impl Speakable for Robot{
    fn speak(&self)->String{
        String::from("Beep boop")
    }
}
pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
            // Return a Dog instance here
            Box::new(Dog::new())             
                    
        }
        "robot" => {
            // Return a Robot instance here
            Box::new(Robot::new()) 
        }
        _ => panic!("Unknown speaker type"),
    }
}
// Example usage
pub fn main() {
    let dog_speaker = get_speaker("dog");
    println!("{}", dog_speaker.speak()); // Expected output: Woof
    let robot_speaker = get_speaker("robot");
    println!("{}", robot_speaker.speak()); // Expected output: Beep boop
}

Kentaro Abe

abekem

9 days ago

3.51ms

87.38kb

pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
            Box::new(Dog {
                name: "d".to_string(),
                breed: "c".to_string(),
            })
        }
        "robot" => {
            Box::new(Robot {
                model: "a".to_string(),
                purpose: "b".to_string(),
            })
        }
        _ => panic!("Unknown speaker type"),
    }
}
pub trait Speakable {
    fn speak(&self) -> String;
}
pub struct Dog {
    pub name: String,
    pub breed: String,
}
impl Speakable for Dog {
    fn speak(&self) -> String {
        "Woof".to_string()
    }
}
pub struct Robot {
    pub model: String,
    pub purpose: String,
}
impl Speakable for Robot {
    fn speak(&self) -> String {
        "Beep boop".to_string()
    }
}
// Example usage
pub fn main() {
    let dog_speaker = get_speaker("dog");
    println!("{}", dog_speaker.speak()); // Expected output: Woof
    let robot_speaker = get_speaker("robot");
    println!("{}", robot_speaker.speak()); // Expected output: Beep boop
}

norabbito

9 days ago

3.41ms

87.38kb

pub trait Speakable {
    fn speak(&self) -> String;
}
pub struct Dog {
    pub name: String,
    pub breed: String,
}
pub struct Robot {
    pub model: String,
    pub purpose: String,
}
impl Speakable for Dog {
    fn speak(&self) -> String {
        String::from("Woof")
    }
}
impl Speakable for Robot {
    fn speak(&self) -> String {
        String::from("Beep boop")
    }
}
pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
            // Return a Dog instance here
            Box::new(Dog {
                name: "".to_string(),
                breed: "".to_string(),
            })
        }
        "robot" => {
            // Return a Robot instance here
            Box::new(Robot {
                model: "".to_string(),
                purpose: "".to_string(),
            })
        }
        _ => panic!("Unknown speaker type"),
    }
}
// Example usage
pub fn main() {
    let dog_speaker = get_speaker("dog");
    println!("{}", dog_speaker.speak()); // Expected output: Woof
    let robot_speaker = get_speaker("robot");
    println!("{}", robot_speaker.speak()); // Expected output: Beep boop
}

norabbito

9 days ago

3.83ms

87.38kb

pub trait Speakable {
    fn speak(&self) -> String;
}
pub struct Dog {
    pub name: String,
    pub breed: String,
}
pub struct Robot {
    pub model: String,
    pub purpose: String,
}
impl Speakable for Dog {
    fn speak(&self) -> String {
        String::from("Woof")
    }
}
impl Speakable for Robot {
    fn speak(&self) -> String {
        String::from("Beep boop")
    }
}
pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
            // Return a Dog instance here
            Box::new(Dog {
                name: "".to_string(),
                breed: "".to_string(),
            })
        }
        "robot" => {
            // Return a Robot instance here
            Box::new(Robot {
                model: "".to_string(),
                purpose: "".to_string(),
            })
        }
        _ => panic!("Unknown speaker type"),
    }
}
// Example usage
pub fn main() {
    let dog_speaker = get_speaker("dog");
    println!("{}", dog_speaker.speak()); // Expected output: Woof
    let robot_speaker = get_speaker("robot");
    println!("{}", robot_speaker.speak()); // Expected output: Beep boop
}

Ayushman Rathore

Spartan09

9 days ago

3.45ms

87.39kb

pub trait Speakable {
    fn speak(&self) -> String;
}
pub struct Dog {
    pub name: String,
    pub breed: String
}
pub struct Robot {
    pub model: String,
    pub purpose: String
}
impl Speakable for Dog {
    fn speak(&self) -> String {
        "Woof".into()
    }
}
impl Speakable for Robot {
    fn speak(&self) -> String {
        "Beep boop".into()
    }
}
pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
            Box::new(Dog { name: "cutiepie".to_string(), breed: "husky".to_string() })
        }
        "robot" => {
            Box::new(Robot { model: "kdj5454".to_string(), purpose: "assistant".to_string() })
        }
        _ => panic!("Unknown speaker type"),
    }
}
// Example usage
pub fn main() {
    let dog_speaker = get_speaker("dog");
    println!("{}", dog_speaker.speak()); // Expected output: Woof
    let robot_speaker = get_speaker("robot");
    println!("{}", robot_speaker.speak()); // Expected output: Beep boop
}

Jordan

Jordan-Haidee

12 days ago

4.23ms

87.39kb

pub struct Dog {
    pub name: String, 
    pub breed: String
}
pub struct Robot {
    pub model: String, 
    pub purpose: String
}
pub trait Speakable {
    fn speak(&self) -> String; 
}
impl Speakable for Dog {
    fn speak(&self) -> String {
        "Woof".to_string()
    }
}
impl Speakable for Robot {
    fn speak(&self) -> String {
        "Beep boop".to_string()
    }
}
pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
            Box::new(
                Dog {name: "dahuang".to_string(), breed: "jinmao".to_string()}
            )
        }
        "robot" => {
            Box::new(
                Robot {model: "halfcheetah".to_string(), purpose: "running".to_string()}
            )
        }
        _ => panic!("Unknown speaker type"),
    }
}
// Example usage
pub fn main() {
    let dog_speaker = get_speaker("dog");
    println!("{}", dog_speaker.speak()); // Expected output: Woof
    let robot_speaker = get_speaker("robot");
    println!("{}", robot_speaker.speak()); // Expected output: Beep boop
}

Jun Huang

leemars

13 days ago

3.31ms

87.38kb

pub struct Dog {
    pub name: String,
    pub breed: String,
}
pub struct Robot {
    pub model: String,
    pub purpose: String,
}
pub trait Speakable {
    fn speak(&self) -> String;
}
impl Speakable for Dog {
    fn speak(&self) -> String {
        "Woof".into()
    }
}
impl Speakable for Robot {
    fn speak(&self) -> String {
        "Beep boop".into()
    }
}
pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
            // Return a Dog instance here
            Box::new(Dog { name: "".into(), breed: "".into() })
        }
        "robot" => {
            // Return a Robot instance here
            Box::new(Robot { model: "".into(), purpose: "".into() })
        }
        _ => panic!("Unknown speaker type"),
    }
}
// Example usage
pub fn main() {
    let dog_speaker = get_speaker("dog");
    println!("{}", dog_speaker.speak()); // Expected output: Woof
    let robot_speaker = get_speaker("robot");
    println!("{}", robot_speaker.speak()); // Expected output: Beep boop
}

Kyle Diaz

kylediaz

14 days ago

3.27ms

87.38kb

pub struct Dog {
    pub name: String,
    pub breed: String,
}
pub struct Robot {
    pub model: String,
    pub purpose: String,
}
pub trait Speakable {
    fn speak(&self) -> String;
}
pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
            Box::new(
                Dog{
                    name: "".to_string(),
                    breed: "dog".to_string(),
                }
            )
        }
        "robot" => {
            Box::new(
                Robot{
                    model: "".to_string(), 
                    purpose: "butter".to_string(),
                }
            )
        }
        _ => panic!("Unknown speaker type"),
    }
}
impl Speakable for Dog {
    fn speak(&self) -> String {
        "Woof".to_string()
    }
}
impl Speakable for Robot {
    fn speak(&self) -> String {
        "Beep boop".to_string()
    }
}
// Example usage
pub fn main() {
    let dog_speaker = get_speaker("dog");
    println!("{}", dog_speaker.speak()); // Expected output: Woof
    let robot_speaker = get_speaker("robot");
    println!("{}", robot_speaker.speak()); // Expected output: Beep boop
}

Kenneth Love

kennethlove

15 days ago

3.34ms

87.39kb

pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
            Box::new(Dog {
                name: "Fluffy".to_string(),
                breed: "Pomeranian".to_string(),
            })
        }
        "robot" => {
            Box::new(Robot {
                model: "T-80".to_string(),
                purpose: "Kill Sarah Conner".to_string()
            })
        }
        _ => panic!("Unknown speaker type"),
    }
}
pub trait Speakable {
    fn speak(&self) -> String;
}
pub struct Dog {
    pub name: String,
    pub breed: String,
}
impl Speakable for Dog {
    fn speak(&self) -> String {
        String::from("Woof")
    }
}
pub struct Robot {
    pub model: String,
    pub purpose: String,
}
impl Speakable for Robot {
    fn speak(&self) -> String {
        String::from("Beep boop")
    }
}
// Example usage
pub fn main() {
    let dog_speaker = get_speaker("dog");
    println!("{}", dog_speaker.speak()); // Expected output: Woof
    let robot_speaker = get_speaker("robot");
    println!("{}", robot_speaker.speak()); // Expected output: Beep boop
}

Viktor Merkurev

fennr

15 days ago

3.41ms

87.39kb

pub trait Speakable {
    fn speak(&self) -> String;
}
pub struct Dog {
    pub name: String,
    pub breed: String,
}
impl Speakable for Dog {
    fn speak(&self) -> String {
        String::from("Woof")
    }
}
pub struct Robot {
    pub model: String,
    pub purpose: String,
}
impl Speakable for Robot {
    fn speak(&self) -> String {
        String::from("Beep boop")
    }
}
pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => Box::new(Dog { 
            name: "Wolf".to_string(), 
            breed: "Dog".to_string() 
        }),
        "robot" => Box::new(Robot { 
            model: "T1000".to_string(), 
            purpose: "T1000".to_string() 
        }),
        _ => panic!("Unknown speaker type"),
    }
}
// Example usage
pub fn main() {
    let dog_speaker = get_speaker("dog");
    println!("{}", dog_speaker.speak()); // Expected output: Woof
    let robot_speaker = get_speaker("robot");
    println!("{}", robot_speaker.speak()); // Expected output: Beep boop
}

Romain Grimau

Herrgrim0

16 days ago

3.49ms

87.39kb

pub trait Speakable {
    fn speak(&self) -> String;
}
pub struct Dog {
    pub name: String,
    pub breed: String,
}
impl Speakable for Dog {
    fn speak(&self) -> String {
        "Woof".to_string()
    }
}
pub struct Robot {
    pub model: String,
    pub purpose: String,
}
impl Speakable for Robot {
    fn speak(&self) -> String {
        "Beep boop".to_string()
    }
}
pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
            // Return a Dog instance here
            Box::new(Dog {
                name: "Tony".to_string(),
                breed: "bulldog".to_string(),
            })
        }
        "robot" => {
            // Return a Robot instance here
            Box::new(Robot {
                model: "X0A-2".to_string(),
                purpose: "bring the butter".to_string(),
            })
        }
        _ => panic!("Unknown speaker type"),
    }
}
// Example usage
pub fn main() {
    let dog_speaker = get_speaker("dog");
    println!("{}", dog_speaker.speak()); // Expected output: Woof
    let robot_speaker = get_speaker("robot");
    println!("{}", robot_speaker.speak()); // Expected output: Beep boop
}

Marco-Normal

16 days ago

3.33ms

87.38kb

#[derive(Default)]
pub struct Dog {
    pub name: String,
    pub breed: String,
}
#[derive(Default)]
pub struct Robot {
    pub model: String,
    pub purpose: String,
}
pub trait Speakable {
    fn speak(&self) -> String;
}
impl Speakable for Dog {
    fn speak(&self) -> String {
        format!("Woof")
    }
}
impl Speakable for Robot {
    fn speak(&self) -> String {
        format!("Beep boop")
    }
}
pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
            Box::new(Dog::default())
        }
        "robot" => {
            Box::new(Robot::default())
        }
        _ => panic!("Unknown speaker type"),
    }
}
// Example usage
pub fn main() {
    let dog_speaker = get_speaker("dog");
    println!("{}", dog_speaker.speak()); // Expected output: Woof
    let robot_speaker = get_speaker("robot");
    println!("{}", robot_speaker.speak()); // Expected output: Beep boop
}

ludovicknecht

16 days ago

4.46ms

87.40kb

pub trait Speakable {
    fn speak(&self) -> String;
}
pub struct Dog {
    pub name: String,
    pub breed: String,
}
pub struct Robot {
    pub model: String,
    pub purpose: String,
}
impl Speakable for Dog {
    fn speak(&self) -> String {
        String::from("Woof")
    }
}
impl Speakable for Robot {
    fn speak(&self) -> String {
        String::from("Beep boop")
    }
}
pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
            Box::new(Dog {
                name: "Rex".into(),
                breed: "German shepherd".into(),
            })
        }
        "robot" => {
            Box::new(Robot {
                model: "TX8000".into(),
                purpose: "LASER".into(),
            })
        }
        _ => panic!("Unknown speaker type"),
    }
}
// Example usage
pub fn main() {
    let dog_speaker = get_speaker("dog");
    println!("{}", dog_speaker.speak()); // Expected output: Woof
    let robot_speaker = get_speaker("robot");
    println!("{}", robot_speaker.speak()); // Expected output: Beep boop
}

alemack17

17 days ago

5.04ms

87.38kb

pub struct Dog{
    pub name: String,
    pub breed: String
}
pub struct Robot{
    pub model: String,
    pub purpose: String
}
pub trait Speakable{
    fn speak(&self)-> String;
}
impl Speakable for Dog{
    fn speak(&self)-> String{
        "Woof".to_string()
    }
}
impl Speakable for Robot{
    fn speak(&self)-> String{
        "Beep boop".to_string()
    }
}
pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
            Box::new(Dog{name: "".to_string(), breed: "".to_string()})
        }
        "robot" => {
            Box::new(Robot{model: "".to_string(), purpose: "".to_string()})
        }
        _ => panic!("Unknown speaker type"),
    }
}
// Example usage
pub fn main() {
    let dog_speaker = get_speaker("dog");
    println!("{}", dog_speaker.speak()); // Expected output: Woof
    let robot_speaker = get_speaker("robot");
    println!("{}", robot_speaker.speak()); // Expected output: Beep boop
}

Denis SOURON

Brack0

17 days ago

3.19ms

87.39kb

pub trait Speakable {
    fn speak(&self) -> String;
}
pub struct Dog {
    pub name: String,
    pub breed: String,
}
impl Speakable for Dog {
    fn speak(&self) -> String {
        "Woof".to_owned()
    }
}
pub struct Robot {
    pub model: String,
    pub purpose: String,
}
impl Speakable for Robot {
    fn speak(&self) -> String {
        "Beep boop".to_owned()
    }
}
pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => Box::new(Dog {
            name: "dog".to_owned(),
            breed: "breed".to_owned(),
        }),
        "robot" => Box::new(Robot {
            model: "Marvin".to_owned(),
            purpose: "Servant".to_owned(),
        }),
        _ => panic!("Unknown speaker type"),
    }
}

RiyadDz22

17 days ago

3.50ms

87.38kb

#[derive(Default)]
pub struct Dog{
    pub name: String,
    pub breed: String
}
#[derive(Default)]
pub struct Robot{
    pub model :String,
    pub purpose: String
}
pub trait Speakable {
    fn speak(&self) -> String;
}
impl Speakable for Dog{
    fn speak(&self)-> String{
        String::from("Woof")
    }
} 
impl Speakable for Robot{
    fn speak(&self)-> String{
        String::from("Beep boop")
    }
} 
pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
            Box::new(Dog::default())
        }
        "robot" => {
            Box::new(Robot::default())
        }
        _ => panic!("Unknown speaker type"),
    }
}
// Example usage
pub fn main() {
    let dog_speaker = get_speaker("dog");
    println!("{}", dog_speaker.speak()); // Expected output: Woof
    let robot_speaker = get_speaker("robot");
    println!("{}", robot_speaker.speak()); // Expected output: Beep boop
}

Algorab

18 days ago

4.06ms

87.38kb

pub trait Speakable {
    fn speak(&self) -> String;
}
pub struct Dog {
    pub name: String,
    pub breed: String
}
impl Speakable for Dog {
    fn speak(&self) -> String {
        "Woof".to_string()
    }
}
pub struct Robot {
    pub model: String,
    pub purpose: String,
}
impl Speakable for Robot {
    fn speak(&self) -> String {
        "Beep boop".to_string()
    }
}
pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
           Box::new(Dog {
                name: "a".to_string(),
                breed: "b".to_string()
            })
        }
        "robot" => {
            Box::new(
                Robot {
                    model: "a".to_string(),
                    purpose: "b".to_string()
                }
            )
        }
        _ => panic!("Unknown speaker type"),
    }
}
// Example usage
pub fn main() {
    let dog_speaker = get_speaker("dog");
    println!("{}", dog_speaker.speak()); // Expected output: Woof
    let robot_speaker = get_speaker("robot");
    println!("{}", robot_speaker.speak()); // Expected output: Beep boop
}

automata-studio

19 days ago

3.65ms

87.38kb

#[derive(Default)]
pub struct Dog {
    pub name: String,
    pub breed: String,
}
#[derive(Default)]
pub struct Robot {
    pub model: String,
    pub purpose: String,
}
pub trait Speakable {
    fn speak(&self) -> String;
}
impl Speakable for Dog {
    fn speak(&self) -> String {
        String::from("Woof")
    }
}
impl Speakable for Robot {
    fn speak(&self) -> String {
        String::from("Beep boop")
    }
}
pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
            Box::new(Dog::default())
        }
        "robot" => {
            Box::new(Robot::default())
        }
        _ => panic!("Unknown speaker type"),
    }
}
// Example usage
pub fn main() {
    let dog_speaker = get_speaker("dog");
    println!("{}", dog_speaker.speak()); // Expected output: Woof
    let robot_speaker = get_speaker("robot");
    println!("{}", robot_speaker.speak()); // Expected output: Beep boop
}

kosay

sarub0b0

19 days ago

4.80ms

87.38kb

pub trait Speakable {
    fn speak(&self) -> String;
}
#[derive(Default)]
pub struct Dog {
    pub name: String,
    pub breed: String,
}
#[derive(Default)]
pub struct Robot {
    pub model: String,
    pub purpose: String,
}
impl Speakable for Dog {
    fn speak(&self) -> String {
        "Woof".to_string()
    }
}
impl Speakable for Robot {
    fn speak(&self) -> String {
        "Beep boop".to_string()
    }
}
pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => Box::new(Dog::default()),
        "robot" => Box::new(Robot::default()),
        _ => panic!("Unknown speaker type"),
    }
}
// Example usage
pub fn main() {
    let dog_speaker = get_speaker("dog");
    println!("{}", dog_speaker.speak()); // Expected output: Woof
    let robot_speaker = get_speaker("robot");
    println!("{}", robot_speaker.speak()); // Expected output: Beep boop
}

rawar089

20 days ago

3.59ms

87.38kb


#[derive(Default)]
pub struct Dog {
    pub name: String,
    pub breed: String,
}
#[derive(Default)]
pub struct Robot {
    pub model: String,
    pub purpose: String,
}
pub trait Speakable {
    fn speak(&self) -> String;
}
impl Speakable for Robot {
    fn speak(&self) -> String {
        "Beep boop".to_string()
    }
}
impl Speakable for Dog {
    fn speak(&self) -> String {
        "Woof".to_string()
    }
}
pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
            // Return a Dog instance here
            Box::new(Dog::default())
        }
        "robot" => {
            // Return a Robot instance here
            Box::new( Robot::default() )
        }
        _ => panic!("Unknown speaker type"),
    }
}
// Example usage
pub fn main() {
    let dog_speaker = get_speaker("dog");
    println!("{}", dog_speaker.speak()); // Expected output: Woof
    let robot_speaker = get_speaker("robot");
    println!("{}", robot_speaker.speak()); // Expected output: Beep boop
}

iamforgettable

20 days ago

3.64ms

87.39kb

pub trait Speakable {
    fn speak(&self) -> String;
}
pub struct Dog {
    pub name: String,
    pub breed: String,
}
impl Speakable for Dog {
    fn speak(&self) -> String {
        return String::from("Woof");
    }
}
pub struct Robot {
    pub model: String,
    pub purpose: String,
}
impl Speakable for Robot {
    fn speak(&self) -> String {
        return String::from("Beep boop");
    }
}
pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
            Box::new(Dog {
                name: String::from("Rex"),
                breed: String::from("Labrador")
            })
        }
        "robot" => {
            Box::new(Robot {
                model: String::from("R2-D2"),
                purpose: String::from("assistance")
            })
        }
        _ => panic!("Unknown speaker type"),
    }
}
// Example usage
pub fn main() {
    let dog_speaker = get_speaker("dog");
    println!("{}", dog_speaker.speak()); // Expected output: Woof
    let robot_speaker = get_speaker("robot");
    println!("{}", robot_speaker.speak()); // Expected output: Beep boop
}

Nikita Smirnov

Nismirno

21 days ago

3.85ms

87.39kb

pub trait Speakable {
    fn speak(&self) -> String;
}
pub struct Dog {
    pub name: String,
    pub breed: String,
}
pub struct Robot {
    pub model: String,
    pub purpose: String,
}
impl Speakable for Dog {
    fn speak(&self) -> String {
        String::from("Woof")
    }
}
impl Speakable for Robot {
    fn speak(&self) -> String {
        String::from("Beep boop")
    }
}
pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => Box::new(Dog {
            name: "Good boy".to_string(),
            breed: "Hound".to_string(),
        }),
        "robot" => Box::new(Robot {
            model: "R2-D2".to_string(),
            purpose: "Repair".to_string(),
        }),
        _ => panic!("Unknown speaker type"),
    }
}
// Example usage
pub fn main() {
    let dog_speaker = get_speaker("dog");
    println!("{}", dog_speaker.speak()); // Expected output: Woof
    let robot_speaker = get_speaker("robot");
    println!("{}", robot_speaker.speak()); // Expected output: Beep boop
}

Elliott Draper

ejdraper

22 days ago

4.29ms

87.39kb

pub trait Speakable {
    fn speak(self: &Self) -> String;
}
pub struct Dog {
    pub name: String,
    pub breed: String
}
impl Speakable for Dog {
    fn speak(self: &Self) -> String {
        return "Woof".to_string();
    }
}
pub struct Robot {
    pub model: String,
    pub purpose: String
}
impl Speakable for Robot {
    fn speak(self: &Self) -> String {
        return "Beep boop".to_string();
    }
}
pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
            return Box::new(Dog {
                name: "Rover".to_string(),
                breed: "Dog".to_string()
            })
            // Return a Dog instance here
        }
        "robot" => {
            return Box::new(Robot {
                model: "T800".to_string(),
                purpose: "Terminate".to_string()
            })
            // Return a Robot instance here
        }
        _ => panic!("Unknown speaker type"),
    }
}
// Example usage
pub fn main() {
    let dog_speaker = get_speaker("dog");
    println!("{}", dog_speaker.speak()); // Expected output: Woof
    let robot_speaker = get_speaker("robot");
    println!("{}", robot_speaker.speak()); // Expected output: Beep boop
}

Justin Maillet

justy777

23 days ago

5.12ms

87.38kb

pub trait Speakable {
    fn speak(&self) -> String;
}
#[derive(Default)]
pub struct Dog {
    pub name: String,
    pub breed: String,
}
impl Speakable for Dog {
    fn speak(&self) -> String {
        String::from("Woof")
    }
}
#[derive(Default)]
pub struct Robot {
    pub model: String,
    pub purpose: String,
}
impl Speakable for Robot {
    fn speak(&self) -> String {
        String::from("Beep boop")
    }
}
pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
            Box::new(Dog::default())
        }
        "robot" => {
            Box::new(Robot::default())
        }
        _ => panic!("Unknown speaker type"),
    }
}
// Example usage
pub fn main() {
    let dog_speaker = get_speaker("dog");
    println!("{}", dog_speaker.speak()); // Expected output: Woof
    let robot_speaker = get_speaker("robot");
    println!("{}", robot_speaker.speak()); // Expected output: Beep boop
}

Oebelus

oebelus

24 days ago

4.19ms

87.39kb

pub trait Speakable {
    fn speak(&self) -> String;
}
pub struct Dog {
    pub name: String,
    pub breed: String
}
pub struct Robot {
    pub model: String,
    pub purpose: String
}
impl Speakable for Dog {
    fn speak(&self) -> String {
        String::from("Woof")
    }
}
impl Speakable for Robot {
    fn speak(&self) -> String {
        String::from("Beep boop")
    }
}
pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => Box::new(Dog {
            name: String::from("Kelly"),
            breed: String::from("Labrador"), 
        }),
        "robot" => Box::new(Robot {
            model: String::from("X32"),
            purpose: String::from("VR"),
        }),
        _ => panic!("Unknown speaker type"),
    }
}
// Example usage
pub fn main() {
    let dog_speaker = get_speaker("dog");
    println!("{}", dog_speaker.speak()); // Expected output: Woof
    let robot_speaker = get_speaker("robot");
    println!("{}", robot_speaker.speak()); // Expected output: Beep boop
}

zahrajavar

24 days ago

7.38ms

87.39kb


pub trait Speakable{
    fn speak(&self)-> String;
}
pub struct Dog{
    pub name:String,
    pub breed: String,
}
pub struct Robot{
    pub model: String,
    pub purpose: String,
}
impl Speakable for Dog{
    fn speak(&self) -> String {
        "Woof".to_string()
    }
}
impl Speakable for Robot{
    fn speak(&self) -> String {
        "Beep boop".to_string()
    }
}
pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => Box::new(Dog {
            name: "Buddy".to_string(),
            breed: "Labrador".to_string(),
        }),
        
        "robot" => Box::new(Robot {
            model: "T-800".to_string(),
            purpose: "Protect humanity".to_string(),
        }),
        _ => panic!("Unknown speaker type"),
    }
}
// Example usage
pub fn main() {
    let dog_speaker = get_speaker("dog");
    println!("{}", dog_speaker.speak()); // Expected output: Woof
    let robot_speaker = get_speaker("robot");
    println!("{}", robot_speaker.speak()); // Expected output: Beep boop
}

Jim Lawton

jimlawton

24 days ago

5.16ms

87.39kb

pub trait Speakable {
    fn speak(&self) -> String;
}
pub struct Dog {
    pub name: String,
    pub breed: String,
}
impl Speakable for Dog {
    fn speak(&self) -> String {
        "Woof".to_string()
    }
}
pub struct Robot {
    pub model: String,
    pub purpose: String,
}
impl Speakable for Robot {
    fn speak(&self) -> String {
        "Beep boop".to_string()
    }
}
pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
            let dog = Dog {
                name: "Dune".to_string(),
                breed: "Border Collie".to_string(),
            };
            Box::new(dog)
        }
        "robot" => {
            let robot = Robot {
                model: "HAL 8999".to_string(),
                purpose: "Sorry Dave".to_string(),
            };
            Box::new(robot)
        }
        _ => panic!("Unknown speaker type"),
    }
}
// Example usage
pub fn main() {
    let dog_speaker = get_speaker("dog");
    println!("{}", dog_speaker.speak()); // Expected output: Woof
    let robot_speaker = get_speaker("robot");
    println!("{}", robot_speaker.speak()); // Expected output: Beep boop
}

Stefan Roas

sroas

24 days ago

3.40ms

87.38kb

pub trait Speakable {
    fn speak(&self) -> String;
}
#[derive(Default)]
pub struct Dog {
    pub name: String,
    pub breed: String,
}
impl Speakable for Dog {
    fn speak(&self) -> String {
        "Woof".to_string()
    }
}
#[derive(Default)]
pub struct Robot {
    pub model: String,
    pub purpose: String,
}
impl Speakable for Robot {
    fn speak(&self) -> String {
        "Beep boop".to_string()
    }
}
pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
            // Return a Dog instance here
            Box::new(Dog::default())
        }
        "robot" => {
            // Return a Robot instance here
            Box::new(Robot::default())
        }
        _ => panic!("Unknown speaker type"),
    }
}
// Example usage
pub fn main() {
    let dog_speaker = get_speaker("dog");
    println!("{}", dog_speaker.speak()); // Expected output: Woof
    let robot_speaker = get_speaker("robot");
    println!("{}", robot_speaker.speak()); // Expected output: Beep boop
}

Shafer Hess

shafer-hess

25 days ago

3.25ms

87.39kb

pub trait Speakable {
    fn speak(&self) -> String;
}
pub struct Dog {
    pub name: String,
    pub breed: String
}
pub struct Robot {
    pub model: String,
    pub purpose: String
}
impl Speakable for Dog {
    fn speak(&self) -> String {
        String::from("Woof")
    }
}
impl Speakable for Robot {
    fn speak(&self) -> String {
        String::from("Beep boop")
    }
}
pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
            Box::new(Dog { name: "Winston".to_string(), breed: "Dog".to_string() })
        }
        "robot" => {
            Box::new(Robot { model: "Robot".to_string(), purpose: "Love".to_string()})
        }
        _ => panic!("Unknown speaker type"),
    }
}
// Example usage
pub fn main() {
    let dog_speaker = get_speaker("dog");
    println!("{}", dog_speaker.speak()); // Expected output: Woof
    let robot_speaker = get_speaker("robot");
    println!("{}", robot_speaker.speak()); // Expected output: Beep boop
}

TaiPoole

a month ago

3.31ms

87.40kb

pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
            Box::new(Dog {
                name: "buddy".to_string(),
                breed: "idk dog breeds".to_string() 
            })
        }
        "robot" => {
            Box::new(Robot {
                model: "microwave".to_string(),
                purpose: "make things hot".to_string()
            })
        }
        _ => panic!("Unknown speaker type"),
    }
}
pub trait Speakable {
    fn speak(&self) -> String;
}
pub struct Dog {
    pub name: String,
    pub breed: String
}
impl Speakable for Dog {
    fn speak(&self) -> String {
        "Woof".to_string()
    }
}
pub struct Robot {
    pub model: String,
    pub purpose: String
}
impl Speakable for Robot {
    fn speak(&self) -> String {
        "Beep boop".to_string()
    }
}
// Example usage
pub fn main() {
    let dog_speaker = get_speaker("dog");
    println!("{}", dog_speaker.speak()); // Expected output: Woof
    let robot_speaker = get_speaker("robot");
    println!("{}", robot_speaker.speak()); // Expected output: Beep boop
}

Jonathan Voss

jvoss

a month ago

3.45ms

87.39kb

pub trait Speakable {
    fn speak(&self) -> String;
}
pub struct Dog {
    pub name: String,
    pub breed: String
}
pub struct Robot {
    pub model: String,
    pub purpose: String
}
impl Speakable for Dog {
    fn speak(&self) -> String {
        String::from("Woof")
    }
}
impl Speakable for Robot {
    fn speak(&self) -> String {
        String::from("Beep boop")
    }
}
pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
            // Return a Dog instance here
            Box::new(Dog{name: "dog1".to_string(), breed: "doggie".to_string()})
        }
        "robot" => {
            // Return a Robot instance here
            Box::new(Robot{model: "robot1".to_string(), purpose: "robot stuff".to_string()})
        }
        _ => panic!("Unknown speaker type"),
    }
}
// Example usage
pub fn main() {
    let dog_speaker = get_speaker("dog");
    println!("{}", dog_speaker.speak()); // Expected output: Woof
    let robot_speaker = get_speaker("robot");
    println!("{}", robot_speaker.speak()); // Expected output: Beep boop
}

Christopher Nielson

c-nielson

a month ago

3.94ms

87.39kb

pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
            Box::new(Dog {
                name: String::from("Fido"),
                breed: String::from("Labrador"),
            })
        }
        "robot" => {
            Box::new(Robot {
                model: String::from("R2D2"),
                purpose: String::from("Pass the butter"),
            })
        }
        _ => panic!("Unknown speaker type"),
    }
}
pub trait Speakable {
    fn speak(&self) -> String;
}
pub struct Dog {
    pub name: String,
    pub breed: String,
}
impl Speakable for Dog {
    fn speak(&self) -> String {
        String::from("Woof")
    }
}
pub struct Robot {
    pub model: String,
    pub purpose: String,
}
impl Speakable for Robot {
    fn speak(&self) -> String {
        String::from("Beep boop")
    }
}
// Example usage
pub fn main() {
    let dog_speaker = get_speaker("dog");
    println!("{}", dog_speaker.speak()); // Expected output: Woof
    let robot_speaker = get_speaker("robot");
    println!("{}", robot_speaker.speak()); // Expected output: Beep boop
}

dawwestk

a month ago

3.16ms

87.39kb

pub trait Speakable {
    fn speak(&self) -> String;
}
pub struct Dog {
    pub name: String,
    pub breed: String,
}
impl Speakable for Dog {
    fn speak(&self) -> String {
        String::from("Woof")
    }
}
pub struct Robot {
    pub model: String,
    pub purpose: String,
}
impl Speakable for Robot {
    fn speak(&self) -> String {
        String::from("Beep boop")
    }
}
pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
            // Return a Dog instance here
            Box::new(Dog { name: "dog".to_string(), breed: "breed".to_string() })
        }
        "robot" => {
            // Return a Robot instance here
            Box::new(Robot { model: "robot".to_string(), purpose: "robot".to_string() })
        }
        _ => panic!("Unknown speaker type"),
    }
}
// Example usage
pub fn main() {
    let dog_speaker = get_speaker("dog");
    println!("{}", dog_speaker.speak()); // Expected output: Woof
    let robot_speaker = get_speaker("robot");
    println!("{}", robot_speaker.speak()); // Expected output: Beep boop
}

PangoSea

kapaseker

a month ago

3.31ms

87.38kb


pub trait Speakable {
    fn speak(&self) -> String;
}
pub struct Dog {
    pub name: String,
    pub breed: String,
}
impl Speakable for Dog {
    fn speak(&self) -> String {
        "Woof".to_string()
    }
}
pub struct Robot {
    pub model: String,
    pub purpose: String,
}
impl Speakable for Robot {
    fn speak(&self) -> String {
        "Beep boop".to_string()
    }
}
pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
            Box::new(Dog { name: "Bob".to_string(), breed: "Bob".to_string() })
        }
        "robot" => {
            // Return a Robot instance here
            Box::new(Robot { model: "Robot".to_string(), purpose: "Robot".to_string() })    
        }
        _ => panic!("Unknown speaker type"),
    }
}
// Example usage
pub fn main() {
    let dog_speaker = get_speaker("dog");
    println!("{}", dog_speaker.speak()); // Expected output: Woof
    let robot_speaker = get_speaker("robot");
    println!("{}", robot_speaker.speak()); // Expected output: Beep boop
}