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

Baily

baily-zhang

18 hours ago

3.99ms

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: "wtoto".to_string(),
                breed: "wow".to_string(),
            })
        }
        "robot" => {
            // Return a Robot instance here
            Box::new(Robot {
                model: "whow".to_string(),
                purpose:"twe".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
}

Baily

baily-zhang

18 hours ago

4.97ms

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: "wtoto".to_string(),
                breed: "wow".to_string(),
            })
        }
        "robot" => {
            // Return a Robot instance here
            Box::new(Robot {
                model: "whow".to_string(),
                purpose:"twe".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
}

Piotr Baranowski

piotrbar250

2 days ago

4.21ms

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_owned()
    }
}
#[derive(Default)]
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" => {
            // 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
}

Piotr Baranowski

piotrbar250

2 days ago

3.32ms

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_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" => {
            // 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
}

mihaya

mihaya03

5 days ago

3.66ms

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")
    }
}
impl Dog {
    fn new(name: &str, breed: &str) -> Self {
        Dog {
            name: name.to_string(),
            breed: breed.to_string(),
        }
    }
}
impl Robot {
    fn new(model: &str, purpose: &str) -> Self {
        Robot {
            model: model.to_string(),
            purpose: purpose.to_string(),
        }
    }
}
pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => Box::new(Dog::new("Buddy", "Golden Retriever")),
        "robot" => Box::new(Robot::new("R2-D2", "Astromech")),
        _ => panic!("Unknown speaker type"),
    }
}
pub fn main() {
    let dog_speaker = get_speaker("dog");
    println!("{}", dog_speaker.speak());
    let robot_speaker = get_speaker("robot");
    println!("{}", robot_speaker.speak());
}

Artyom Chebotarev

Derik117

5 days ago

3.23ms

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 {
        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::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
}

zibuyu28

6 days ago

3.37ms

87.38kb

pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
            // Return a Dog instance here
            Box::new(Dog{name:"test".to_string(), breed:"".to_string()})
        }
        "robot" => {
            // Return a Robot instance here
             Box::new(Robot{model:"".to_string(), purpose:"".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
}

Atanas Krondev

AtanasKrondev

6 days ago

3.40ms

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: String::from("Fido"),
            breed: String::from("Labrador"),
        }),
        "robot" => Box::new(Robot {
            model: String::from("RX-78"),
            purpose: String::from("Companion"),
        }),
        _ => 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
}

jcarey9149

10 days ago

3.79ms

87.40kb

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> {
    let default_value="unspecified".to_string();
    match kind {
        "dog" => {
            Box::new(Dog{
                name: default_value.clone(), breed: default_value})
        },
        "robot" => {
            Box::new(Robot{model: default_value.clone(), 
                purpose: default_value})
        }
        _ => 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
}

Ignat S.

Igonato

14 days ago

3.26ms

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" => Box::new(Dog {
            name: "foo".into(),
            breed: "bar".into(),
        }),
        "robot" => Box::new(Robot {
            model: "foo".into(),
            purpose: "bar".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
}

Luiz Pinheiro

lgabriellp

14 days ago

3.29ms

87.39kb

pub trait Speakable {
    fn speak(&self) -> String;
}
pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => Box::new(Dog {
            name: "Rex".to_string(),
            breed: "Pastor Alemão".to_string()
        }),
        "robot" => Box::new(Robot {
            model: "C3PO".to_string(),
            purpose: "Engineering".to_string()
        }),
        _ => panic!("Unknown speaker type"),
    }
}
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()
    }
}
// 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
}

Marouan Boulahtouf

MBoulahtouf

15 days ago

3.42ms

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" => {
            // Return a Dog instance here
            Box::new(Dog {
                name: String::from("Buddy"),
                breed: String::from("Golden Retriever"),
            })
        }
        "robot" => {
            // Return a Robot instance here
            Box::new(Robot {
                model: String::from("XJ-9"),
                purpose: String::from("Household Assistant"),
            })
        }
        _ => 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
}

gtakacse

15 days ago

