Compiler Explorer

Source code

pub trait Shape {
    type T;
    fn area(&self) -> Self::T;
}

pub trait Draw: Shape {
    fn draw(&self);
}

// The function operates with a trait object reference
pub fn draw_dynamic(a: &dyn Draw<T = f64>) {
    a.draw();
}

// Invokes the draw method and then the area method on the trait object
pub fn draw_and_report_area_dynamic(a: &dyn Draw<T = f64>) -> f64 {
    a.draw();
    a.area()
}

// The trait object is wrapped in a Box. This means that function will have
// to free the memory associated with the trait object in the function body.
pub fn draw_and_report_area_dynamic_box(a: Box<dyn Draw<T = f64>>) -> f64 {
    a.draw();
    a.area()
}

// ====== Concrete type ======

// This function invokes the three functions we have been dealing with
// In this case, the compiler is able to inline the functions and remove
// the dynamic dispatch.
pub fn draw_rectange(rectangle: Rectangle<f64>) -> (f64, f64) {

draw_dynamic(&rectangle);
    let a = draw_and_report_area_dynamic(&rectangle);
    let b = draw_and_report_area_dynamic_box(Box::new(rectangle));
    (a, b)
}

pub struct Point<T> {
    x: T,
    y: T,
}

pub struct Rectangle<T> {
    top_left: Point<T>,
    bottom_right: Point<T>,
}

impl<T> Shape for Rectangle<T>
where
    T: std::ops::Sub<Output = T> + std::ops::Mul<Output = T> + Copy,
{
    type T = T;
    fn area(&self) -> T {
        let width = self.bottom_right.x - self.top_left.x;
        let height = self.top_left.y - self.bottom_right.y;
        width * height
    }
}

impl<T> Draw for Rectangle<T>
where
    T: std::ops::Sub<Output = T> + std::ops::Mul<Output = T> + Copy,
{
    fn draw(&self) {
        println!("Draw a rectangle");
    }
}