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

amdfxlucas

5 days ago

3.71ms

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

RaDo

rado31

6 days ago

3.94ms

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

RaDo

rado31

6 days ago

4.86ms

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_owned()
    }
}
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: "".to_owned(), breed: "".to_owned() }),
        "robot" => 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
}

RaDo

rado31

6 days ago

5.82ms

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_owned()
    }
}
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: "".to_owned(), breed: "".to_owned() }),
        "robot" => 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
}

StevenCanDrink

6 days ago

3.47ms

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

Jai

jsat97

7 days ago

3.38ms

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> {
    match kind {
        "dog" => {
            // Return a Dog instance here
            Box::new(Dog{name: String::from("Max"), breed: String::from("German Shepherd")})
        }
        "robot" => {
            // Return a Robot instance here
            Box::new(Robot{model: String::from("H1234"), purpose: String::from("house helper")})
        }
        _ => 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
}

Chih Ying Yen

xavierforge

9 days ago

4.34ms

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" => {
            // Return a Dog instance here
            Box::new(Dog {name: "Cat".to_string(), breed: "Mix".to_string()})
        }
        "robot" => {
            // Return a Robot instance here
            Box::new(Robot {model: "T-800".to_string(), purpose: "Be back".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
}

baschdik

11 days ago

3.58ms

87.39kb

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

undefeated_

boyboi86

11 days ago

4.38ms

87.38kb

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

Artem Nistuley

artemnistuley

12 days ago

3.51ms

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

GunGraveCpp

13 days ago

3.26ms

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 {
        return "Woof".to_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" => {
            return Box::new(Dog{name:  String::default() , breed: String::default()})
        }
        "robot" => {
            return Box::new(Robot{model:  String::default() , purpose: String::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
}

David Rasch

dcrasch

14 days ago

3.53ms

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" => {
            Box::new(Dog{ name: "bobby".to_string(), breed:"terrier".to_string()})
        }
        "robot" => {
            Box::new(Robot { model:"1".to_string(), purpose:"destroy".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
}

Lvfalue

16 days ago

4.23ms

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

visanr

17 days ago

3.74ms

87.38kb

pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
            Box::new(Dog::default())
            // Return a Dog instance here
        }
        "robot" => {
            Box::new(Robot::default())
            // Return a Robot instance here
        }
        _ => panic!("Unknown speaker type"),
    }
}
#[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()
    }
}
// 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
}

shahab-tplus

19 days ago

3.68ms

87.47kb

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

Jean-baptiste JOFFRE

Indy79

19 days ago

3.32ms

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

toto

19 days ago

3.20ms

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

Gurneet singh

GS-Jatt

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

Luka Bračun

lbracun

23 days ago

4.20ms

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 {
    format!("Woof")
  }
}
#[derive(Default)]
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" => {
            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
}

bzdula

23 days ago

3.43ms

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{
                breed: String::from("JRT"), 
                name: "Mayo".to_owned()
            })
            // Return a Dog instance here
        }
        "robot" => {
            Box::new(Robot {
                model: String::from("T1000"),
                purpose: "Pass the butter".to_owned()
                
            })
            // 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
}

Ranjith Thangavel

RanjithECE24

23 days ago

3.59ms

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

Evgenii Uglanov

winchest3r

a month ago

4.73ms

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

aghia98

a month ago

3.61ms

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

Franklin Chen

FranklinChen

a month ago

3.38ms

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

Wouter

WouterMartens

a month ago

4.23ms

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

Daniel Mestas

miel-codeai

a month ago

3.29ms

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

Andy Randrianirina

andyslash

a month ago

3.63ms

87.38kb


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

thriller08

a month ago

3.72ms

87.38kb

pub trait Speakable {
    fn speak(&self) -> String;
}
#[derive(Default)]
pub struct Dog {
    pub name: String,
    pub breed: String,
}
impl Speakable for Dog {
    fn speak(&self) -> String {
        String::from("Woof")
    }
}
#[derive(Default)]
pub struct Robot {
    pub model: String,
    pub purpose: String,
}
impl Speakable for Robot {
    fn speak(&self) -> String {
        String::from("Beep boop")
    }
}
pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
            // 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
}

manu3618

a month ago

3.52ms

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(Debug, Default)]
pub struct Dog {
    pub name: String,
    pub breed: String,
}
impl Speakable for Dog {
    fn speak(&self) -> String {
        "Woof".into()
    }
}
#[derive(Debug, 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
}

Fatih

0fatih

a month ago

6.28ms

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

Evrins Hu

evrins

a month ago

3.19ms

87.78kb

pub trait Speakable {
    fn speak(&self) -> &'static str;
}
#[derive(Default)]
pub struct Dog {
    pub name: String,
    pub breed: String,
}
impl Speakable for Dog {
    fn speak(&self) -> &'static str {
        "Woof"
    }
}
#[derive(Default)]
pub struct Robot {
    pub model: String,
    pub purpose: String,
}
impl Speakable for Robot {
    fn speak(&self) -> &'static str {
        "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
}

slaws

a month ago

3.48ms

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

Blaze

Divakar-2508

a month ago

3.42ms

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" => {
            Box::new(Robot::default())
            // 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
}

johndoe30bc

a month ago

3.84ms

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

Baron Curtin

baroncurtin2

a month ago

4.76ms

87.39kb

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

m1031

monorail103

a month ago

3.60ms

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

AtlasVakyrie

a month ago

4.32ms

87.39kb

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

xxxxsk

a month ago

3.26ms

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

bernardoLY19

a month ago

3.23ms

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

Evgenii Grigorenko

grevgeny

a month ago

3.33ms

87.78kb

pub trait Speakable {
    fn speak(&self) -> &'static str;
}
#[derive(Default)]
pub struct Dog {
    pub name: String,
    pub breed: String
}
impl Speakable for Dog {
    fn speak(&self) -> &'static str {
        "Woof"
    }
}
#[derive(Default)]
pub struct Robot {
    pub model: String,
    pub purpose: String,
}
impl Speakable for Robot {
    fn speak(&self) -> &'static str {
        "Beep boop"
    }
}
pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
            Box::new(Dog { ..Default::default() })
        }
        "robot" => {
            Box::new(Robot { ..Default::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
}

FredoPo

2 months ago

4.31ms

87.38kb

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

Karol Płatkowski

spoohie

2 months ago

3.91ms

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

Procybit

2 months ago

4.31ms

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: "Snacky".to_string(),
            breed: "Golden Retriever".to_string(),
        }),
        "robot" => Box::new(Robot {
            model: "Bishop / HS17B48XG5-D5".to_string(),
            purpose: "The android executive officer assigned to the Sulaco".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
}

brucecox01

2 months ago

3.65ms

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

Rocky.C

cloki0610

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

Miguel Ángel Allende

maallende

2 months ago

3.53ms

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

Krzysztof Atłasik

katlasik

2 months ago

3.79ms

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

medzernik

2 months 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 {
        String::from("Woof")
    }
}
impl Speakable for Robot {
    fn speak(&self) -> String {
        String::from("Beep boop")
    }
}
pub fn get_speaker(kind: &str) -> Box<dyn Speakable> {
    match kind {
        "dog" => {
           Box::new(Dog{
                name: "Rex".to_string(),
                breed: "German Shepeard".to_string(),
            })
        }
        "robot" => {
            Box::new(Robot{
                model: "Robot1".to_string(),
                purpose: "To kill".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
}

Herman effendi

hrmneffdii

2 months 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_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: "Companion".to_string(),
        }),
        _ => panic!("Unknown speaker type"),
    }
}
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
}

Kr0wZ

2 months ago

4.92ms

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