Rust Tutorial : Smart Pointers
from tutorialspoint.com

Description
Rust allocates everything on the stack by default
can store things on the heap by wrapping them in smart pointers like Box types like Vec and String implicitly help heap allocation
smart pointers implement traits
these traits of the smart pointers differentiate them from an ordinary struct

Trait Package Description
Deref std::ops::Deref used for immutable dereferencing operations, like *v.
Drop std::ops::Drop used to run some code when a value goes out of scope
sometimes called a destructor
Box
the Box smart pointer also called a box allows storing data on the heap rather than the stack
the stack contains the pointer to the heap data
a Box does not have performance overhead other than storing their data on the heap
example use a box to store an i32 value on the heap 
fn main() {
   let var_i32 = 5; 
   //stack
   let b = Box::new(var_i32); 
   //heap
   println!("b = {}", b);
}
to access a value pointed by a variable, use dereferencing
the * is used as a dereference operator
example showing how to use dereference with Box 
fn main() {
   let x = 5; 
   // value type variable
   let y = Box::new(x); 
   // y points to a new value 5 in the heap
   println!("{}",5==x);
   // dereferencing y
   println!("{}",5==*y); 
}
variable x is a value-type with the value 5
the expression 5==x will return true
variable y points to the heap
to access the value in heap, need to dereference using *y
the expression 5==*y returns true

Deref Trait
the Deref trait requires implementing one method named deref
method borrows self and returns a reference to the inner data
example creates a structure MyBox, which is a generic type
implements the trait Deref
trait helps access heap values wrapped by y using *y 
use std::ops::Deref;
struct MyBox<T>(T);
impl<T> MyBox<T> { 
   // Generic structure with static method new
   fn new(x:T)-> MyBox<T> {
      MyBox(x)
   }
}
impl<T> Deref for MyBox<T> {
   type Target = T;
   fn deref(&self) -> &T {
      &self.0 //returns data
   }
}
fn main() {
   let x = 5;
   let y = MyBox::new(x); 
   // calling static method
   
   println!("5==x is {}",5==x);
   println!("5==*y is {}",5==*y); 
   // dereferencing y
   println!("x==*y is {}",x==*y);
   // dereferencing y
}
output 
5==x is true
5==*y is true
x==*y is true
Drop Trait
the Drop trait contains the drop() method
method is called when a structure that implemented this trait goes out of scope
in Rust can achieve automatic memory deallocation using Drop trait
in example the drop method will be called twice as two objects are created in the heap 
use std::ops::Deref;

struct MyBox<T>(T);
impl<T> MyBox<T> {
   fn new(x:T)->MyBox<T>{
      MyBox(x)
   }
}
impl<T> Deref for MyBox<T> {
   type Target = T;
   fn deref(&self) -> &T {
      &self.0
   }
}
impl<T> Drop for MyBox<T>{
   fn drop(&mut self){
      println!("dropping MyBox object from memory ");
   }
}
fn main() {
   let x = 50;
   MyBox::new(x);
   MyBox::new("Hello");
}
index