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

Maintain

duonghb53

an hour ago

3.54ms

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

Khalifa

e1ec30

6 days ago

5.84ms

87.39kb

pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
            // Return a Dog instance here
            let d = Dog {
                name: String::from("Dog"),
                breed: String::from("DobberMan")
            };
            Box::new(d)
        }
        "robot" => {
            // Return a Robot instance here
            let r = Robot {
                model: String::from("T1000"),
                purpose: String::from("Termination")
            };
            Box::new(r)
        }
        _ => 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")
    }
}
pub trait Speakable {
    fn speak(&self) -> 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
}

Khalifa

e1ec30

6 days ago

4.38ms

87.39kb

pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
            // Return a Dog instance here
            let d = Dog {
                name: String::from("Dog"),
                breed: String::from("DobberMan")
            };
            Box::new(d)
        }
        "robot" => {
            // Return a Robot instance here
            let r = Robot {
                model: String::from("T1000"),
                purpose: String::from("Termination")
            };
            Box::new(r)
        }
        _ => 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")
    }
}
pub trait Speakable {
    fn speak(&self) -> 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
}

Nicolai

Posmac

7 days ago

3.88ms

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 {
        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("Buddy"),
                breed: String::from("Labrador"),
            })
        }
        "robot" => {
            // Return a Robot instance here
            Box::new(Robot {
                model: String::from("R2-D2"),
                purpose: String::from("Protocol"),
            })
        }
        _ => 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
}

agamaontherock

10 days ago

6.20ms

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 {
        return String::from("Woof");
    }
}
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: String::from("oskar"), breed: String::from("poodle")});
        }
        "robot" => {
            // Return a Robot instance here
            return Box::new(Robot{model: "C3PO".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
}

Health-Care-Movie

11 days ago

4.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" => {
            // 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: "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
}

Splatrac

splatrac

12 days ago

4.31ms

87.40kb

pub struct Dog {
    pub name: String,
    pub breed: String,
}
pub struct Robot {
    pub model: String,
    pub purpose: String,
}
pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
            // Return a Dog instance here
            let dog = Dog { name: "Flox".to_string(), breed: "German Sheperd".to_string() };
            Box::new(dog)
        }
        "robot" => {
            // Return a Robot instance here
            let robot = Robot { model: "R2D2".to_string(), purpose: "Assistant".to_string() };
            Box::new(robot)
        }
        _ => panic!("Unknown speaker type"),
    }
}
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()
    }
}
// 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
}

Trịnh Chấn Duy

Duyyy123

13 days ago

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

Liyqq

14 days ago

5.21ms

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

roboquaternion

22 days ago

3.34ms

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.
            let dog = Dog{
                name: "Fido".to_string(), 
                breed: "Collie".to_string()};
            Box::new(dog)
        }
        "robot" => {
            // Return a Robot instance here.
            let robot = Robot{
                model: "X2000".to_string(), 
                purpose: "Butler".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
}

roboquaternion

22 days 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 {
        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.
            Box::new(Dog{name: "Fido".to_string(), breed: "Collie".to_string()})
        }
        "robot" => {
            // Return a Robot instance here.
            Box::new(Robot{model: "X2000".to_string(), purpose: "Butler".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
}

gsspdev

a month ago

3.54ms

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 doggy = Dog {
                name: "Abby".to_string(),
                breed: "Yellow Lab".to_string()
            };
            Box::new(doggy)
        }
        "robot" => {
            let robby = Robot {
                model: "Robby".to_string(),
                purpose: "T-100".to_string(),
            };
            Box::new(robby)
        }
        _ => 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
}

Nathan GAUD

Natchica

a month ago

4.10ms

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

Nguyen Vo Hoang Son

sonmessia

a month ago

4.41ms

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 {
        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" => {
            // Return a Dog instance here
            let dog = Dog {
                name: "Beo".to_string(),
                breed: "Corgi".to_string(),
            };
            Box::new(dog)
        }
        "robot" => {
            // Return a Robot instance here
            let robot = Robot {
                model: "V1".to_string(),
                purpose: "Clean".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
}

shibu-t

a month ago

3.51ms

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 {
        format!("Woof")
    }
}
pub struct Robot {
    pub model: String,
    pub purpose: String,
}
impl Speakable for Robot {
    fn speak(&self) -> String {
        format!("Beep boop")
    }
}
pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
            // Return a Dog instance here
            let dog = Dog {
                name: "Buddy".to_string(),
                breed: "Golden Retriever".to_string(),
            };
            Box::new(dog)
        }
        "robot" => {
            // Return a Robot instance here
            let robot = Robot {
                model: "RX-78".to_string(),
                purpose: "Combat".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
}

Paolo Cancedda

Pac72

a month ago

3.70ms

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: String::from("Bobby"),
                breed: String::from("Boxer")
            })
        }
        "robot" => {
            // Return a Robot instance here
            Box::new(Robot {
                model: String::from("3PO"),
                purpose: String::from("Protocol droid")
            })
        }
        _ => 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
}

