Trait Objects

Now that we know a little bit about trait objects and how to work with them, let's use them in a different example, this challenge focuses on using Box<dyn Trait> as fields in structs to encapsulate objects with dynamic behavior.

Your Task

You need to define a trait called Renderable and create two structs, Circle and Rectangle, that implement this trait. Then, you will create another struct called Canvas, which can hold a collection of objects implementing the Renderable trait. The Canvas struct should have methods to add objects and render all objects.

Requirements

Here are the requirements for the program, make sure to read them carefully:

Define the `Renderable` Trait

The trait should have a method render(&self) -> String to represent the object visually.

Define the `Circle` and `Rectangle` Structs

Circle should have a radius: f64 field.
Rectangle should have width: f64 and height: f64 fields.

Implement the `Renderable` Trait

For Circle, the render method should return a string like "Circle with radius X".
For Rectangle, the render method should return a string like "Rectangle with width X and height Y".

Define the `Canvas` Struct

The struct should have a shapes field that can store a Vec of the Renderable trait objects.
Implement the following methods for Canvas:
- new() -> Canvas: Initializes an empty canvas.
- add_shape(): Adds a shape to the canvas.
- render_all(): Returns a vector of strings, each representing a rendered shape.

⚠️ Make sure you make all the relevant items public with the pub keyword, this is required for the tests to work.

Hints

If you're stuck, here are some hints to help you solve the challenge:

Click here to reveal hints

Use Box<dyn Trait> to store objects with dynamic behavior. e.g.

pub struct Canvas {
  pub shapes: Vec<Box<dyn Renderable>>,
}

Editor not available on Mobile!

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

Solutions

Khalifa

e1ec30

6 days ago

5.32ms

193.67kb


pub trait Renderable {
    fn render(&self) -> String;
}
pub struct Circle {
    pub radius: f64,
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
// 1. Implement the trait for Circle and Rectangle
impl Renderable for Circle {
    fn render(&self) -> String {
        format!("Circle with radius {}", self.radius)
    }
}
impl Renderable for Rectangle {
    fn render(&self) -> String {
        format!("Rectangle with width {} and height {}", self.width, self.height)
    }
}
// 2. Create the Canvas struct
pub struct Canvas {
    pub objects: Vec<Box<dyn Renderable>>,
}
// 3. Implement the Canvas struct
impl Canvas {
    pub fn new() -> Self {
        Self {
            objects: Vec::new()
        }
    }
    pub fn add_shape(&mut self, object: Box<dyn Renderable>) {
        self.objects.push(object);
    }
    pub fn render_all(&self) -> Vec<String> {
        self.objects.iter().map(|o| o.render()).collect()
    }
}
// Example usage
pub fn main() {
    let mut canvas = Canvas::new();
    canvas.add_shape(Box::new(Circle { radius: 5.0 }));
    canvas.add_shape(Box::new(Rectangle {
        width: 3.0,
        height: 4.0,
    }));
    let rendered_shapes = canvas.render_all();
    for shape in rendered_shapes {
        println!("{}", shape);
    }
}

Nicolai

Posmac

7 days ago

9.72ms

193.67kb

pub trait Renderable {
    fn render(&self) -> String;
}
pub struct Circle {
    pub radius: f64,
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
// 1. Implement the trait for Circle and Rectangle
impl Renderable for Circle {
    fn render(&self) -> String {
        format!("Circle with radius {}", self.radius)
    }
}
impl Renderable for Rectangle {
    fn render(&self) -> String {
        format!("Rectangle with width {} and height {}", self.width, self.height)
    }
}
pub struct Canvas {
    shapes: Vec<Box<dyn Renderable>>,
}
impl Canvas {
    pub fn new() -> Canvas {
        Canvas{shapes: vec![]}
    }
    
    pub fn add_shape(&mut self, shape: Box<dyn Renderable>) {
        self.shapes.push(shape);
    }
    