3.76ms

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: "Fido".to_string(),
            breed: "German shepard".to_string(),
        }),
        "robot" => Box::new(Robot {
            model: "X1".to_string(),
            purpose: "generic".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
}

0xdangit

15 days ago

4.21ms

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 {
        return "Woof".to_string();
    }
}
pub struct Robot {
    pub purpose: String,
    pub model: String,
}
impl Speakable for Robot {
    fn speak(&self) -> String {
        return "Beep boop".to_string();
    }
}
pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
            Box::new(Dog { breed: "".to_string(), name: "".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
}

Özgür

AyikOzgur

16 days ago

5.62ms

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: String::from("Vendi"), 
                breed: String::from("nive")
            })
        }
        "robot" => {
            // Return a Robot instance here
            Box::new(Robot {
                model: String::from("boston"),
                purpose: String::from("cleaning")
            })
        }
        _ => 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
}

Egu0

egu0

18 days ago

3.07ms

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 {
        "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: "Fater".to_string(),
            breed: "Border-Collie".to_string(),
        }),
        "robot" => Box::new(Robot {
            model: "XF32".to_string(),
            purpose: "Refueling".to_string(),
        }),
        _ => panic!("Unknown speaker type"),
    }
}

Hariom

om-secadvice

19 days ago

3.37ms

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: "Tom".into(),
                breed: "Chiuauha".into()
            })
        }
        "robot" => {
            // Return a Robot instance here
            Box::new(Robot {
                model: "AI453".into(),
                purpose: "Terminator".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
}

Snoweuph

snoweuph

21 days ago

33.83ms

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".into()
    }
}
pub struct Robot {
    pub model: String,
    pub purpose: String,
}
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: "".into(),
            breed: "".into(),
        }),
        "robot" => Box::new(Robot {
            model: "".into(),
            purpose: "".into(),
        }),
        _ => panic!("Unknown speaker type"),
    }
}

azmahflameheart

22 days ago

3.20ms

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 {
        "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::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
}

ffrie

23 days ago

3.38ms

87.38kb

pub trait Speakable {
    fn speak(&self) -> String;
}
#[derive(Debug, Default)]
pub struct Dog {
    pub name: String, 
    pub breed: String,
}
#[derive(Debug, Default)]
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::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
}

Ramon Silva

rsilva1

24 days ago

4.38ms

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: "Luna".to_string(), breed: "Border collie".to_string() })
        }
        "robot" => {
            // Return a Robot instance here
            Box::new(Robot { model: "1A".to_string(), purpose: "Serve coffee".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
}

vqk-2003

24 days ago

4.85ms

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: String::from("Jojo"),
                breed: String::from("Pug"),
            })
        }
        "robot" => {
            // Return a Robot instance here
            Box::new(Robot {
                model: String::from("MIT"),
                purpose: String::from("Clean"),
            })
        }
        _ => 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
}

Yashwanth

Yash981

a month ago

3.45ms

87.40kb

pub struct Dog {
    pub name: String,
    pub breed: String
}
pub trait Speakable {
    fn speak(&self) -> 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" => {
            // Return a Dog instance here
            let dog =  Box::new(Dog {
                name:String::from("dog"),
                breed:String::from("German Shepherd")
            });
            return dog;
        },
        "robot" => {
            // Return a Robot instance here
            let robot = Box::new(Robot {
                model: String::from("latest Model"),
                purpose: String::from("reduce human work")
            });
            return 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
}

LawisChen

a month ago

3.92ms

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

ychanghe

a month ago

3.35ms

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" => {
            // Return a Dog instance here 
            Box::new(Dog{name: "dong".to_string(), breed: "mix".to_string()})
        }
        "robot" => {
            // Return a Robot instance here
            Box::new(Robot{model: "hi".to_string(), purpose: "die".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
}

makinpaper

a month 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 {
        "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: "Gigi".to_string(),
            breed: "Cutest".to_string(),
        }),
        "robot" => Box::new(Robot {
            model: "R2D2".to_string(),
            purpose: "Lay the law".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
}

fasolyee

fasolyeedev

a month ago

3.84ms

87.38kb

pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
            // Return a Dog instance here
            return Box::new(Dog{name: String::new(), breed: String::new()})
        }
        "robot" => {
            // Return a Robot instance here
            return Box::new(Robot{model: String::new(), purpose: String::new()})
        }
        _ => 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{
        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")
    }
} 
// 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
}

