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

amaneru

7ma8no9

11 hours ago

5.36ms

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

AKA.MoneyTaker

M4Bo2

2 days ago

6.52ms

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, shape: Box<dyn Renderable> ){
        self.shapes.push(shape);
    }
    pub fn render_all(&self)-> Vec<String>{
        let mut rendered = Vec::<String>::new(); 
        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);
    }
}

Guilherme Cesário Strachan

strachan

3 days ago

5.74ms

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 {
        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(|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);
    }
}

AKA.MoneyTaker

M4Bo2

3 days ago

5.58ms

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 {
    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()
    }
}
// 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);
    }
}

Anıl Şenay

anilsenay

5 days ago

5.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,
}
// 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, r: Box<dyn Renderable>) {
        self.shapes.push(r)
    }
    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);
    }
}

Dyaa Adel

dyaa-adel

6 days ago

5.02ms

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::new()
        }
    }
    pub fn add_shape(&mut self, shape : Box<dyn Renderable>) {
        self.shapes.push(shape);
    }
    pub fn render_all(&self) -> Vec<String> {
        let mut renders : Vec<String> = Vec::new();
        for renderable_shape in self.shapes.iter() {
            renders.push(renderable_shape.render());
        }
        renders
    }
}
// 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);
    }
}

manuelmj

8 days ago

6.16ms

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 {
        String::from(format!("Circle with radius {}",self.radius))
    }
}
impl Renderable for Rectangle{
    fn render(&self)-> String{
        String::from(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, new_shape: Box<dyn Renderable>){
        self.shapes.push(new_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);
    }
}

Kentaro Abe

abekem

8 days ago

6.80ms

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 {
    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()
    }
}
// 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);
    }
}

norabbito

9 days ago

7.51ms

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![] }
    }
    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);
    }
}

Ayushman Rathore

Spartan09

9 days ago

5.76ms

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

Jun Huang

leemars

10 days ago

5.27ms

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

Jordan

Jordan-Haidee

12 days ago

6.50ms

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::new()}
    }
    pub fn add_shape(&mut self, s: Box<dyn Renderable>) {
        self.shapes.push(s);
    }
    pub fn render_all(&self) -> Vec<String> {
        let mut buffer = vec![];
        for s in self.shapes.iter() {
            buffer.push(s.render());
        }
        return buffer;
    }
}
// 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);
    }
}

Kyle Diaz

kylediaz

14 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 shapes: Vec<Box<dyn Renderable>>,
}
impl Canvas {
    pub fn new() -> Canvas {
        Canvas{
            shapes: vec![]
        }
    }
    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()
    }
}
// 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);
    }
}

automata-studio

14 days ago

5.00ms

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 {
        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(|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);
    }
}

Kenneth Love

kennethlove

15 days ago

4.83ms

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(|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);
    }
}

Muhammad-Dennis

16 days ago

4.96ms

194.25kb

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>>
}
// 3. Implement the Canvas struct
impl Canvas {
    pub fn new() -> Self {
        Self { shapes: Vec::new()}
    }
    pub fn add_shape(&mut self, s: Box<dyn Renderable>) 
    {
        self.shapes.push(s)
    }
    pub fn render_all(&self) -> Vec<String> {
        let mut rendered = vec![];
        for shape in &self.shapes {
            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);
    }
}

Romain Grimau

Herrgrim0

16 days ago

4.94ms

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 {0} and height {1}", 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(|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);
    }
}

Denis SOURON

Brack0

16 days ago

4.99ms

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
        )
    }
}
#[derive(Default)]
pub struct Canvas {
    pub shapes: Vec<Box<dyn Renderable>>,
}
impl Canvas {
    pub fn new() -> Self {
        Canvas::default()
    }
    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()
    }
}

Marco-Normal

16 days ago

4.84ms

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 {
    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(|sh| sh.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);
    }
}

ludovicknecht

16 days ago

4.72ms

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 rendered = Vec::<String>::new();
        for shape in &self.shapes {
            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);
    }
}

Christopher Nielson

c-nielson

17 days ago

5.16ms

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::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_shapes = Vec::new();
        for shape in &self.shapes {
            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);
    }
}

alemack17

17 days ago

4.57ms

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![]}
    }
    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);
    }
}