    pub fn render_all(&self) -> Vec<String> {
        self.shapes.iter().map(|shape| shape.render()).collect()
    }
}
// 2. Create the Canvas struct
// 3. Implement the Canvas struct
// Example usage
pub fn main() {
    let mut canvas = Canvas::new();
    canvas.add_shape(Box::new(Circle { radius: 5.0 }));
    canvas.add_shape(Box::new(Rectangle {
        width: 3.0,
        height: 4.0,
    }));
    let rendered_shapes = canvas.render_all();
    for shape in rendered_shapes {
        println!("{}", shape);
    }
}

agamaontherock

8 days ago

6.37ms

172.58kb

pub trait Renderable {
    fn render(&self) -> String;
}
pub struct Circle {
    pub radius: f64,
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
// 1. Implement the trait for Circle and Rectangle
impl Renderable for Circle {
    fn render(&self) -> String{
        format!("Circle with radius {}", self.radius)
    }
}
impl Renderable for Rectangle {
    fn render(&self) -> String{
        format!("Rectangle with width {} and height {}", self.width, self.height)
    }
}
// 2. Create the Canvas struct
pub struct Canvas {
    pub shapes: Vec<Box<dyn Renderable>>,
}
// 3. Implement the Canvas struct
impl Canvas {
    pub fn new() -> Canvas{
        return Canvas{shapes: Vec::<Box<dyn Renderable>>::new()};
    }
    pub fn add_shape(&mut self, shape: Box<dyn Renderable>){
        self.shapes.push(shape)
    }
    pub fn render_all(&self) -> Vec<String>{
        let mut res:Vec<String>= vec![];
        for s in self.shapes.iter() {
            // res.push(s.render());
            res.push((*s.render()).to_string()); 
        } 
        return res;
    }
}
// Example usage
pub fn main() {
    let mut canvas = Canvas::new();
    canvas.add_shape(Box::new(Circle { radius: 5.0 }));
    canvas.add_shape(Box::new(Rectangle {
        width: 3.0,
        height: 4.0,
    }));
    let rendered_shapes = canvas.render_all();
    for shape in rendered_shapes {
        println!("{}", shape);
    }
}

agamaontherock

8 days ago

6.48ms

194.25kb

pub trait Renderable {
    fn render(&self) -> String;
}
pub struct Circle {
    pub radius: f64,
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
// 1. Implement the trait for Circle and Rectangle
impl Renderable for Circle {
    fn render(&self) -> String{
        format!("Circle with radius {}", self.radius)
    }
}
impl Renderable for Rectangle {
    fn render(&self) -> String{
        format!("Rectangle with width {} and height {}", self.width, self.height)
    }
}
// 2. Create the Canvas struct
pub struct Canvas {
    pub shapes: Vec<Box<dyn Renderable>>,
}
// 3. Implement the Canvas struct
impl Canvas {
    pub fn new() -> Canvas{
        return Canvas{shapes: Vec::<Box<dyn Renderable>>::new()};
    }
    pub fn add_shape(&mut self, shape: Box<dyn Renderable>){
        self.shapes.push(shape)
    }
    pub fn render_all(&self) -> Vec<String>{
        let mut res:Vec<String>= vec![];
        for s in self.shapes.iter() {
            res.push((*s).render());
        } 
        res
    }
}
// Example usage
pub fn main() {
    let mut canvas = Canvas::new();
    canvas.add_shape(Box::new(Circle { radius: 5.0 }));
    canvas.add_shape(Box::new(Rectangle {
        width: 3.0,
        height: 4.0,
    }));
    let rendered_shapes = canvas.render_all();
    for shape in rendered_shapes {
        println!("{}", shape);
    }
}

agamaontherock

8 days ago

5.49ms

194.25kb

pub trait Renderable {
    fn render(&self) -> String;
}
pub struct Circle {
    pub radius: f64,
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
// 1. Implement the trait for Circle and Rectangle
impl Renderable for Circle {
    fn render(&self) -> String{
        format!("Circle with radius {}", self.radius)
    }
}
impl Renderable for Rectangle {
    fn render(&self) -> String{
        format!("Rectangle with width {} and height {}", self.width, self.height)
    }
}
// 2. Create the Canvas struct
pub struct Canvas {
    pub shapes: Vec<Box<dyn Renderable>>,
}
// 3. Implement the Canvas struct
impl Canvas {
    pub fn new() -> Canvas{
        return Canvas{shapes: Vec::<Box<dyn Renderable>>::new()};
    }
    pub fn add_shape(&mut self, shape: Box<dyn Renderable>){
        self.shapes.push(shape)
    }
    pub fn render_all(&self) -> Vec<String>{
        let mut res:Vec<String>= vec![];
        for s in self.shapes.iter() {
            res.push((*s).render());
        } 
        return res;
    }
}
// Example usage
pub fn main() {
    let mut canvas = Canvas::new();
    canvas.add_shape(Box::new(Circle { radius: 5.0 }));
    canvas.add_shape(Box::new(Rectangle {
        width: 3.0,
        height: 4.0,
    }));
    let rendered_shapes = canvas.render_all();
    for shape in rendered_shapes {
        println!("{}", shape);
    }
}

agamaontherock

8 days ago

5.92ms

194.25kb

pub trait Renderable {
    fn render(&self) -> String;
}
pub struct Circle {
    pub radius: f64,
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
// 1. Implement the trait for Circle and Rectangle
impl Renderable for Circle {
    fn render(&self) -> String{
        format!("Circle with radius {}", self.radius)
    }
}
impl Renderable for Rectangle {
    fn render(&self) -> String{
        format!("Rectangle with width {} and height {}", self.width, self.height)
    }
}
// 2. Create the Canvas struct
pub struct Canvas {
    pub shapes: Vec<Box<dyn Renderable>>,
}
// 3. Implement the Canvas struct
impl Canvas {
    pub fn new() -> Canvas{
        return Canvas{shapes: Vec::<Box<dyn Renderable>>::new()};
    }
    pub fn add_shape(&mut self, shape: Box<dyn Renderable>){
        self.shapes.push(shape)
    }
    pub fn render_all(&self) -> Vec<String>{
        let mut res:Vec<String>= vec![];
        for s in self.shapes.iter() {
            res.push(s.render());
        } 
        return res;
    }
}
// Example usage
pub fn main() {
    let mut canvas = Canvas::new();
    canvas.add_shape(Box::new(Circle { radius: 5.0 }));
    canvas.add_shape(Box::new(Rectangle {
        width: 3.0,
        height: 4.0,
    }));
    let rendered_shapes = canvas.render_all();
    for shape in rendered_shapes {
        println!("{}", shape);
    }
}

agamaontherock

8 days ago

7.24ms

194.25kb

pub trait Renderable {
    fn render(&self) -> String;
}
pub struct Circle {
    pub radius: f64,
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
// 1. Implement the trait for Circle and Rectangle
impl Renderable for Circle {
    fn render(&self) -> String{
        format!("Circle with radius {}", self.radius)
    }
}
impl Renderable for Rectangle {
    fn render(&self) -> String{
        format!("Rectangle with width {} and height {}", self.width, self.height)
    }
}
// 2. Create the Canvas struct
pub struct Canvas {
    pub shapes: Vec<Box<dyn Renderable>>,
}
// 3. Implement the Canvas struct
impl Canvas {
    pub fn new() -> Canvas{
        return Canvas{shapes: vec![]};
    }
    pub fn add_shape(&mut self, shape: Box<dyn Renderable>){
        self.shapes.push(shape)
    }
    pub fn render_all(&self) -> Vec<String>{
        let mut res:Vec<String>= vec![];
        for s in self.shapes.iter() {
            res.push(s.render());
        } 
        return res;
    }
}
// Example usage
pub fn main() {
    let mut canvas = Canvas::new();
    canvas.add_shape(Box::new(Circle { radius: 5.0 }));
    canvas.add_shape(Box::new(Rectangle {
        width: 3.0,
        height: 4.0,
    }));
    let rendered_shapes = canvas.render_all();
    for shape in rendered_shapes {
        println!("{}", shape);
    }
}

Health-Care-Movie

11 days ago

8.29ms

193.67kb

pub trait Renderable {
    fn render(&self) -> String;
}
pub struct Circle {
    pub radius: f64,
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
// 1. Implement the trait for Circle and Rectangle
impl Renderable for Circle {
    fn render(&self) -> String {
        format!("Circle with radius {}", self.radius)
    }
}
impl Renderable for Rectangle {
    fn render(&self) -> String {
        format!("Rectangle with width {} and height {}", self.width, self.height)
    }
}
// 2. Create the Canvas struct
pub struct Canvas {
    pub shapes: Vec<Box<dyn Renderable>>,
}
// 3. Implement the Canvas struct
impl Canvas {
    pub fn new() -> Canvas {
        Canvas {
            shapes: vec![],
        }
    }
    pub fn add_shape(&mut self, shape: Box<dyn Renderable>) {
        self.shapes.push(shape);
    }
    pub fn render_all(&self) -> Vec<String> {
        self.shapes.iter().map(|x| x.render()).collect()
    }
}
// Example usage
pub fn main() {
    let mut canvas = Canvas::new();
    canvas.add_shape(Box::new(Circle { radius: 5.0 }));
    canvas.add_shape(Box::new(Rectangle {
        width: 3.0,
        height: 4.0,
    }));
    let rendered_shapes = canvas.render_all();
    for shape in rendered_shapes {
        println!("{}", shape);
    }
}

Splatrac

splatrac

12 days ago

7.04ms

194.25kb

pub trait Renderable {
    fn render(&self) -> String;
}
pub struct Circle {
    pub radius: f64,
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
// 1. Implement the trait for Circle and Rectangle
impl Renderable for Circle {
    fn render(&self) -> String {
        format!("Circle with radius {}", &self.radius)
    }
}
impl Renderable for Rectangle {
    fn render(&self) -> String {
        format!("Rectangle with width {} and height {}", &self.width, &self.height)
    }
}
// 2. Create the Canvas struct
pub struct Canvas {
    pub shapes: Vec<Box<dyn Renderable>>
}
// 3. Implement the Canvas struct
impl Canvas {
    pub fn new() -> Self {
        Canvas { shapes: Vec::<Box::<dyn Renderable>>::new() }
    }
    pub fn add_shape(&mut self, shape: Box<dyn Renderable>) {
        self.shapes.push(shape);
    }
    pub fn render_all(&self) -> Vec<String> {
        let mut rendered: Vec<String> = Vec::new();
        for shape in self.shapes.iter() {
            rendered.push(shape.render());
        }
        rendered
    }
}
// Example usage
pub fn main() {
    let mut canvas = Canvas::new();
    canvas.add_shape(Box::new(Circle { radius: 5.0 }));
    canvas.add_shape(Box::new(Rectangle {
        width: 3.0,
        height: 4.0,
    }));
    let rendered_shapes = canvas.render_all();
    for shape in rendered_shapes {
        println!("{}", shape);
    }
}

Trịnh Chấn Duy

Duyyy123

13 days ago

5.13ms

193.67kb

pub trait Renderable {
    fn render(&self) -> String;
}
pub struct Circle {
    pub radius: f64,
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
// 1. Implement the trait for Circle and Rectangle
impl Renderable for Circle {
    // add code here
    fn render(&self) -> String {
        format!("Circle with radius {}", self.radius)
    }
}
impl Renderable for Rectangle {
    fn render(&self) -> String {
        format!(
            "Rectangle with width {} and height {}",
            self.width, self.height
        )
    }
}
// 2. Create the Canvas struct
pub struct Canvas {
    pub objs: Vec<Box<dyn Renderable>>,
}
// 3. Implement the Canvas struct
impl Canvas {
    pub fn new() -> Self {
        Canvas { objs: Vec::new() }
    }
    pub fn add_shape(&mut self, obj: Box<dyn Renderable>) {
        self.objs.push(obj);
    }
    pub fn render_all(&self) -> Vec<String> {
        self.objs.iter().map(|x| x.render()).collect()
    }
}
// Example usage
pub fn main() {
    let mut canvas = Canvas::new();
    canvas.add_shape(Box::new(Circle { radius: 5.0 }));
    canvas.add_shape(Box::new(Rectangle {
        width: 3.0,
        height: 4.0,
    }));
    let rendered_shapes = canvas.render_all();
    for shape in rendered_shapes {
        println!("{}", shape);
    }
}

Liyqq

14 days ago

6.88ms

193.67kb

pub trait Renderable {
    fn render(&self) -> String;
}
pub struct Circle {
    pub radius: f64,
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
// 1. Implement the trait for Circle and Rectangle
impl Renderable for Circle {
    fn render(&self) -> String {
        format!("Circle with radius {}", self.radius)
    }
}
impl Renderable for Rectangle {
    fn render(&self) -> String {
        format!("Rectangle with width {} and height {}", self.width, self.height)
    }
}
// 2. Create the Canvas struct
pub struct Canvas {
    pub shape: Vec<Box<dyn Renderable>>,
}
// 3. Implement the Canvas struct
impl Canvas {
    pub fn new() -> Canvas {
        Canvas {shape: vec![]}
    }
    pub fn add_shape(&mut self, shape: Box<dyn Renderable>) {
        self.shape.push(shape);
    }
    pub fn render_all(&self) -> Vec<String> {
        self.shape.iter().map(|s| s.render()).collect()
    }
}
// Example usage
pub fn main() {
    let mut canvas = Canvas::new();
    canvas.add_shape(Box::new(Circle { radius: 5.0 }));
    canvas.add_shape(Box::new(Rectangle {
        width: 3.0,
        height: 4.0,
    }));
    let rendered_shapes = canvas.render_all();
    for shape in rendered_shapes {
        println!("{}", shape);
    }
}

roboquaternion

22 days ago

4.77ms

194.25kb

pub trait Renderable {
    fn render(&self) -> String;
}
#[derive(Default)]
pub struct Circle {
    pub radius: f64,
}
#[derive(Default)]
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
// 1. Implement the trait for Circle and Rectangle
impl Renderable for Circle {
    fn render(&self) -> String {
        format!("Circle with radius {}", self.radius)
    }
}
impl Renderable for Rectangle {
    fn render(&self) -> String {
        format!("Rectangle with width {} and height {}", self.width, self.height)
    }
}
// 2. Create the Canvas struct
#[derive(Default)]
pub struct Canvas {
    shapes: Vec<Box<dyn Renderable>>,
}
// 3. Implement the Canvas struct
impl Canvas {
    pub fn new() -> Canvas {
        Canvas{
            shapes: Vec::<Box<dyn Renderable>>::new()}
    }
    pub fn add_shape(&mut self, shape: Box<dyn Renderable>) {
        self.shapes.push(shape)
    }
    pub fn render_all(&self) -> Vec<String> {
        let mut shape_vec: Vec<String> = vec![];
        for shape in self.shapes.iter() {
            shape_vec.push(shape.render());
        }
        shape_vec
    }
}
// Example usage
pub fn main() {
    let mut canvas = Canvas::new();
    canvas.add_shape(Box::new(Circle { radius: 5.0 }));
    canvas.add_shape(Box::new(Rectangle {
        width: 3.0,
        height: 4.0,
    }));
    let rendered_shapes = canvas.render_all();
    for shape in rendered_shapes {
        println!("{}", shape);
    }
}

Nathan GAUD

Natchica

25 days ago

4.96ms

193.67kb

pub trait Renderable {
    fn render(&self) -> String;
}
pub struct Circle {
    pub radius: f64,
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
// 1. Implement the trait for Circle and Rectangle
impl Renderable for Circle {
    fn render(&self) -> String {
        format!("Circle with radius {}", self.radius)
    }
}
impl Renderable for Rectangle {
    fn render(&self) -> String {
        format!("Rectangle with width {} and height {}", self.width, self.height)
    }
}
// 2. Create the Canvas struct
pub struct Canvas {
    pub shapes: Vec<Box<dyn Renderable>>,
}
// 3. Implement the Canvas struct
impl Canvas {
    pub fn new() -> Self {
        Self {
            shapes: Vec::new(),
        }
    }
    pub fn add_shape(&mut self, shape: Box<dyn Renderable>) {
        self.shapes.push(shape);
    }
    pub fn render_all(&self) -> Vec<String> {
        self.shapes.iter().map(|s| s.render()).collect()
    }
}
// Example usage
pub fn main() {
    let mut canvas = Canvas::new();
    canvas.add_shape(Box::new(Circle { radius: 5.0 }));
    canvas.add_shape(Box::new(Rectangle {
        width: 3.0,
        height: 4.0,
    }));
    let rendered_shapes = canvas.render_all();
    for shape in rendered_shapes {
        println!("{}", shape);
    }
}

gsspdev

a month ago

7.28ms

172.58kb

pub struct Circle {
    pub radius: f64,
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
pub trait Renderable {
    fn render(&self) -> String;
}
// 1. Implement the trait for Circle and Rectangle
impl Renderable for Circle {
    fn render(&self) -> String {
        format!("Circle with radius {}", self.radius)
    }
}
impl Renderable for Rectangle {
    fn render(&self) -> String {
        format!("Rectangle with width {} and height {}", self.width, self.height)
    }
}
// 2. Create the Canvas struct
pub struct Canvas {
    shapes: Vec<Box<dyn Renderable>>,
}
// 3. Implement the Canvas struct
impl Canvas {
    pub fn new() -> Canvas {
        Canvas {
            shapes: Vec::<Box<dyn Renderable>>::new()
        }
    }
    pub fn add_shape(&mut self, shape: Box<dyn Renderable>) {
        self.shapes.push(shape)
    }
    pub fn render_all(&self) -> Vec<String> {
        let mut vec_strings: Vec<String> = vec![];
        for string in self.shapes.iter() {
            vec_strings.push((*string.render()).to_string());
        }
        vec_strings
    }
}
// Example usage
pub fn main() {
    let mut canvas = Canvas::new();
    canvas.add_shape(Box::new(Circle { radius: 5.0 }));
    canvas.add_shape(Box::new(Rectangle {
        width: 3.0,
        height: 4.0,
    }));
    let rendered_shapes = canvas.render_all();
    for shape in rendered_shapes {
        println!("{}", shape);
    }
}

Jakub Wiśniewski

wisniewskij

a month ago

7.07ms

193.67kb

pub trait Renderable {
    fn render(&self) -> String;
}
pub struct Circle {
    pub radius: f64,
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
impl Renderable for Circle {
    fn render(&self) -> String {
        format!("Circle with radius {}", self.radius)
    }
}
impl Renderable for Rectangle {
    fn render(&self) -> String {
        format!("Rectangle with width {} and height {}", self.width, self.height)
    }
}
// 1. Implement the trait for Circle and Rectangle
// 2. Create the Canvas struct
// 3. Implement the Canvas struct
pub struct Canvas {
    pub shapes: Vec<Box<dyn Renderable>>
}
impl Canvas {
    pub fn new() -> Canvas {
       Canvas {
        shapes: Vec::new(),
       } 
    }
    pub fn add_shape(&mut self, shape: Box<dyn Renderable>) {
        self.shapes.push(shape);
    }
    pub fn render_all(&self) -> Vec<String> {
        self.shapes.iter().map(|x| x.render()).collect()
    }
}
// Example usage
pub fn main() {
    let mut canvas = Canvas::new();
    canvas.add_shape(Box::new(Circle { radius: 5.0 }));
    canvas.add_shape(Box::new(Rectangle {
        width: 3.0,
        height: 4.0,
    }));
    let rendered_shapes = canvas.render_all();
    for shape in rendered_shapes {
        println!("{}", shape);
    }
}

Nguyen Vo Hoang Son

sonmessia

a month ago

6.46ms

172.58kb

pub trait Renderable {
    fn render(&self) -> String;
}
pub struct Circle {
    pub radius: f64,
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
// 1. Implement the trait for Circle and Rectangle
impl Renderable for Circle {
    fn render(&self) -> String {
        format!("Circle with radius {}", self.radius)
    }
}
impl Renderable for Rectangle {
    fn render(&self) -> String {
        format!("Rectangle with width {} and height {}", self.width, self.height)
    }
}
// 2. Create the Canvas struct
pub struct Canvas {
    shapes: Vec<Box<dyn Renderable>>,
}
// 3. Implement the Canvas struct
impl Canvas {
    pub fn new() -> Canvas {
        Canvas {
            shapes: Vec::<Box<dyn Renderable>>::new(),
        }
    }
    pub fn add_shape(&mut self, b: Box<dyn Renderable>) {
        self.shapes.push(b)
    }
    pub fn render_all(&self) -> Vec<String> {
        let mut rendered: Vec<String> = vec![];
        for shape in self.shapes.iter() {
            rendered.push((*shape.render()).to_string());
        }
        rendered
    }
}
// Example usage
pub fn main() {
    let mut canvas = Canvas::new();
    canvas.add_shape(Box::new(Circle { radius: 5.0 }));
    canvas.add_shape(Box::new(Rectangle {
        width: 3.0,
        height: 4.0,
    }));
    let rendered_shapes = canvas.render_all();
    for shape in rendered_shapes {
        println!("{}", shape);
    }
}

shibu-t

a month ago

8.02ms

193.67kb

pub trait Renderable {
    fn render(&self) -> String;
}
pub struct Circle {
    pub radius: f64,
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
// 1. Implement the trait for Circle and Rectangle
impl Renderable for Circle {
    fn render(&self) -> String {
        format!("Circle with radius {}", self.radius)
    }
}
impl Renderable for Rectangle {
    fn render(&self) -> String {
        format!("Rectangle with width {} and height {}", self.width, self.height)
    }
}
// 2. Create the Canvas struct
pub struct Canvas {
    pub shapes: Vec<Box<dyn Renderable>>,
}
// 3. Implement the Canvas struct
impl Canvas {
    pub fn new() -> Canvas {
        Canvas {
            shapes: Vec::new(),
        }
    }
    pub fn add_shape(&mut self, shape: Box<dyn Renderable>) {
        self.shapes.push(shape);
    }
    pub fn render_all(&self) -> Vec<String> {
        self.shapes.iter().map(|shape| shape.render()).collect()
    }
}
// Example usage
pub fn main() {
    let mut canvas = Canvas::new();
    canvas.add_shape(Box::new(Circle { radius: 5.0 }));
    canvas.add_shape(Box::new(Rectangle {
        width: 3.0,
        height: 4.0,
    }));
    let rendered_shapes = canvas.render_all();
    for shape in rendered_shapes {
        println!("{}", shape);
    }
}

Paolo Cancedda

Pac72

a month ago

4.89ms

193.67kb

pub trait Renderable {
    fn render(&self) -> String;
}
pub struct Circle {
    pub radius: f64,
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
// 1. Implement the trait for Circle and Rectangle
impl Renderable for Circle {
    fn render(&self) -> String {
        format!("Circle with radius {}", self.radius)
    }
}
impl Renderable for Rectangle {
    fn render(&self) -> String {
        format!("Rectangle with width {} and height {}",
            self.width, self.height)
    }
}
// 2. Create the Canvas struct
pub struct Canvas {
    shapes: Vec<Box<dyn Renderable>>,
}
// 3. Implement the Canvas struct
impl Canvas {
    pub fn new() -> Self {
        Canvas { shapes: Vec::new() }
    }
    pub fn add_shape(&mut self, shape: Box<dyn Renderable>) {
        self.shapes.push(shape);
    }
    pub fn render_all(&self) -> Vec<String> {
        self.shapes.iter()
            .map(|shape| shape.render())
            .collect()
    }
}
// Example usage
pub fn main() {
    let mut canvas = Canvas::new();
    canvas.add_shape(Box::new(Circle { radius: 5.0 }));
    canvas.add_shape(Box::new(Rectangle {
        width: 3.0,
        height: 4.0,
    }));
    let rendered_shapes = canvas.render_all();
    for shape in rendered_shapes {
        println!("{}", shape);
    }
}

mishbah

a month ago

5.44ms

193.67kb

pub trait Renderable {
    fn render(&self) -> String;
}
pub struct Circle {
    pub radius: f64,
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
impl Renderable for Circle {
    fn render(&self) -> String {
        format!("Circle with radius {}", self.radius)
    }
}
impl Renderable for Rectangle {
    fn render(&self) -> String {
        format!(
            "Rectangle with width {} and height {}",
            self.width, self.height
        )
    }
}
pub struct Canvas {
    pub shapes: Vec<Box<dyn Renderable>>,
}
impl Canvas {
    pub fn new() -> Self {
        Self { shapes: vec![] }
    }
    pub fn add_shape(&mut self, shape: Box<dyn Renderable>) {
        self.shapes.push(shape);
    }
    pub fn render_all(&self) -> Vec<String> {
        self.shapes.iter().map(|x| x.render()).collect()
    }
}
pub fn main() {
    let mut canvas = Canvas::new();
    canvas.add_shape(Box::new(Circle { radius: 5.0 }));
    canvas.add_shape(Box::new(Rectangle {
        width: 3.0,
        height: 4.0,
    }));
    let rendered_shapes = canvas.render_all();
    for shape in rendered_shapes {
        println!("{}", shape);
    }
}

Jakub Wiśniewski

wisniewskij

a month ago

4.96ms

193.67kb

pub trait Renderable {
    fn render(&self) -> String;
}
pub struct Circle {
    pub radius: f64,
}
impl Renderable for Circle {
    fn render(&self) -> String {
        format!("Circle with radius {}", self.radius)
    }
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
impl Renderable for Rectangle {
    fn render(&self) -> String {
        format!("Rectangle with width {} and height {}", self.width, self.height)
    }
}
// 1. Implement the trait for Circle and Rectangle
// 2. Create the Canvas struct
pub struct Canvas {
    pub shapes: Vec<Box<dyn Renderable>>,
}
impl Canvas {
    pub fn new() -> Canvas {
        Canvas {
            shapes: Vec::new() 
        }
    }
    pub fn add_shape(&mut self, obj: Box<dyn Renderable>) {
        self.shapes.push(obj);
    } 
    pub fn render_all(&self) -> Vec<String> {
        self.shapes.iter().map(|x| x.render()).collect()
    }
}
// 3. Implement the Canvas struct
// Example usage
pub fn main() {
    let mut canvas = Canvas::new();
    canvas.add_shape(Box::new(Circle { radius: 5.0 }));
    canvas.add_shape(Box::new(Rectangle {
        width: 3.0,
        height: 4.0,
    }));
    let rendered_shapes = canvas.render_all();
    for shape in rendered_shapes {
        println!("{}", shape);
    }
}

Jason

Jason-fy-wang

a month ago

5.10ms

194.25kb

pub trait Renderable {
    fn render(&self) -> String;
}
pub struct Circle {
    pub radius: f64,
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
// 1. Implement the trait for Circle and Rectangle
impl Renderable for Circle {
    fn render(&self) -> String {
        format!("Circle with radius {}", self.radius)
    }
}
// 2. Create the Canvas struct
impl Renderable for Rectangle {
    fn render(&self) -> String {
        format!("Rectangle with width {} and height {}", self.width, self.height)
    }
}
// 3. Implement the Canvas struct
pub struct Canvas {
    pub shapes: Vec<Box<dyn Renderable>>,
}
impl Canvas {
    pub fn new() -> Self {
        Canvas {shapes: Vec::new()}
    }
    pub fn add_shape(&mut self, shape: Box<dyn Renderable>) {
        self.shapes.push(shape);
    }
    pub fn render_all(&self) -> Vec<String> {
        let mut vecs = Vec::<String>::new();
        
        self.shapes.iter().for_each(|item| {
            vecs.push(item.render());
        });
        vecs
    }
}
// Example usage
pub fn main() {
    let mut canvas = Canvas::new();
    canvas.add_shape(Box::new(Circle { radius: 5.0 }));
    canvas.add_shape(Box::new(Rectangle {
        width: 3.0,
        height: 4.0,
    }));
    let rendered_shapes = canvas.render_all();
    for shape in rendered_shapes {
        println!("{}", shape);
    }
}

vijayabhaskar badireddi

ptcte

a month ago

5.12ms

193.67kb

pub trait Renderable {
    fn render(&self) -> String;
}
pub struct Circle {
    pub radius: f64,
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
impl Renderable for Circle {
    fn render(&self) -> String {
        format!("Circle with radius {}", self.radius)
    }
}
impl Renderable for Rectangle {
    fn render(&self) -> String {
        format!(
            "Rectangle with width {} and height {}",
            self.width, self.height
        )
    }
}
// 1. Implement the trait for Circle and Rectangle
pub struct Canvas {
    shapes: Vec<Box<dyn Renderable>>,
}
// 3. Implement the Canvas struct
impl Canvas {
    pub fn new() -> Self {
        Self { shapes: vec![] }
    }
    pub fn add_shape(&mut self, shape: Box<dyn Renderable>) {
        self.shapes.push(shape);
    }
    pub fn render_all(&self) -> Vec<String> {
        self.shapes.iter().map(|shape| shape.render()).collect()
    }
}
// Example usage
pub fn main() {
    let mut canvas = Canvas::new();
    canvas.add_shape(Box::new(Circle { radius: 5.0 }));
    canvas.add_shape(Box::new(Rectangle {
        width: 3.0,
        height: 4.0,
    }));
    let rendered_shapes = canvas.render_all();
    for shape in rendered_shapes {
        println!("{}", shape);
    }
}

Assylbek Razakhbergenov

asylbek27

a month ago

5.71ms

193.67kb

pub trait Renderable {
    fn render(&self) -> String;
}
pub struct Circle {
    pub radius: f64,
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
// 1. Implement the trait for Circle and Rectangle
impl Renderable for Circle {
    fn render(&self) -> String {
        format!("Circle with radius {}", self.radius)
    }
}
impl Renderable for Rectangle {
    fn render(&self) -> String {
        format!("Rectangle with width {} and height {}", self.width, self.height)
    }
}
// 2. Create the Canvas struct
pub struct Canvas {
    shapes: Vec<Box<dyn Renderable>>,
}
// 3. Implement the Canvas struct
impl Canvas {
    pub fn new() -> Self {
        Self {
            shapes: vec![],
        }
    }
    pub fn add_shape(&mut self, shape: Box<dyn Renderable>) {
        self.shapes.push(shape);
    }
    pub fn render_all(&self) -> Vec<String> {
        self.shapes.iter().map(|shape| shape.render()).collect()
    }
}
// Example usage
pub fn main() {
    let mut canvas = Canvas::new();
    canvas.add_shape(Box::new(Circle { radius: 5.0 }));
    canvas.add_shape(Box::new(Rectangle {
        width: 3.0,
        height: 4.0,
    }));
    let rendered_shapes = canvas.render_all();
    for shape in rendered_shapes {
        println!("{}", shape);
    }
}

chuyuanlinzi

a month ago

4.70ms

193.67kb

pub trait Renderable {
    fn render(&self) -> String;
}
pub struct Circle {
    pub radius: f64,
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
// 1. Implement the trait for Circle and Rectangle
impl Renderable for Circle{
    fn render(&self) -> String {
        format!("Circle with radius {}", self.radius)
    }
}
impl Renderable for Rectangle{
    fn render(&self) -> String {
        format!("Rectangle with width {} and height {}", self.width, self.height)
    }
}
// 2. Create the Canvas struct
pub struct Canvas{
    pub shapes: Vec<Box<dyn Renderable>>,
}
// 3. Implement the Canvas struct
impl Canvas{
    pub fn new() -> Canvas {
        Canvas {
            shapes: Vec::new()
        }
    }
    pub fn add_shape(&mut self, item: Box<dyn Renderable>){
        self.shapes.push(item);
    }
    pub fn render_all(&self) -> Vec<String>{
        self.shapes.iter().map(|i| i.render()).collect()
    }
}
// Example usage
pub fn main() {
    let mut canvas = Canvas::new();
    canvas.add_shape(Box::new(Circle { radius: 5.0 }));
    canvas.add_shape(Box::new(Rectangle {
        width: 3.0,
        height: 4.0,
    }));
    let rendered_shapes = canvas.render_all();
    for shape in rendered_shapes {
        println!("{}", shape);
    }
}

VerweyFr

a month ago

7.01ms

193.67kb

pub trait Renderable {
    fn render(&self) -> String;
}
pub struct Circle {
    pub radius: f64,
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
// 1. Implement the trait for Circle and Rectangle
impl Renderable for Circle {
    fn render(&self) -> String {
        format!("Circle with radius {}", self.radius)
    }
}
impl Renderable for Rectangle {
    fn render(&self) -> String {
        format!("Rectangle with width {} and height {}", self.width, self.height)
    }
}
// 2. Create the Canvas struct
pub struct Canvas {
    shapes: Vec<Box<dyn Renderable>>,
}
impl Canvas {
    pub fn new() -> Self {
        Canvas {
            shapes: Vec::new(),
        }
    }
    pub fn add_shape(&mut self, shape: Box<dyn Renderable>) {
        self.shapes.push(shape);
    }
    pub fn render_all(&self) -> Vec<String> {
        self.shapes.iter().map(|shape| shape.render()).collect()
    }
}
pub fn main() {
    let mut canvas = Canvas::new();
    canvas.add_shape(Box::new(Circle { radius: 5.0 }));
    canvas.add_shape(Box::new(Rectangle {
        width: 3.0,
        height: 4.0,
    }));
    let rendered_shapes = canvas.render_all();
    for shape in rendered_shapes {
        println!("{}", shape);
    }
}

Suresh Kumar

toddlers

a month ago

6.45ms

194.25kb

pub trait Renderable {
    fn render(&self) -> String;
}
pub struct Circle {
    pub radius: f64,
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
// 1. Implement the trait for Circle and Rectangle
impl Renderable for Circle {
    fn render(&self) -> String {
        format!("Circle with radius {}", self.radius)
    }
}
impl Renderable for Rectangle {
    fn render(&self) -> String {
        format!("Rectangle with width {} and height {}", self.width, self.height)
    }
}
// 2. Create the Canvas struct
pub struct Canvas {
    pub shape: Vec<Box<dyn Renderable>>,
}
// 3. Implement the Canvas struct
impl Canvas {
    pub fn new() -> Self {
        Self {
            shape:Vec::new(),
        }
    }
    pub fn add_shape(&mut self, other_shape: Box<dyn Renderable>) {
        self.shape.push(other_shape);
    }
    pub fn render_all(&self)-> Vec<String>{
        let mut result = Vec::new();
        for temp_shape in self.shape.iter(){
                result.push(temp_shape.render());
        }
        result
    }
}
// Example usage
pub fn main() {
    let mut canvas = Canvas::new();
    canvas.add_shape(Box::new(Circle { radius: 5.0 }));
    canvas.add_shape(Box::new(Rectangle {
        width: 3.0,
        height: 4.0,
    }));
    let rendered_shapes = canvas.render_all();
    for shape in rendered_shapes {
        println!("{}", shape);
    }
}

Kondorok

a month ago

5.53ms

193.67kb

pub trait Renderable {
    fn render(&self) -> String;
}
pub struct Circle {
    pub radius: f64,
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
// 1. Implement the trait for Circle and Rectangle
impl Renderable for Circle {
    fn render(&self) -> String {
        format!("Circle with radius {}", self.radius)
    }
}
impl Renderable for Rectangle {
    fn render(&self) -> String {
        format!(
            "Rectangle with width {} and height {}",
            self.width, self.height
        )
    }
}
// 2. Create the Canvas struct
pub struct Canvas {
    pub shape: Vec<Box<dyn Renderable>>,
}
// 3. Implement the Canvas struct
impl Canvas {
    pub fn new() -> Canvas {
        Canvas { shape: vec![] }
    }
    pub fn add_shape(&mut self, shape: Box<dyn Renderable>) {
        self.shape.push(shape);
    }
    pub fn render_all(&self) -> Vec<String> {
        self.shape.iter().map(|shape| shape.render()).collect()
    }
}
// Example usage
pub fn main() {
    let mut canvas = Canvas::new();
    canvas.add_shape(Box::new(Circle { radius: 5.0 }));
    canvas.add_shape(Box::new(Rectangle {
        width: 3.0,
        height: 4.0,
    }));
    let rendered_shapes = canvas.render_all();
    for shape in rendered_shapes {
        println!("{}", shape);
    }
}

Suresh Kumar

toddlers

a month ago

11.25ms

194.25kb

pub trait Renderable {
    fn render(&self) -> String;
}
pub struct Circle {
    pub radius: f64,
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
// 1. Implement the trait for Circle and Rectangle
impl Renderable for Circle {
    fn render(&self) -> String {
        format!("Circle with radius {}", self.radius)
    }
}
impl Renderable for Rectangle {
    fn render(&self) -> String {
        format!("Rectangle with width {} and height {}", self.width, self.height)
    }
}
// 2. Create the Canvas struct
pub struct Canvas {
    pub shape: Vec<Box<dyn Renderable>>,
}
// 3. Implement the Canvas struct
impl Canvas {
    pub fn new() -> Self {
        Self {
            shape:Vec::new(),
        }
    }
    pub fn add_shape(&mut self, other_shape: Box<dyn Renderable>) {
        self.shape.push(other_shape);
    }
    pub fn render_all(&self)-> Vec<String>{
        let mut result = Vec::new();
        for temp_shape in self.shape.iter(){
                result.push(temp_shape.render());
        }
        result
    }
}
// Example usage
pub fn main() {
    let mut canvas = Canvas::new();
    canvas.add_shape(Box::new(Circle { radius: 5.0 }));
    canvas.add_shape(Box::new(Rectangle {
        width: 3.0,
        height: 4.0,
    }));
    let rendered_shapes = canvas.render_all();
    for shape in rendered_shapes {
        println!("{}", shape);
    }
}

Namondz

a month ago

7.19ms

193.61kb

pub trait Renderable {
    fn render(&self) -> String;
}
pub struct Circle {
    pub radius: f64,
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
// 1. Implement the trait for Circle and Rectangle
impl Renderable for Circle {
    fn render(&self) -> String {
        format!("Circle with radius {}",self.radius)
    }
}
impl Renderable for Rectangle {
    fn render(&self) -> String {
        format!("Rectangle with width {} and height {}",self.width,self.height)
    }
}
// 2. Create the Canvas struct
pub struct Canvas {
    shape: Vec<Box<dyn Renderable>>
}
// 3. Implement the Canvas struct
impl Canvas {
    pub fn new() -> Self {
        Self{
            shape:Vec::new(),
        }
    }
    pub fn add_shape(&mut self,other_shape:Box<dyn Renderable>) {
        self.shape.push(other_shape)
    }
    pub fn render_all(self) ->Vec<String> {
        self.shape.iter().map(|x| x.render()).collect()
    }
}
// Example usage
pub fn main() {
    let mut canvas = Canvas::new();
    canvas.add_shape(Box::new(Circle { radius: 5.0 }));
    canvas.add_shape(Box::new(Rectangle {
        width: 3.0,
        height: 4.0,
    }));
    let rendered_shapes = canvas.render_all();
    for shape in rendered_shapes {
        println!("{}", shape);
    }
}

Namondz

a month ago

11.91ms

181.62kb

pub trait Renderable {
    fn render(&self) -> String;
}
pub struct Circle {
    pub radius: f64,
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
// 1. Implement the trait for Circle and Rectangle
impl Renderable for Circle {
    fn render(&self) -> String {
        format!("Circle with radius {}",self.radius)
    }
}
impl Renderable for Rectangle {
    fn render(&self) -> String {
        format!("Rectangle with width {} and height {}",self.width,self.height)
    }
}
// 2. Create the Canvas struct
pub struct Canvas {
    shape: Vec<Box<dyn Renderable>>
}
// 3. Implement the Canvas struct
impl Canvas {
    pub fn new() -> Self {
        Self{
            shape:Vec::new(),
        }
    }
    pub fn add_shape(&mut self,other_shape:Box<dyn Renderable>) {
        self.shape.push(other_shape)
    }
    pub fn render_all(self) ->Vec<String> {
        self.shape.into_iter().map(|x| x.render()).collect()
    }
}
// Example usage
pub fn main() {
    let mut canvas = Canvas::new();
    canvas.add_shape(Box::new(Circle { radius: 5.0 }));
    canvas.add_shape(Box::new(Rectangle {
        width: 3.0,
        height: 4.0,
    }));
    let rendered_shapes = canvas.render_all();
    for shape in rendered_shapes {
        println!("{}", shape);
    }
}

Jason

chenjie1219

2 months ago

7.47ms

193.67kb

pub trait Renderable {
    fn render(&self) -> String;
}
pub struct Circle {
    pub radius: f64,
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
// 1. Implement the trait for Circle and Rectangle
impl Renderable for Circle {
    fn render(&self) -> String {
        format!("Circle with radius {}", self.radius)
    }
}
impl Renderable for Rectangle {
    fn render(&self) -> String {
        format!(
            "Rectangle with width {} and height {}",
            self.width, self.height
        )
    }
}
// 2. Create the Canvas struct
pub struct Canvas {
    shapes: Vec<Box<dyn Renderable>>,
}
// 3. Implement the Canvas struct
impl Canvas {
    pub fn new() -> Self {
        Self { shapes: vec![] }
    }
    pub fn add_shape(&mut self, shape: Box<dyn Renderable>) {
        self.shapes.push(shape);
    }
    pub fn render_all(&self) -> Vec<String> {
        self.shapes.iter().map(|shape| shape.render()).collect()
    }
}
// Example usage
pub fn main() {
    let mut canvas = Canvas::new();
    canvas.add_shape(Box::new(Circle { radius: 5.0 }));
    canvas.add_shape(Box::new(Rectangle {
        width: 3.0,
        height: 4.0,
    }));
    let rendered_shapes = canvas.render_all();
    for shape in rendered_shapes {
        println!("{}", shape);
    }
}

Yixian Du

duyixian1234

2 months ago

10.71ms

194.25kb

pub trait Renderable {
    fn render(&self) -> String;
}
pub struct Circle {
    pub radius: f64,
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
// 1. Implement the trait for Circle and Rectangle
impl Renderable for Circle {
    fn render(&self) -> String {
        format!("Circle with radius {}", self.radius)
    }
}
impl Renderable for Rectangle {
    fn render(&self) -> String {
        format!("Rectangle with width {} and height {}", self.width, self.height)
    }
}
// 2. Create the Canvas struct
pub struct Canvas {
    shapes: Vec<Box<dyn Renderable>>
}
// 3. Implement the Canvas struct
impl Canvas {
    pub fn new() -> Self {
        Canvas { shapes: Vec::new() }
    }
    pub fn add_shape(&mut self, new_shape: Box<dyn Renderable>) {
        &self.shapes.push(new_shape);
    }
    pub fn render_all(&self) -> Vec<String> {
        let mut shapes = Vec::new();
        for shape in &self.shapes {
            shapes.push(shape.render());
        }
        shapes
    }
}
// Example usage
pub fn main() {
    let mut canvas = Canvas::new();
    canvas.add_shape(Box::new(Circle { radius: 5.0 }));
    canvas.add_shape(Box::new(Rectangle {
        width: 3.0,
        height: 4.0,
    }));
    let rendered_shapes = canvas.render_all();
    for shape in rendered_shapes {
        println!("{}", shape);
    }
}

lugtester

2 months ago

8.59ms

194.25kb

pub trait Renderable {
    fn render(&self) -> String;
}
pub struct Circle {
    pub radius: f64,
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
// 1. Implement the trait for Circle and Rectangle
impl Renderable for Circle {
    fn render(&self) -> String {
        format!("Circle with radius {}", self.radius)
    }
}
impl Renderable for Rectangle {
    fn render(&self) -> String {
        format!("Rectangle with width {} and height {}", self.width, self.height)
    }
}
// 2. Create the Canvas struct
pub struct Canvas {
    shapes: Vec<Box<dyn Renderable>>
}
// 3. Implement the Canvas struct
impl Canvas {
    pub fn new() -> Self {
        Canvas { shapes: Vec::new() }
    }
    pub fn add_shape(&mut self, new_shape: Box<dyn Renderable>) {
        &self.shapes.push(new_shape);
    }
    pub fn render_all(&self) -> Vec<String> {
        let mut shapes = Vec::new();
        for shape in &self.shapes {
            shapes.push(shape.render());
        }
        shapes
    }
}
// Example usage
pub fn main() {
    let mut canvas = Canvas::new();
    canvas.add_shape(Box::new(Circle { radius: 5.0 }));
    canvas.add_shape(Box::new(Rectangle {
        width: 3.0,
        height: 4.0,
    }));
    let rendered_shapes = canvas.render_all();
    for shape in rendered_shapes {
        println!("{}", shape);
    }
}

Aurimas Kuniutis

auriku

2 months ago

5.26ms

172.58kb

pub trait Renderable {
    fn render(&self) -> String;
}
pub struct Circle {
    pub radius: f64,
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
// 1. Implement the trait for Circle and Rectangle
impl Renderable for Circle {
    fn render(&self) -> String {
        format!("Circle with radius {}", self.radius)
    }
}
impl Renderable for Rectangle {
    fn render(&self) -> String {
        format!(
            "Rectangle with width {} and height {}",
            self.width, self.height
        )
    }
}
// 2. Create the Canvas struct
pub struct Canvas {
    shapes: Vec<Box<dyn Renderable>>,
}
impl Canvas {
  pub fn new() -> Self {
    Self { shapes: Vec::<Box<dyn Renderable>>::new() }
  }
  pub fn add_shape(&mut self, shape: Box<dyn Renderable>){
    self.shapes.push(shape);
  }
  pub fn render_all(&self) -> Vec<String> {
    let mut rendered: Vec<String> = vec![];
    for shape in self.shapes.iter() {
        rendered.push((*shape.render()).to_string());
    }
//       self.shapes.iter().for_each(|e|rendered.push(e.render()));
      rendered
  }
}
// 3. Implement the Canvas struct
// Example usage
pub fn main() {
    let mut canvas = Canvas::new();
    canvas.add_shape(Box::new(Circle { radius: 5.0 }));
    canvas.add_shape(Box::new(Rectangle {
        width: 3.0,
        height: 4.0,
    }));
    let rendered_shapes = canvas.render_all();
    for shape in rendered_shapes {
        println!("{}", shape);
    }
}

Aurimas Kuniutis

auriku

2 months ago

6.12ms

194.25kb

pub trait Renderable {
    fn render(&self) -> String;
}
pub struct Circle {
    pub radius: f64,
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
// 1. Implement the trait for Circle and Rectangle
impl Renderable for Circle {
    fn render(&self) -> String {
        format!("Circle with radius {}", self.radius)
    }
}
impl Renderable for Rectangle {
    fn render(&self) -> String {
        format!(
            "Rectangle with width {} and height {}",
            self.width, self.height
        )
    }
}
// 2. Create the Canvas struct
pub struct Canvas {
    shapes: Vec<Box<dyn Renderable>>,
}
impl Canvas {
  pub fn new() -> Self {
    Self { shapes: Vec::<Box<dyn Renderable>>::new() }
  }
  pub fn add_shape(&mut self, shape: Box<dyn Renderable>){
    self.shapes.push(shape);
  }
  pub fn render_all(&self) -> Vec<String> {
    let mut rendered: Vec<String> = vec![];
      self.shapes.iter().for_each(|e|rendered.push(e.render()));
      rendered
  }
}
// 3. Implement the Canvas struct
// Example usage
pub fn main() {
    let mut canvas = Canvas::new();
    canvas.add_shape(Box::new(Circle { radius: 5.0 }));
    canvas.add_shape(Box::new(Rectangle {
        width: 3.0,
        height: 4.0,
    }));
    let rendered_shapes = canvas.render_all();
    for shape in rendered_shapes {
        println!("{}", shape);
    }
}

0XDamn

0xDamn

2 months ago

4.92ms

193.67kb

pub trait Renderable {
    fn render(&self) -> String;
}
pub struct Circle {
    pub radius: f64,
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
// 1. Implement the trait for Circle and Rectangle
impl Renderable for Circle {
    fn render(&self) -> String {
        format!("Circle with radius {}", self.radius)
    }
}
impl Renderable for Rectangle {
    fn render(&self) -> String {
        format!("Rectangle with width {} and height {}", self.width, self.height)
    }
}
// 2. Create the Canvas struct
pub struct Canvas {
    pub shapes: Vec<Box<dyn Renderable>>,
}
// 3. Implement the Canvas struct
impl Canvas {
    pub fn new() -> Canvas {
        Canvas { shapes: Vec::new() }
    }
    pub fn add_shape(&mut self, s: Box<dyn Renderable>) {
        self.shapes.push(s);
    }
    pub fn render_all(&self) -> Vec<String> {
        self.shapes.iter().map(|s| s.render()).collect()
    }
}
// Example usage
pub fn main() {
    let mut canvas = Canvas::new();
    canvas.add_shape(Box::new(Circle { radius: 5.0 }));
    canvas.add_shape(Box::new(Rectangle {
        width: 3.0,
        height: 4.0,
    }));
    let rendered_shapes = canvas.render_all();
    for shape in rendered_shapes {
        println!("{}", shape);
    }
}

Anna Komarova

Vlasanya

2 months ago

14.06ms

193.67kb

pub trait Renderable {
    fn render(&self) -> String;
}
pub struct Circle {
    pub radius: f64,
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
impl Renderable for Circle {
    fn render(&self) -> String {
        format!("Circle with radius {}", self.radius)
    }
}
impl Renderable for Rectangle {
    fn render(&self) -> String {
        format!("Rectangle with width {} and height {}", self.width, self.height)
    }
}
pub struct Canvas {
    pub shapes: Vec<Box<dyn Renderable>>,
}
impl Canvas {
    pub fn new() -> Self {
        Self {
            shapes: Vec::new(),
        }
    }
    