<YoungAncient/>

youngancient

a month ago

3.51ms

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{
        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
            return Box::new(Dog{name: String::new(), breed: String::new()});
        }
        "robot" => {
            // Return a Robot instance here
            return Box::new(Robot{model : String::new(), purpose: String::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
}

SpontaneousOverthrow

a month ago

3.41ms

87.47kb

pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
            // Return a Dog instance here
            Box::new(Dog {name: "a".to_string(), breed: "b".to_string()})
        }
        "robot" => {
            // Return a Robot instance here
            Box::new(Robot {model: "a".to_string(), purpose: "b".to_string()})
        }
        _ => panic!("Unknown speaker type"),
    }
}
pub trait Speakable {
    fn speak(&self) -> &'static str;
}
pub struct Dog {
    pub name: String,
    pub breed: String,
}
impl Speakable for Dog {
    fn speak(&self) -> &'static str {
        "Woof"
    }
}
pub struct Robot {
    pub model: String,
    pub purpose: String,
}
impl Speakable for Robot {
    fn speak(&self) -> &'static str {
        "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
}

Omar Saber Talaat Abdelrahman

omar-s-ta

a month ago

4.29ms

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: String::from("name"),
            breed: String::from("breed"),
        }),
        "robot" => Box::new(Robot {
            model: String::from("model"),
            purpose: String::from("purpose"),
        }),
        // 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
}

Dan Wayne

danwayne-me

a month ago

3.94ms

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: "dog".to_string(),
            breed: "breed".to_string(),
        }),
        "robot" => Box::new(Robot {
            model: "model".to_string(),
            purpose: "p".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
}

Dimas Avrian Fachriza

FForFachriza

a month ago

3.52ms

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" => {
            // Return a Dog instance here
            Box::new(Dog{
                breed: String::from("Golden Retriever"),
                name: String::from("Dog"),
            })
        }
        "robot" => {
            // Return a Robot instance here
            Box::new(Robot {
                model: String::from("T-O1"),
                purpose: String::from("Genocide"),
            })
        }
        _ => 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
}

Kishan

wdcs-kishansudani

a month ago

4.97ms

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 {
        return "Woof".to_string();
    }
}
pub struct Robot {
    pub model: String,
    pub purpose: String,
}
impl Speakable for Robot {
    fn speak(&self) -> String {
        return "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
}

Asrul Firdaus

AsrulF

a month ago

3.37ms

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" => {
            // Return a Dog instance here
            Box::new(
                Dog {
                    name: "yogi".to_string(),
                    breed: "Chihua-hua".to_string(),
                }
            )
        }
        "robot" => {
            // Return a Robot instance here
            Box::new(
                Robot {
                    model: "modern".to_string(),
                    purpose: "allround".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
}

Dharm Singh

dharmvr1

a month 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:String::from("raju"),breed:"bye".to_string()})
        }
        "robot" => {
            // Return a Robot instance here
          Box::new(Robot{model:String::from("raju"),purpose:"bye".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
}

Mykhailo Huzhvii

Ymkavi

a month ago

5.44ms

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 {
        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: "val".to_string(), breed: "val".to_string() })
        }
        "robot" => {
            Box::new(Robot { model: "val".to_string(), purpose: "val".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
}

银雀Sparrxw

Sparr0www820

2 months ago

24.50ms

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".into()
    }
}
impl Dog {
    pub fn new() -> Dog {
        Dog {
            name: "".into(),
            breed: "".into(),
        }
    }
}
pub struct Robot {
    pub model: String,
    pub purpose: String,
}
impl Speakable for Robot {
    fn speak(&self) -> String {
        "Beep boop".into()
    }
}
impl Robot {
    pub fn new() -> Robot {
        Robot {
            model: "".into(),
            purpose: "".into(),
        }
    }
}
pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
            Box::new(Dog::new())
        }
        "robot" => {
            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
}

银雀Sparrxw

Sparr0www820

2 months ago