RiyadDz22

17 days ago

5.96ms

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, shape: Box<dyn Renderable> ){
        self.shapes.push(shape);
    }
    pub fn render_all(&self)-> Vec<String>{
        let mut rendered = Vec::<String>::new(); 
        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);
    }
}

Algorab

18 days ago

4.68ms

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 {
        Self { shapes: Vec::new() }
    }
    pub fn add_shape(&mut self, p0: Box<dyn Renderable>) {
       self.shapes.push(p0);
    }
    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);
    }
}

iamforgettable

19 days ago

4.64ms

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::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_strings = vec![];
        for shape in &self.shapes {
            shapes_strings.push(shape.render())
        }
        shapes_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);
    }
}

kosay

sarub0b0

19 days ago

6.78ms

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 {
    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()
    }
}
// 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);
    }
}

rawar089

20 days ago

5.55ms

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![] }
    }
    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(|o| o.render()).collect::<Vec<String>>()
    }
}
// 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);
    }
}

Nikita Smirnov

Nismirno

21 days ago

4.61ms

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::<Vec<String>>()
    }
}
// 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);
    }
}

Elliott Draper

ejdraper

22 days ago

8.99ms

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 {
        return format!("Circle with radius {}", self.radius);
    }
}
impl Renderable for Rectangle {
    fn render(&self) -> String {
        return 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> {
        return 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);
    }
}

zahrajavar

22 days ago

5.15ms

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, renderable: Box<dyn Renderable>) {
        self.shapes.push(renderable);
    }
    pub fn render_all(&self) -> Vec<String> {
        self.shapes.iter().map(|shape| shape.render()).collect()
    }
}
// Example usage
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);
    }
}

Justin Maillet

justy777

23 days ago

8.76ms

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

Oebelus

oebelus

24 days ago

4.85ms

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>>
}
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::<Vec<String>>()
    }
}
// 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);
    }
}

Jim Lawton

jimlawton

24 days ago

4.54ms

172.58kb

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 {
    shapes: Vec<Box<dyn Renderable>>,
}
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 renders = Vec::<String>::new();
        for shape in self.shapes.iter() {
            renders.push((*shape).render().to_string());
        }
        renders
    }
}
// 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);
    }
}

Stefan Roas

sroas

24 days ago

5.51ms

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>>,
}
// 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::<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);
    }
}

Shafer Hess

shafer-hess

25 days ago

5.09ms

193.67kb

pub trait Renderable {
    fn render(&self) -> String;
}
pub struct Circle {
    pub radius: f64,
}
pub struct Rectangle {
    pub width: f64,
    pub height: f64,
}
pub struct Canvas {
    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::<Vec<String>>()
    }
}
// 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)
    }
}
// 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);
    }
}

Jonathan Voss

jvoss

25 days ago

5.08ms

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(|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);
    }
}

TaiPoole

a month ago

12.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![]
        }
    }
    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(|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);
    }
}

dawwestk

a month ago

4.77ms

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(|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);
    }
}

PangoSea

kapaseker

a month ago

4.69ms

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 {
    shapes: Vec<Box<dyn Renderable>>,
}
impl Canvas {
    // Initializes an empty canvas.
    pub fn new() -> Self {
        Canvas {
            shapes: Vec::new(),
        }
    }
    // Adds a shape to the canvas.
    pub fn add_shape(&mut self, shape: Box<dyn Renderable>) {
        self.shapes.push(shape);
    }
    // Returns a vector of strings, each representing a rendered 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);
    }
}

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

amaneru

AKA.MoneyTaker

Guilherme Cesário Strachan

AKA.MoneyTaker

Anıl Şenay

Dyaa Adel

Kentaro Abe

Ayushman Rathore

Jun Huang

Jordan

Kyle Diaz

Kenneth Love

Romain Grimau

Denis SOURON

Christopher Nielson

Algorab

kosay

Nikita Smirnov

Elliott Draper

Justin Maillet

Oebelus

Jim Lawton

Stefan Roas

Shafer Hess

Jonathan Voss

PangoSea

Define the `Renderable` Trait

Define the `Circle` and `Rectangle` Structs

Implement the `Renderable` Trait

Define the `Canvas` Struct