Rust dependency inversion with nested structs using RC - struct

Question

I am trying to do some dependecy inversion in Rust. My goal is to create a struct that accepts any other struct instance that complies with a trait.
This wont compile, but is basically what I would like to achieve:
// Trait for any kind of tool I may use in my work
trait ToolTrait {
fn do_work(&self);
}
struct Saw {
size: i32,
}
impl ToolTrait for Saw {
fn do_work(&self) {
println!("I'm a saw, size: {}cm", self.size);
}
}
struct ScrewDriver {
size: i32,
}
impl ToolTrait for ScrewDriver {
fn do_work(&self) {
println!("I'm a screwdriver, size: {}mm", self.size);
}
}
// Work uses any struct that complies with ToolTrait
pub struct Work {
tool: ToolTrait,
}
impl Work {
// We can instantiate Work and set tool to it
fn new(tool: ToolTrait) -> Work {
Work { tool }
}
}
let saw = Saw { size: 30 };
let work_1 = Work::new(saw);
work_1.tool.do_work(); // "I'm a saw, size: 30cm"
let screwdriver = ScrewDriver { size: 4 };
let work_2 = Work::new(screwdriver);
work_2.tool.do_work(); // "I'm a screwdriver, size: 4mm"
Now, regarding Rust compiler, we have several error warnings:
pub struct Work {
tool: ToolTrait,
}
// trait objects without an explicit `dyn` are deprecated
Ok, lets add dyn both in Work and impl Work:
pub struct Work {
tool: dyn ToolTrait,
}
impl Work {
fn new(tool: dyn ToolTrait) -> Work {
Work {
tool: Rc::new(tool),
}
}
}
Perfect, no error in Work. But focusing on impl Work we have this error:
impl Work {
fn new(tool: ToolTrait) -> Work {
Work {
tool: Rc::new(tool),
}
}
}
// the size for values of type `(dyn main::ToolTrait + 'static)` cannot be known at compilation time
Makes sense: Work can not know what size tool will have. But how can I fix it?
I wrapped dyn ToolTrait with std::rc::Rc as Rc<dyn ToolTrait>:
pub struct Work {
tool: Rc<dyn ToolTrait>,
}
impl Work {
// We can instantiate Work and set tool to it
fn new(tool: Rc<dyn ToolTrait>) -> Work {
Work { tool }
}
}
This works, but is this the correct way to achieve dependency inversion as we usually do in object oriented programming?

Answer 1

You can make your struct generic over the tool:
// Trait for any kind of tool I may use in my work
trait ToolTrait {
fn do_work(&self);
}
struct Saw {
size: i32,
}
impl ToolTrait for Saw {
fn do_work(&self) {
println!("I'm a saw, size: {}cm", self.size);
}
}
struct ScrewDriver {
size: i32,
}
impl ToolTrait for ScrewDriver {
fn do_work(&self) {
println!("I'm a screwdriver, size: {}mm", self.size);
}
}
// Work uses any struct that complies with ToolTrait
pub struct Work<T> {
tool: T,
}
impl<T: ToolTrait> Work<T> {
// We can instantiate Work and set tool to it
fn new(tool: T) -> Work<T> {
Work { tool }
}
}
fn main() {
let saw = Saw { size: 30 };
let work_1 = Work::new(saw);
work_1.tool.do_work(); // "I'm a saw, size: 30cm"
let screwdriver = ScrewDriver { size: 4 };
let work_2 = Work::new(screwdriver);
work_2.tool.do_work(); // "I'm a screwdriver, size: 4mm"
}