    pub fn add_shape(&mut self, shape: Box<dyn Renderable>) {
        self.shapes.push(shape);
    }
    
    pub fn render_all(&self) -> Vec<String> {
        self.shapes.iter().map(|shape| shape.render()).collect()
    }
}
// Example usage
pub fn main() {
    let mut canvas = Canvas::new();
    canvas.add_shape(Box::new(Circle { radius: 5.0 }));
    canvas.add_shape(Box::new(Rectangle {
        width: 3.0,
        height: 4.0,
    }));
    let rendered_shapes = canvas.render_all();
    for shape in rendered_shapes {
        println!("{}", shape);
    }
}

Cristian Prieto

cprieto

2 months ago

6.57ms

193.67kb

pub trait Renderable {
    fn render(&self) -> String;
}
pub struct Circle {
    pub radius: f64,
}
impl Renderable for Circle {
    fn render(&self) -> String {
        format!("Circle with radius {}", self.radius)
    }
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
impl Renderable for Rectangle {
    fn render(&self) -> String {
        format!(
            "Rectangle with width {} and height {}",
            self.width, self.height
        )
    }
}
// 2. Create the Canvas struct
pub struct Canvas {
    pub shapes: Vec<Box<dyn Renderable>>,
}
impl Canvas {
    pub fn new() -> Self {
        Canvas { shapes: vec![] }
    }
    pub fn add_shape(&mut self, shape: Box<dyn Renderable>) {
        self.shapes.push(shape);
    }
    pub fn render_all(&self) -> Vec<String> {
        self.shapes
            .iter()
            .map(|shape| shape.render())
            .collect::<Vec<String>>()
    }
}
// 3. Implement the Canvas struct
// Example usage
pub fn main() {
    let mut canvas = Canvas::new();
    canvas.add_shape(Box::new(Circle { radius: 5.0 }));
    canvas.add_shape(Box::new(Rectangle {
        width: 3.0,
        height: 4.0,
    }));
    let rendered_shapes = canvas.render_all();
    for shape in rendered_shapes {
        println!("{}", shape);
    }
}

Artem

tich31337

2 months ago

4.75ms

193.67kb

pub trait Renderable {
    fn render(&self) -> String;
}
pub struct Circle {
    pub radius: f64,
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
// 1. Implement the trait for Circle and Rectangle
impl Renderable for Circle {
    fn render(&self) -> String {
        format!("Circle with radius {}", self.radius)
    }
}
// 2. Create the Canvas struct
impl Renderable for Rectangle {
    fn render(&self) -> String {
        format!("Rectangle with width {} and height {}", self.width, self.height)
    }
}
// 3. Implement the Canvas struct
pub struct Canvas {
    pub shapes: Vec<Box<dyn Renderable>>,
}
impl Canvas {
    pub fn new() -> Canvas {
        Canvas{
            shapes: vec![],
        }
    }
    pub fn add_shape(&mut self, val: Box<dyn Renderable>) {
        self.shapes.push(val);
    }
    pub fn render_all(&self) -> Vec<String> {
        self.shapes.iter().map(|val| val.render()).collect()
    }
}
// Example usage
pub fn main() {
    let mut canvas = Canvas::new();
    canvas.add_shape(Box::new(Circle { radius: 5.0 }));
    canvas.add_shape(Box::new(Rectangle {
        width: 3.0,
        height: 4.0,
    }));
    let rendered_shapes = canvas.render_all();
    for shape in rendered_shapes {
        println!("{}", shape);
    }
}

Paulo Lins

pblins

2 months ago

5.20ms

193.67kb

pub trait Renderable {
    fn render(&self) -> String;
}
pub struct Circle {
    pub radius: f64,
}
impl Renderable for Circle {
    fn render(&self) -> String {
        format!("Circle with radius {}", self.radius)
    }
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
impl Renderable for Rectangle {
    fn render(&self) -> String {
        format!(
            "Rectangle with width {} and height {}",
            self.width, self.height
        )
    }
}
pub struct Canvas {
    pub shapes: Vec<Box<dyn Renderable>>,
}
impl Canvas {
    pub fn new() -> Self {
        Self { shapes: Vec::new() }
    }
    pub fn add_shape(&mut self, shape: Box<dyn Renderable>) {
        self.shapes.push(shape);
    }
    pub fn render_all(&self) -> Vec<String> {
        self.shapes.iter().map(|s| s.render()).collect()
    }
}
pub fn main() {
    let mut canvas = Canvas::new();
    canvas.add_shape(Box::new(Circle { radius: 5.0 }));
    canvas.add_shape(Box::new(Rectangle {
        width: 3.0,
        height: 4.0,
    }));
    let rendered_shapes = canvas.render_all();
    for shape in rendered_shapes {
        println!("{}", shape);
    }
}

tzmijewski

2 months ago

5.24ms

194.25kb

pub trait Renderable {
    fn render(&self) -> String;
}
pub struct Circle {
    pub radius: f64,
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
// 1. Implement the trait for Circle and Rectangle
impl Renderable for Circle {
    fn render(&self) -> String {
        format!("Circle with radius {}", self.radius)
    }
}
impl Renderable for Rectangle {
    fn render(&self) -> String {
        format!("Rectangle with width {} and height {}", self.width, self.height)
    }
}
// 2. Create the Canvas struct
pub struct Canvas {
    pub shapes: Vec<Box<dyn Renderable>>,
}
// 3. Implement the Canvas struct
impl Canvas {
    pub fn new() -> Canvas {
        Canvas {
            shapes: vec![],
        }
    }
    pub fn add_shape(&mut self, shape: Box<dyn Renderable>) {
        self.shapes.push(shape);
    }
    pub fn render_all(&self) -> Vec<String> {
        let mut rendered_shapes: Vec<String> = vec![];
        for shape in self.shapes.iter() {
            rendered_shapes.push(shape.render());
        }
        rendered_shapes
    }
}
// Example usage
pub fn main() {
    let mut canvas = Canvas::new();
    canvas.add_shape(Box::new(Circle { radius: 5.0 }));
    canvas.add_shape(Box::new(Rectangle {
        width: 3.0,
        height: 4.0,
    }));
    let rendered_shapes = canvas.render_all();
    for shape in rendered_shapes {
        println!("{}", shape);
    }
}

Icarus

IcarusxB

2 months ago

5.46ms

193.67kb

pub trait Renderable {
    fn render(&self) -> String;
}
pub struct Circle {
    pub radius: f64,
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
 impl Renderable for Circle{
    fn render(&self) -> String{
        format!("Circle with radius {}", self.radius)
    }
}
impl Renderable for Rectangle{
    fn render(&self) -> String{
        format!("Rectangle with width {} and height {}", self.width, self.height)
    }
}
pub struct Canvas {
    pub shapes : Vec<Box<dyn Renderable>>,
}
impl Canvas {
    pub fn new() -> Canvas{
        Canvas {shapes: Vec::new()}
    }
    pub fn add_shape(&mut self, shape: Box<dyn Renderable>) {
        self.shapes.push(shape);
    }
    pub fn render_all(&self) -> Vec<String>{
        self.shapes.iter().map(|s| s.render()).collect()
    }
}
// 1. Implement the trait for Circle and Rectangle
// 2. Create the Canvas struct
// 3. Implement the Canvas struct
// Example usage
pub fn main() {
    let mut canvas = Canvas::new();
    canvas.add_shape(Box::new(Circle { radius: 5.0 }));
    canvas.add_shape(Box::new(Rectangle {
        width: 3.0,
        height: 4.0,
    }));
    let rendered_shapes = canvas.render_all();
    for shape in rendered_shapes {
        println!("{}", shape);
    }
}

Icarus

IcarusxB

2 months ago

9.40ms

193.67kb

pub trait Renderable {
    fn render(&self) -> String;
}
pub struct Circle {
    pub radius: f64,
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
 impl Renderable for Circle{
    fn render(&self) -> String{
        format!("Circle with radius {}", self.radius)
    }
}
impl Renderable for Rectangle{
    fn render(&self) -> String{
        format!("Rectangle with width {} and height {}", self.width, self.height)
    }
}
pub struct Canvas {
    pub shapes : Vec<Box<dyn Renderable>>,
}
impl Canvas {
    pub fn new() -> Canvas{
        Canvas {shapes: Vec::new()}
    }
    pub fn add_shape(&mut self, shape: Box<dyn Renderable>) {
        self.shapes.push(shape);
    }
    pub fn render_all(&self) -> Vec<String>{
        self.shapes.iter().map(|shape| shape.render()).collect()
    }
}
// 1. Implement the trait for Circle and Rectangle
// 2. Create the Canvas struct
// 3. Implement the Canvas struct
// Example usage
pub fn main() {
    let mut canvas = Canvas::new();
    canvas.add_shape(Box::new(Circle { radius: 5.0 }));
    canvas.add_shape(Box::new(Rectangle {
        width: 3.0,
        height: 4.0,
    }));
    let rendered_shapes = canvas.render_all();
    for shape in rendered_shapes {
        println!("{}", shape);
    }
}

Matthew Li

circles-png

2 months ago

5.11ms

193.67kb

pub trait Renderable {
    fn render(&self) -> String;
}
pub struct Circle {
    pub radius: f64,
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
// 1. Implement the trait for Circle and Rectangle
impl Renderable for Circle {
    fn render(&self) -> String {
        format!("Circle with radius {}", self.radius)
    }
}
impl Renderable for Rectangle {
    fn render(&self) -> String {
        format!("Rectangle with width {} and height {}", self.width, self.height)
    }
}
// 2. Create the Canvas struct
pub struct Canvas {
    pub shapes: Vec<Box<dyn Renderable>>
}
// 3. Implement the Canvas struct
impl Canvas {
    pub fn new() -> Self {
        Self {
            shapes: Vec::new()
        }
    }
    pub fn add_shape(&mut self, shape: Box<dyn Renderable>) {
        self.shapes.push(shape)
    }
    pub fn render_all(&self) -> Vec<String> {
        self.shapes.iter().map(|shape| shape.render()).collect()
    }
}
// Example usage
pub fn main() {
    let mut canvas = Canvas::new();
    canvas.add_shape(Box::new(Circle { radius: 5.0 }));
    canvas.add_shape(Box::new(Rectangle {
        width: 3.0,
        height: 4.0,
    }));
    let rendered_shapes = canvas.render_all();
    for shape in rendered_shapes {
        println!("{}", shape);
    }
}

Tboot

tboot-0510

2 months ago

10.77ms

194.25kb

pub trait Renderable {
    fn render(&self) -> String;
}
pub struct Circle {
    pub radius: f64,
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
// 1. Implement the trait for Circle and Rectangle
impl Renderable for Circle {
    fn render(&self) -> String {
        format!("Circle with radius {}", self.radius)
    }
}
impl Renderable for Rectangle {
    fn render(&self) -> String {
        format!("Rectangle with width {} and height {}", self.width, self.height)
    }
}
// 2. Create the Canvas struct
pub struct Canvas {
    pub shapes: Vec<Box<dyn Renderable>>,
}
// 3. Implement the Canvas struct
impl Canvas {
    pub fn new() -> Self {
        Self {
            shapes: Vec::new()
        }
    }
    pub fn add_shape(&mut self, shape: Box<dyn Renderable>) {
        self.shapes.push(shape);
    }
    pub fn render_all(&self) -> Vec<String> {
        let mut string_vec: Vec<String> = Vec::new();
        for elm in self.shapes.iter() {
            string_vec.push(elm.render())
        }
        string_vec
    }
}
// Example usage
pub fn main() {
    let mut canvas = Canvas::new();
    canvas.add_shape(Box::new(Circle { radius: 5.0 }));
    canvas.add_shape(Box::new(Rectangle {
        width: 3.0,
        height: 4.0,
    }));
    let rendered_shapes = canvas.render_all();
    for shape in rendered_shapes {
        println!("{}", shape);
    }
}

TiagONTOP

2 months ago

5.74ms

194.25kb


pub trait Renderable {
    fn render(&self) -> String;
}
pub struct Circle {
    pub radius: f64,
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
// 1. Implement the trait for Circle and Rectangle
impl Renderable for Circle {
    fn render(&self) -> String {
        format!("Circle with radius {}", self.radius.to_string())
    }
}
impl Renderable for Rectangle {
    fn render(&self) -> String {
        format!("Rectangle with width {} and height {}", self.width, self.height)
    }
}
// 2. Create the Canvas struct
pub struct Canvas {
    pub shapes: Vec<Box<dyn Renderable>>,
}
// 3. Implement the Canvas struct
impl Canvas {
    pub fn new() -> Self {
        Self {
            shapes: Vec::new()
        }
    }
    pub fn add_shape(&mut self, shape: Box<dyn Renderable>) {
        self.shapes.push(shape)
    }
    pub fn render_all(&self) -> Vec<String> {
        let mut string_vec: Vec<String> = Vec::new();
        for elm in self.shapes.iter() {
            string_vec.push(elm.render())
        }
        string_vec
    }
}
// Example usage
pub fn main() {
    let mut canvas = Canvas::new();
    canvas.add_shape(Box::new(Circle { radius: 5.0 }));
    canvas.add_shape(Box::new(Rectangle {
        width: 3.0,
        height: 4.0,
    }));
    let rendered_shapes = canvas.render_all();
    for shape in rendered_shapes {
        println!("{}", shape);
    }
}

Hung Dinh

nhdinh

2 months ago

5.19ms

194.25kb

pub trait Renderable {
    fn render(&self) -> String;
}
pub struct Circle {
    pub radius: f64,
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
// 1. Implement the trait for Circle and Rectangle
impl Renderable for Circle {
    fn render(&self) -> String {
        format!("Circle with radius {}", self.radius)
    }
}
impl Renderable for Rectangle {
    fn render(&self) -> String {
        format!("Rectangle with width {} and height {}", self.width, self.height)
    }
}
// 2. Create the Canvas struct
pub struct Canvas {
    pub shapes: Vec<Box<dyn Renderable>>
}
impl Canvas {
    pub fn new() -> Canvas {
        Canvas {
            shapes: vec![]
        }
    }
    pub fn add_shape(&mut self, shape: Box<dyn Renderable>) {
        self.shapes.push(shape);
    }
    pub fn render_all(&self) -> Vec<String> {
        let mut ans: Vec<String> = vec![];
        for shape in self.shapes.iter() {
            ans.push(shape.render());
        }
        ans
    }
}
// 3. Implement the Canvas struct
// Example usage
pub fn main() {
    let mut canvas = Canvas::new();
    canvas.add_shape(Box::new(Circle { radius: 5.0 }));
    canvas.add_shape(Box::new(Rectangle {
        width: 3.0,
        height: 4.0,
    }));
    let rendered_shapes = canvas.render_all();
    for shape in rendered_shapes {
        println!("{}", shape);
    }
}

AnKarl

Zythophilus

2 months ago

5.35ms

194.25kb

pub trait Renderable {
    fn render(&self) -> String;
}
pub struct Circle {
    pub radius: f64,
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
// 1. Implement the trait for Circle and Rectangle
impl Renderable for Circle {
    fn render(&self) -> String {
        format!("Circle with radius {}", self.radius)
    }
}
impl Renderable for Rectangle {
    fn render(&self) -> String {
        format!("Rectangle with width {} and height {}", self.width, self.height)
    }
}
// 2. Create the Canvas struct
pub struct Canvas {
    pub shapes: Vec<Box<dyn Renderable>>,
}
// 3. Implement the Canvas struct
impl Canvas {
    pub fn new() -> Self {
        Canvas {shapes: vec![]}
    }
    pub fn add_shape(&mut self, shape: Box<dyn Renderable>) {
        self.shapes.push(shape)
    }
    pub fn render_all(&self) -> Vec<String> {
        let mut res:Vec<String> = vec![];
        for shape in self.shapes.iter() {
            res.push(shape.render());
        }
        res
    }
}
// Example usage
pub fn main() {
    let mut canvas = Canvas::new();
    canvas.add_shape(Box::new(Circle { radius: 5.0 }));
    canvas.add_shape(Box::new(Rectangle {
        width: 3.0,
        height: 4.0,
    }));
    let rendered_shapes = canvas.render_all();
    for shape in rendered_shapes {
        println!("{}", shape);
    }
}

Zeiion

2 months ago

5.70ms

193.67kb

pub trait Renderable {
    fn render(&self) -> String;
}
pub struct Circle {
    pub radius: f64,
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
// 1. Implement the trait for Circle and Rectangle
impl Renderable for Circle {
    fn render(&self) -> String {
        format!("Circle with radius {}", self.radius)
    }
}
impl Renderable for Rectangle {
    fn render(&self) -> String {
        format!("Rectangle with width {} and height {}", self.width, self.height)
    }
}
// 2. Create the Canvas struct
pub struct Canvas {
    pub shapes: Vec<Box<dyn Renderable>>,
}
// 3. Implement the Canvas struct
impl Canvas {
    pub fn new() -> Canvas {
        Canvas {
            shapes: vec![]
        }
    }
    pub fn add_shape(&mut self, shape: Box<dyn Renderable>) {
        self.shapes.push(shape)
    }
    pub fn render_all(&self) -> Vec<String> {
        self.shapes.iter().map(|x| x.render()).collect()
    }
}

Viktor Merkurev

fennr

3 months ago

5.82ms

193.67kb

pub trait Renderable {
    fn render(&self) -> String;
}
pub struct Circle {
    pub radius: f64,
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
// 1. Implement the trait for Circle and Rectangle
impl Renderable for Circle {
    fn render(&self) -> String {
        format!("Circle with radius {}", self.radius)
    }
}
impl Renderable for Rectangle {
    fn render(&self) -> String {
        format!(
            "Rectangle with width {} and height {}",
            self.width, self.height
        )
    }
}
// 2. Create the Canvas struct
pub struct Canvas {
    shapes: Vec<Box<dyn Renderable>>,
}
// 3. Implement the Canvas struct
impl Canvas {
    pub fn new() -> Canvas {
        Canvas { shapes: Vec::new() }
    }
    pub fn add_shape(&mut self, shape: Box<dyn Renderable>) {
        self.shapes.push(shape);
    }
    pub fn render_all(&self) -> Vec<String> {
        self.shapes.iter().map(|shape| shape.render()).collect()
    }
}
// Example usage
pub fn main() {
    let mut canvas = Canvas::new();
    canvas.add_shape(Box::new(Circle { radius: 5.0 }));
    canvas.add_shape(Box::new(Rectangle {
        width: 3.0,
        height: 4.0,
    }));
    let rendered_shapes = canvas.render_all();
    for shape in rendered_shapes {
        println!("{}", shape);
    }
}

Trait Objects

Your Task

Requirements

Define the Renderable Trait

Define the Circle and Rectangle Structs

Implement the Renderable Trait

Define the Canvas Struct

Hints

Editor not available on Mobile!

Solutions

Khalifa

Nicolai

Splatrac

Trịnh Chấn Duy

Nathan GAUD

Jakub Wiśniewski

Nguyen Vo Hoang Son

Paolo Cancedda

Jakub Wiśniewski

Jason

vijayabhaskar badireddi

Assylbek Razakhbergenov

Suresh Kumar

Suresh Kumar

Jason

Yixian Du

Aurimas Kuniutis

Aurimas Kuniutis

0XDamn

Anna Komarova

Cristian Prieto

Artem

Paulo Lins

Icarus

Icarus

Matthew Li

Tboot

Hung Dinh

AnKarl

Zeiion

Viktor Merkurev

Define the `Renderable` Trait

Define the `Circle` and `Rectangle` Structs

Implement the `Renderable` Trait

Define the `Canvas` Struct