3.52ms

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".into()
    }
}
impl Dog {
    pub fn new() -> Dog {
        Dog {
            name: "".into(),
            breed: "".into(),
        }
    }
}
pub struct Robot {
    pub model: String,
    pub purpose: String,
}
impl Speakable for Robot {
    fn speak(&self) -> String {
        "Beep boop".into()
    }
}
impl Robot {
    pub fn new() -> Robot {
        Robot {
            model: "".into(),
            purpose: "".into(),
        }
    }
}
pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
            Box::new(Dog::new())
        }
        "robot" => {
            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
}

Ari Karim

arikarim

2 months ago

3.31ms

87.39kb

pub trait Speakable {
    fn speak(&self) -> String {
        "sum".to_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: "name".to_string(),
                    breed: "breed".to_string()
                }
            )
        }
        "robot" => {
            // Return a Robot instance here
            Box::new(Robot {
                model: "model".to_string(),
                purpose: "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
}

Yummy-Yums

2 months ago

3.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 {
        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: String::from("Dog 1"), breed: String::from("Breed 1") })
        }
        "robot" => {
            // Return a Robot instance here
            Box::new(Robot {
                model: String::from("Dog 1"),
                purpose: String::from("Breed 1")
            })
        }
        _ => 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
}

Vincent SAMY

vsamy

2 months ago

4.34ms

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
}

Vincent SAMY

vsamy

2 months ago

4.44ms

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
}

danyaffe63

2 months ago

37.35ms

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{breed:"World".to_string(), name:"Hello".to_string()})
        }
        "robot" => {
            Box::new(Robot{model: "Hello".to_string(), purpose:"World".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
}

reborn3d

2 months ago

4.61ms

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" => {
            // Return a Dog instance here
            return Box::new(Dog{ name : "Pantufa".to_string(), breed: "cat".to_string()});
        }
        "robot" => {
            // Return a Robot instance here
            return Box::new(Robot{model:"android".to_string(), purpose: "play".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
}

Abhishek Sharma

0xAbhiDev

2 months ago

3.70ms

87.40kb

pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
            // Return a Dog instance here
             Box::new(Dog{
                name: "Buddy".to_string(),
                breed: "German Shepherd".to_string(),
            })
          }
        "robot" => {
                        Box::new(Robot {
                model: "Chitti".to_string(),
                purpose: "Cleaning".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{
        return "Woof".to_string();
            }
 }
pub struct Robot {
   pub model:String,
    pub purpose:String
}
 impl Speakable for Robot{
         fn speak(&self)->String{
             return "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
}

Abhishek Sharma

0xAbhiDev

2 months ago

4.63ms

87.40kb

pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
            // Return a Dog instance here
             Box::new(Dog{
                name: "Rex".to_string(),
                breed: "German Shepherd".to_string(),
            })
          }
        "robot" => {
                        Box::new(Robot {
                model: "R2-D2".to_string(),
                purpose: "Astromech".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{
        return "Woof".to_string();
            }
 }
pub struct Robot {
   pub model:String,
    pub purpose:String
}
 impl Speakable for Robot{
         fn speak(&self)->String{
             return "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
}

jfloresremar

2 months ago

3.20ms

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: "shute".to_string(),
            breed: "special".to_string(),
        }),
        "robot" => Box::new(Robot {
            model: "lite".to_string(),
            purpose: "help".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
}

nojae15

2 months ago

3.76ms

87.38kb

pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
            // Return a Dog instance here
            Box::new(Dog{name:"aa".to_string(),breed:"bb".to_string()})
        }
        "robot" => {
            // Return a Robot instance here
            Box::new(Robot{model:"aa".to_string(),purpose:"bb".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
}

Francisco Alejandro

francisco-alejandro

2 months ago

3.50ms

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
            return Box::new(Dog {
                name: String::from("Orlando"),
                breed: String::from("Golden")
            });
        }
        "robot" => {
            // Return a Robot instance here
            return Box::new(Robot{
                model: String::from("Thermomix"),
                purpose: String::from("Cooking")
            });
        }
        _ => 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
}

Francisco Alejandro

francisco-alejandro

2 months ago

3.44ms

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
            return Box::new(Dog {
                name: String::from("Orlando"),
                breed: String::from("Golden")
            });
        }
        "robot" => {
            // Return a Robot instance here
            return Box::new(Robot{
                model: String::from("Thermomix"),
                purpose: String::from("Cooking")
            });
        }
        _ => 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
}