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

azmahflameheart

7 hours 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 {
    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 {
    pub shapes: Vec<Box<dyn Renderable>>,
}
// 3. Implement the Canvas struct
impl Canvas {
    pub fn new() -> Self {
        Self::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()
    }
}
// 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);
    }
}

ffrie

2 days ago

5.95ms

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

vqk-2003

2 days ago

7.14ms

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

Ramon Silva

rsilva1

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

Yashwanth

Yash981

5 days ago

5.14ms

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

LawisChen

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

ychanghe

8 days ago

4.52ms

172.01kb

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).to_string() 
    }
}
// 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::<Box<dyn Renderable>>::new()}
    }
    pub fn add_shape(&mut self, a:Box<dyn Renderable>) {
        self.shapes.push(a); 
    }
    pub fn render_all(&self) -> Vec<String> {
        self.shapes.iter().map(|b| {(*b).render()}).collect() // *b same to just b
    }
}
// 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);
    }
}

fasolyee

fasolyeedev

8 days ago

5.85ms

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 resvec : Vec<String> = Vec::new();
        for shape in self.shapes.iter(){
            resvec.push(shape.render());
        }
        resvec
    }
}
// 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);
    }
}

makinpaper

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

makinpaper

9 days ago

5.04ms

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

SpontaneousOverthrow

10 days ago

8.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>>
}
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> {
        let mut a = Vec::new();
        for i in self.shapes.iter() {
            a.push(i.render())
        }
        a
    }
}
// 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);
    }
}

<YoungAncient/>

youngancient

11 days ago

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

Omar Saber Talaat Abdelrahman

omar-s-ta

11 days ago

5.57ms

172.01kb

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

Omar Saber Talaat Abdelrahman

omar-s-ta

11 days ago

4.95ms

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

Dan Wayne

danwayne-me

11 days ago

4.58ms

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

Dimas Avrian Fachriza

FForFachriza

18 days ago

4.74ms

193.67kb

use std::fmt::Display;
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 Display for dyn Renderable {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(f, "{}", self.render())
    }
}
// 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);
    }
}

Kishan

wdcs-kishansudani

19 days ago

4.62ms

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

Asrul Firdaus

AsrulF

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

kasaxpong

19 days ago

4.95ms

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

Dharm Singh

dharmvr1

21 days ago

4.93ms

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()->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  render = Vec::new();
         for i in &self.shapes{
            render.push(i.render());
         }
         render
        
    }
    
}
// 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);
    }
}

Mykhailo Huzhvii

Ymkavi

24 days ago

5.23ms

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() -> 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(|object: &Box<dyn Renderable>| object.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);
    }
}

银雀Sparrxw

Sparr0www820

a month ago

13.33ms

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::<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> {
        self.shapes.iter().map(|object: &Box<dyn Renderable>| object.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);
    }
}

danyaffe63

a month ago

5.52ms

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::<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> {
        self.shapes.iter().map(|r: &Box<dyn Renderable>| r.render()).collect()
        // self.shapes.iter().map(|r| r.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);
    }
}

danyaffe63

a month ago

4.98ms

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::<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> {
        self.shapes.iter().map(|r: &Box<dyn Renderable>| r.as_ref().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);
    }
}

/sam

samging

a month 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, 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);
    }
}

Ari Karim

arikarim

a month ago

5.91ms

193.67kb

pub trait  Renderable {
    fn render(&self) -> String {
        "This is render from Renderable".to_string()
    }
}
#[derive(Clone)]
pub struct Circle {
    pub radius: f64,
}
impl Renderable for Circle {
    fn render(&self) -> String {
       format!("Circle with radius {}", self.radius)
    }
}
#[derive(Clone)]
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)
    }
}
// #[derive(Clone)]
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> {
        let res = self.shapes.iter().map(|el| {
            el.render()
        }).collect();
        res
    }
}
// 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);
    }
}

Yummy-Yums

a month ago

5.48ms

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

Vincent SAMY

vsamy

a month ago

10.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,
}
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);
    }
}

thriller08

a month ago

4.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).into()
    }
}
impl Renderable for Rectangle {
    fn render(&self) -> String {
        format!("Rectangle with width {} and height {}", self.width, self.height).into()
    }
}
// 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(|x| x.render().into()).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);
    }
}