ON-MX

a month ago

4.95ms

87.38kb

pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
        match kind {
        "dog" => Box::new(Dog {
            name: String::from("Oi"),
            breed: String::from("ii"),
        }),
        "robot" => Box::new(Robot {
            model: String::from("1252"),
            purpose: String::from("walk"),
        }),
        _ => 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
}

mishbah

a month ago

4.40ms

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: String::from("Oi"),
            breed: String::from("ii"),
        }),
        "robot" => Box::new(Robot {
            model: String::from("1252"),
            purpose: String::from("walk"),
        }),
        _ => 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
}

Jason

Jason-fy-wang

a month ago

6.68ms

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 {
        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" => {
            // Return a Dog instance here
            let dog = Dog{name: "name".to_string(), breed: "breed".to_string()};
            Box::new(dog)
        }
        "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
}

Jakub Wiśniewski

wisniewskij

a month 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 {
        "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: "Dis".to_string(), name: "Chuj".to_string()})
            // Return a Dog instance here
        }
        "robot" => {
            Box::new(Robot{model: "1".to_string(), purpose: "2".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
}

vijayabhaskar badireddi

ptcte

a month ago

3.45ms

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_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: "Rex".to_owned(),
            breed: "German Shepherd".to_owned(),
        }),
        "robot" => Box::new(Robot {
            model: "R2-D2".to_owned(),
            purpose: "Assist".to_owned(),
        }),
        _ => 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
}

Assylbek Razakhbergenov

asylbek27

a month ago

5.04ms

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_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: "Rex".to_owned(), breed: "German Shepherd".to_owned(),})
        }
        "robot" => {
            Box::new(Robot{model: "R2-D2".to_owned(), purpose: "Assist".to_owned(),})
        }
        _ => 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
}

VerweyFr

a month ago

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

rolan

rolan36

a month ago

3.49ms

87.38kb

pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
            // Return a Dog instance here
            Box::new(
                Dog {
                    name: "1".to_string(),
                    breed: "2".to_string(),
            }
            ) 
        }
        "robot" => {
            // Return a Robot instance here
            Box::new(       
                Robot {
                    model: "3".to_string(),
                    purpose: "4".to_string(),
            })         
        }
        _ => panic!("Unknown speaker type"),
    }
}
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()
    }
}
// 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
}

Suresh Kumar

toddlers

a month ago

3.63ms

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: "sheeru".to_string(),
                breed: "pitbull".to_string(),
            })
        }
        "robot" => {
            // Return a Robot instance here
            Box::new(Robot{
                model: "1231".to_string(),
                purpose: "helper".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
}

chuyuanlinzi

a month ago

3.44ms

87.41kb


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
            let dog = Dog {
                name: "DaHuang".to_string(),
                breed: "ZhongHuaTianYuanQuan".to_string()
            };
            Box::new(dog)
        }
        "robot" => {
            // Return a Robot instance here
            let robot = Robot {
                model: "WaLi".to_string(),
                purpose: "Blue".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
}

Kondorok

a month ago

4.41ms

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

Suresh Kumar

toddlers

2 months ago

7.49ms

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: "sheeru".to_string(),
                breed: "pitbull".to_string(),
            })
        }
        "robot" => {
            // Return a Robot instance here
            Box::new(Robot{
                model: "1231".to_string(),
                purpose: "helper".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
}

Jason

chenjie1219

2 months ago

4.53ms

87.39kb

pub trait Speakable {
    fn speak(&self) -> String;
}
pub struct Dog {
    pub name: String,
    pub breed: String,
}
impl Dog {
    pub fn new(name: &str, breed: &str) -> Self {
        Self {
            name: name.into(),
            breed: breed.into(),
        }
    }
}
pub struct Robot {
    pub model: String,
    pub purpose: String,
}
impl Robot {
    pub fn new(model: &str, purpose: &str) -> Self {
        Self {
            model: model.into(),
            purpose: purpose.into(),
        }
    }
}
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::new("name", "breed")),
        "robot" => Box::new(Robot::new("model", "purpose")),
        _ => 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
}

