Exploring Dynamic Dispatch in Rust: Unraveling the Power of Box<dyn Trait>

In Rust, Box<dyn Trait> represents a heap-allocated smart pointer to a type that implements a specific Trait. The dyn keyword is used to indicate that the specific type will be dynamically determined at runtime rather than at compile time. This is particularly useful when dealing with abstraction and polymorphism.

Let’s break it down:

• Box: It is a pointer to data allocated on the heap. It allows you to store data on the heap rather than the stack, enabling the storage of types with an unknown size at compile time (such as trait objects).
• dyn: A keyword in Rust used to indicate dynamic dispatch. It is used in conjunction with traits, signifying that, at runtime, the actual type will be known, allowing the invocation of methods defined in a specific trait.
• Trait: An abstract type that defines an interface of methods. By implementing a specific trait, a type can have associated behavior.

Therefore, Box<dyn Trait> represents an object allocated on the heap, implementing a specific trait, with the concrete type determined at runtime.

For example, suppose there is a trait Foo:

trait Foo {
     fn do_something(&self);
 }

You can create a Box<dyn Foo>, which can hold an instance of any type that implements the Foo trait, and call the do_something method at runtime:

trait Foo {
     fn do_something(&self);
 }
 ​
 struct MyStruct;
 ​
 impl Foo for MyStruct {
     fn do_something(&self) {
         println!("Doing something");
     }
 }
 ​
 fn main() {
     let my_box: Box<dyn Foo> = Box::new(MyStruct);
 ​
     my_box.do_something();
 }

In the above code:

• We define a trait called Foo, containing the signature of a do_something method. This trait describes an interface with specific behavior.
• We define a struct MyStruct and implement the do_something method for it, allowing MyStruct to have the methods defined in the Foo trait.
• In the main function, we create a smart pointer of type Box<dyn Foo>, pointing to a heap-allocated instance of a type that implements the Foo trait (in this case, MyStruct). This allows us to dynamically call methods from the Foo trait at runtime using this Box.
• We call my_box.do_something(), invoking the do_something method of the stored MyStruct instance in the Box, and it prints "Doing something." This demonstrates the dynamic dispatch feature of the dyn keyword and traits.