DEV Community: artech-git

Rust Deref Coercion 🦀 simplifying Borrowing and Dereferencing

artech-git — Wed, 17 May 2023 13:27:32 +0000

If you are a newbie or a experienced rust developer you must have come across a special term which represent a amazing features of which is deref coercion

Introduction:

Rust is a powerful and expressive programming language known for its strong emphasis on memory safety and ownership. One of the language's notable features is deref coercion, which allows Rust to automatically convert types through dereference operations. Deref coercion plays a vital role in simplifying borrowing and dereferencing, making code more concise and readable. In this article, we will explore the concept of deref coercion, its benefits, and how it contributes to Rust's safety guarantees.

Understanding Deref and Borrowing:

Before diving into deref coercion, it's essential to understand the concepts of borrowing and dereferencing in Rust.

Borrowing is a mechanism that allows temporary access to a value without taking ownership. A borrow can be of two types only

mutable borrow &val
non mutable borrow &mut val

In Rust, we can borrow a value using references denoted by the & symbol.

let mut val = 32;
let b = &val; // create a borrow of `val`

On the other hand, dereferencing * refers to the process of accessing the value behind a reference or a pointer.

let b = &val; 
let mut k = *b; //original value read is "32" here

Deref Coercion

Deref coercion is Rust's ability to automatically apply dereference operations when calling methods or functions.

It allows the programmer to write code that operates on a value directly, even if they only have a reference to it.
Deref coercion is achieved through the Deref trait present std crate for the types which implement it

fn call_me(val: &str) ... 

let mut boxed_type: Box<String> = Box::new("meow".to_string());

call_me(&boxed_type);

observe the boxed_type is a different type altogther yet we allowed to pass it as & to the method we are making the call for

since Box type implement Deref trait which allows it to return the type of generic directly from the deref_target item type

and since &String type implements the Deref<Target = str> we reach the &str directly

The compiler automatically inserts the necessary dereference operations, simplifying the code and reducing the need for explicit dereference syntax.

Deref Trait and Operator Overloading

At the heart of deref coercion is the Deref trait. This trait is defined in the Rust standard library and allows types to customize the behavior of the dereference operator (*). By implementing the Deref trait for a type, we provide the necessary instructions on how to dereference instances of that type.

Deref Coercion Rules:

Rust follows specific rules for deref coercion to ensure type safety. When the compiler encounters a type mismatch, it tries to find a series of Deref trait implementations that can bridge the gap between the expected and actual types. The rules for deref coercion are as follows:

If the type T implements the Deref trait to produce type U, and U implements the Deref trait to produce type V, Rust will automatically dereference T to get a value of type V when needed.

Deref coercion only applies to cases where the target type is a reference (&T). It does not work for owned types like Box or Vec. The goal is to avoid unnecessary cloning or moving of values.

Benefits of Deref Coercion:

Deref coercion brings several benefits to Rust programming:

Improved Readability: By allowing implicit dereferencing, deref coercion simplifies code by reducing the need for explicit dereference operations. This leads to more readable and concise code.

Reduced Boilerplate: Deref coercion eliminates the need for manually writing dereference syntax when working with types that implement the Deref trait. This reduces unnecessary verbosity and boilerplate code.

Flexibility and Interoperability: Deref coercion enables seamless interoperability between types that can be dereferenced. It allows different types to be used interchangeably, as long as they implement the necessary Deref trait.

Safety and Type Checking: Rust's strong type system ensures that deref coercion follows a set of rules, preventing unsafe conversions. The compiler performs static type checking to ensure that the necessary Deref trait implementations exist and are valid.

Conclusion:

Deref coercion is a powerful feature in Rust that simplifies borrowing and dereferencing. By leveraging the Deref trait and compiler rules, Rust can automatically apply dereference operations when needed, reducing code verbosity and improving code readability.

Creating a heterogenous type for holding several objects of different types in RUST

artech-git — Tue, 05 Jul 2022 00:50:10 +0000

Type available within Rust supports composition of homogenous types, these are availabe in types such as

Vec<T>;  // an vector
[T;N];   // an array
();      // tuple

which can be used depending on various scenarios required ,
though you can use it as a heterogenous type but it is naturally constrained by the Sized trait which is applied to it during compile time which constrain us to further use it dynamically.

The key thing to note here is we can segregate our types based upon some common relation we can derive from them this will be the key idea to follow along towards achieving so

but when it comes to supporting the heterogenous types in rust things get little bit tricky here, to compose a type which can accommodate the objects from several types available using dyn trait which points the object in vtable which is behind a pointer
you can read here,

we want our type to be resizable during runtime therefore I will choose to go with Vec<T> type which can hold our objects

since whichever types applies this trait can directly reference a object using two techniques

1) using a reference to the object

   Vec<&dyn yourTrait>;

2) placing the object behind a Box smart pointer

  Vec<Box<dyn youTrait>>;

let's say the name of your trait is Foo and it declares one method to be implement

trait Foo {
  fn call(&self);
}

now we will create some random types which will implement this
are as follows
(for the sake of simplicity I have defined a tuple struct here but your type can be much more complicated than this ... as long as you implement the trait you should be fine)

#[derive(Debug)]
struct A(i32); 
impl Foo for A {
    fn call(&self) {
        println!("type A: {:?}", self.0);
    }
}

#[derive(Debug)]
struct B(i32); 
impl Foo for B {
    fn call(&self) {
        println!("type B: {:?}", self.0);
    }
}

#[derive(Debug)]
struct C(i32); 
impl Foo for C {
    fn call(&self) {
        println!("type C: {:?}", self.0);
    }
}

here you will observe one strange thing which is all the types implement the same exact definition of the trait methods but this can be different depending upon the operations you wanna do with that type.

now lets begin declaring a type which can simply hold them
according the first method

*1) using the direct reference to the object *

one important thing to note here is, the reference you gonna provide for your types will either be mutable or immutable only !

which simply mean, it applies to all the trait objects uniformly and u can't have some trait objects passed on as mutably and others as immutably.

fn main() {
     //some random trait objects declared
    let a = &A(43); 
    let b = &B(73); 
    let c = &C(95); 

     // now we will compose our homogenous type based on the previously types
    let objs: Vec<&dyn Foo> = vec![a, b, c];

    for I in objs.iter() {
       I.call(); 
    }
}

since our objects a, b, c holds a reference to the types A, B, C respectively we can pass them directly here to construct our homogenous type out of them
output :

type A: 43
type B: 73
type C: 95

2) Using Box smart pointer

now we will try out another interesting method, where we will place our objects behind a Box smart pointer in this case you don't have to worry about initializing your traits objects during compile itself, instead you will place them behind a pointer pointing to the memory location on heap
since in this technique the rules of borrow doesn't apply there it is quite convinence to work with
also the plus side is our objects can be init. during runtime which is a added advantage



fn main() {

    //here we place our objects behind a box pointer 
    let a = Box::new(A(43)); 
    let b = Box::new(B(73)); 
    let c = Box::new(C(95)); 

    //our type hold a boxed trait object as type to accept
    let mut objs: Vec<Box<dyn Foo>> = vec![a,b,c] ;

    for I in objs.iter() {
        I.call();
    }

}

here the output will be exactly same as the previous one but with more features of box pointer:

type A: 43
type B: 73
type C: 95

there you .. go congratulations you successfully learned how to create a new type >>

Thank you 😊 so much for reading till here 🥂🎉🎊!

if you have any comments, suggestion's, doubt or advice feel free to post in comment section