thriller08

a month ago

5.48ms

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).into()
    }
}
impl Renderable for Rectangle {
    fn render(&self) -> String {
        format!("Rectangle with width {} and height {}", self.width, self.height).into()
    }
}
// 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(|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);
    }
}

reborn3d

a month 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 {
        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 {
    shapes : Vec<Box<dyn Renderable>>
}
// 3. Implement the Canvas struct
impl Canvas{
    pub fn new() -> Canvas{
        return 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(|shp| shp.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);
    }
}

Abhishek Sharma

0xAbhiDev

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

Abhishek Sharma

0xAbhiDev

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

nojae15

a month ago

6.05ms

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

jfloresremar

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

Francisco Alejandro

francisco-alejandro

2 months 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,
}
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 {
        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(|v| v.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);
    }
}

QuJohan

2 months ago

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

ghoti225

2 months ago

5.43ms

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, shape : Box<dyn Renderable>) {
        self.shapes.push(shape)
    }
    pub fn render_all(&self) -> Vec<String>{
        let mut all_shapes = vec![];
        for elem in self.shapes.iter() {
            all_shapes.push(elem.render());
        }
        all_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);
    }
}

Omar

OmniKobra

2 months ago

4.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>>,
}
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()
        
    }
}
// 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);
    }
}

Omar

OmniKobra

2 months ago

5.52ms

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() -> 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> {
        let mut v: Vec<String> = Vec::new();
        for s in self.shapes.iter(){
            v.push(s.render());
        }
        v
    }
}
// 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);
    }
}

Abdul

aisiyoup

2 months ago

5.20ms

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

msned

2 months ago

4.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{
        return format!("Circle with radius {}",self.radius).into();
    }
}
impl Renderable for Rectangle{
    fn render(&self) -> String{
        return format!("Rectangle with width {} and height {}",self.width,self.height).into();
    }
}
// 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 allStrings:Vec<String> = Vec::new();
        for shape in &self.shapes{
            allStrings.push(shape.render());
        }
        return allStrings;
    }
}
// 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);
    }
}

TheJanzap

2 months ago

4.73ms

172.01kb

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(|elem| elem.render().to_string()).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);
    }
}

TheJanzap

2 months ago

4.87ms

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

jh4vision

2 months ago

5.45ms

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

Artem

artemnistuley

2 months ago

5.63ms

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

Christophe Mohimont

mohic

2 months ago

6.37ms

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(|shape| shape.render()).collect()
    }
}

Smith, Taylor

a647965_fidelity

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

muemart

2 months ago

4.45ms

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: &Self) -> String {
        format!("Circle with radius {0}", self.radius)
    }
}
impl Renderable for Rectangle {
    fn render(self: &Self) -> String {
        format!("Rectangle with width {0} and height {1}", 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::new()
        }
    }
    pub fn add_shape(self: &mut Self, shape: Box<dyn Renderable>) {
        self.shapes.push(shape);
    }
    pub fn render_all(self: &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);
    }
}

amdfxlucas

2 months ago

4.81ms

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 {
    pub shapes: Vec<Box<dyn Renderable>>
}
impl Canvas {
    pub fn new() -> Self {
        Self{shapes: vec![] }
    }
    pub fn add_shape(&mut self, b: Box<dyn Renderable>)
    {
        self.shapes.push(b);
    }
    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);
    }
}

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

Ramon Silva

Yashwanth

fasolyee

<YoungAncient/>

Omar Saber Talaat Abdelrahman

Omar Saber Talaat Abdelrahman

Dan Wayne

Dimas Avrian Fachriza

Kishan

Asrul Firdaus

Dharm Singh

Mykhailo Huzhvii

银雀Sparrxw

/sam

Ari Karim

Vincent SAMY

Abhishek Sharma

Abhishek Sharma

Francisco Alejandro

Omar

Omar

Abdul

Artem

Christophe Mohimont

Smith, Taylor

Define the `Renderable` Trait

Define the `Circle` and `Rectangle` Structs

Implement the `Renderable` Trait

Define the `Canvas` Struct