Yixian Du

duyixian1234

2 months ago

6.27ms

87.39kb

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

lugtester

2 months ago

4.10ms

87.39kb

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

Aurimas Kuniutis

auriku

2 months ago

3.30ms

87.39kb

pub trait Speakable {
    fn speak(&self) -> String;
}
pub struct Dog {
    pub name: String,
    pub breed: String,
}
impl Dog {
    pub fn new(name: &str, breed: &str) -> Self {
        Self {
            name: name.to_string(),
            breed: breed.to_string(),
        }
    }
}
impl Speakable for Dog {
    fn speak(&self) -> String {
        String::from("Woof")
    }
}
pub struct Robot {
    pub model: String,
    pub purpose: String,
}
impl Robot {
    pub fn new(model: &str, purpose: &str) -> Self {
        Self {
            model: model.to_string(),
            purpose: purpose.to_string(),
        }
    }
}
impl Robot {}
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::new("Link", "Malinois")),
        "robot" => Box::new(Robot::new("Hoo", "Vacum cleaner")),
        _ => 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
}

0XDamn

0xDamn

2 months ago

3.36ms

87.38kb

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"),
    }
}
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".into()
    }
}
#[derive(Default)]
pub struct Robot {
    pub model: String,
    pub purpose: String,
}
impl Speakable for Robot {
    fn speak(&self) -> String {
        "Beep boop".into()
    }
}
// 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
}

Anna Komarova

Vlasanya

2 months ago

8.94ms

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: "Buddy".to_string(),
            breed: "Golden Retriever".to_string(),
        }),
        "robot" => Box::new(Robot {
            model: "RX-78".to_string(),
            purpose: "Exploration".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
}

Cristian Prieto

cprieto

2 months ago

3.52ms

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: "Firulais".into(), breed: "Tinaker".into()})
        }
        "robot" => {
            Box::new(Robot { model: "Bending Unit".into(), purpose: "Bend".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
}

Artem

tich31337

2 months ago

5.08ms

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_owned(), breed: "".to_owned()})
        }
        "robot" => {
            // Return a Robot instance here
            Box::new(Robot{model: "".to_owned(), purpose: "".to_owned()})
        }
        _ => 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
}

Paulo Lins

pblins

2 months ago

3.90ms

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" => 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
}

Icarus

IcarusxB

2 months ago

7.41ms

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

Matthew Li

circles-png

2 months ago

3.46ms

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
}

Tboot

tboot-0510

2 months ago

4.08ms

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" => {
            Box::new(Dog{
                name: "Dog".to_string(),
                breed: "Dog".to_string(),
            })
        }
        "robot" => {
            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
}

Ahmet Özcan

ahmetoozcan

2 months ago

3.45ms

87.38kb

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

TiagONTOP

2 months ago

4.13ms

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

Hung Dinh

nhdinh

2 months ago

4.09ms

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

tzmijewski

2 months ago

6.22ms

87.39kb

pub struct Robot {
    pub model: String,
    pub purpose: String,
}
pub struct Dog {
    pub name: String,
    pub breed: String,
}
pub trait Speakable {
    fn speak(&self) -> String;
    //fn new(name: &str) -> Self;
}
impl Speakable for Dog {
    fn speak(&self) -> String {
        "Woof".to_string()
    } /*
    fn new(name: &str) -> Dog {
        Dog { name: name.to_string(), breed: "unknown".to_string() }
    } */
}
impl Speakable for Robot {
    fn speak(&self) -> String {
        "Beep boop".to_string()
    } /*
    fn new(name: &str) -> Robot {
        Robot { model: name.to_string(), purpose: "unknown".to_string()  }
    } */
}
pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
            // Return a Dog instance here
            //Dog::new("spike")
            Box::new(Dog { name: "fido".to_string(), breed: "unknown".to_string() })
        }
        "robot" => {
            // Return a Robot instance here
            //Robot::new("r2d2")
            Box::new(Robot { model: "r2d2".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
}

AnKarl

Zythophilus

2 months ago

4.77ms

87.39kb

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

Zeiion

2 months ago

6.16ms

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

amaneru

7ma8no9

3 months 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

3 months 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 months 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

3 months 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
}