Deref and DerefMut

The traits std::ops::Deref^◹ and std::ops::DerefMut^◹ are used for explicit dereference operations (immutable or mutable), like:

// immutable dereference
println!("{}", *a);
 
// mutable dereference
*a = <something>;

If a type T implements Deref<Target=U> or DerefMut<Target=U> like this:

impl<T> Deref for Something<T> {
  type Target = T;
 
  fn deref(&self) -> &Self::Target {
    &self.value
  }
}
 
impl<T> DerefMut for Something<T> {
  type Target = T;
 
  fn deref_mut(&mut self) -> &mut Self::Target {
    &mut self.value
  }
}

• Any usage of *a in immutable contexts are equivalent to *Deref::deref(&a), and *DerefMut::deref_mut(&mut a) in mutable contexts.

• Any values of type &T will be coerced to values of type &U, and values of type &mut T will be coerced to values of type &mut U. Mutable references &mut T can also be coerced to immutable references &U, not the other way around, immutable references &T cannot be coerced to mutable references &mut U.

  For example, because type String implemented Deref<U=&str>^◹, we can pass a reference &String to any function that takes a &str:

  fn hello(name: &str) {
    ...
  }
   
  let name: String = String::from("Huy");
  hello(&name); // this works
  

• Type T will implicitly implement all the immutable (for Deref) and mutable (for DerefMut) methods of type U.

  For example, when creating a wrapped type using tuple struct (see previous post), you cannot access any methods of the inner type from the wrapped type:

  struct List(Vec<i32>);
   
  let list = List(vec![1, 2, 3]);
  println!("{}", list.last());
   
  // 1    | struct List(Vec<i32>);
  //      | ----------------------
  //      | |
  //      | method `last` not found for this
  //      | doesn't satisfy `List: Iterator`
  // ...
  // 5    |   println!("{}", list.last());
  //
  

  If you implement Deref or DerefMut for the wrapped type, it will implicitly implement all the immutable or mutable methods from the inner type:

  impl Deref for List {
    type Target = Vec<i32>;
    
    fn deref(&self) -> &Self::Target {
      &self.0
    }
  }
   
  println!("{}", list.first());
  // Output: 1
  

You can read more about Deref and DerefMut in The Rust Programming Language Book^◹, or in the documentation^◹.