Introduction

Discover the latest breakthrough in Rust programming! The Rust Organization has unveiled plans to introduce a groundbreaking feature that will revolutionize the way developers work with trait functions. Prepare to harness the full potential of async-await functions within trait methods, opening new doors for asynchronous programming paradigms. In this article, we dive into the upcoming feature, its significance, and how it will empower developers to write more expressive, efficient, and flexible code within the realm of traits.

Overview

As per the latest blog report dated 3rd May 2023, Rust organisation has added Core support for "async functions in traits" as the MVP 1 target for 2023.

What are async functions?

In Rust, the async function is a feature of the language that allows you to write asynchronous code more conveniently and expressively. An async function is a function that can suspend its execution and resume at a later point in time without blocking the thread.

Here's an example of an async function in Rust:

async fn greet() {
    println!("Hello, world!");
}

The async keyword is used to mark a function as asynchronous. It indicates that the function can perform asynchronous operations and may need to suspend its execution while awaiting the completion of those operations.

When calling an async function, it returns a special type called a "future" (represented as impl Future<Output = T>), which represents an ongoing computation. The future can be awaited to pause the execution of the current function until the result is available.

The impl keyword is used to indicate that the type implementing the Future trait is not explicitly named. Instead, it is an implementation detail determined by the code. This allows for flexibility and abstraction, as different types can implement the Future trait to represent various asynchronous computations.

Here's an example of using await with an async function:

async fn get_data() -> String {
    // Simulating an asynchronous operation
    tokio::time::delay_for(Duration::from_secs(2)).await;
    "Data received!".to_string()
}

async fn print_data() {
    let data = get_data().await;
    println!("{}", data);
}

In the example above, the print_data function awaits the completion of the get_data function before continuing its execution. This allows you to write asynchronous code in a more sequential and readable manner.

To use async functions and await, you need to have an asynchronous runtime like Tokio or async-std configured in your project. These runtimes handle scheduling and executing asynchronous tasks efficiently.

"Explain Like I'm Five" Explanation of Async-await Functions.

Imagine you have a toy robot that can do different tasks, like walking, talking, and dancing. Normally, when the robot does something, it follows the instructions one by one and waits until it finishes before moving on to the next task.

But sometimes, some tasks take a long time to complete, like fetching a ball from the other side of the room. Instead of waiting idly, the robot can be clever and do other things while it waits for the ball. It can sing a song, do a little dance, or even tell a story!

In programming, async and await work are just like that clever robot. When a task takes a long time to complete, the program can use async to mark it as something that can be done in the background. Then, instead of waiting, the program can go and do other tasks. When the long task is finished, the program uses await to get the result and continue where it left off.

So, async and await help programs be more efficient by allowing them to do multiple things at once, just like the clever robot. It makes programs faster and more responsive, just like how the robot can entertain you with songs and dances while fetching the ball.

If you come from a Javascript background, you can see how similar is the async await in both Rust and Javascript

use tokio::time::{sleep, Duration};

async fn async_task() {
    println!("Starting async task in Rust...");
    sleep(Duration::from_secs(2)).await;
    println!("Async task completed in Rust!");
}

#[tokio::main]
async fn main() {
    println!("Before async task in Rust...");
    async_task().await;
    println!("After async task in Rust...");
}

function sleep(ms) {
    return new Promise((resolve) => setTimeout(resolve, ms));
}

async function asyncTask() {
    console.log("Starting async task in JavaScript...");
    await sleep(2000);
    console.log("Async task completed in JavaScript!");
}

console.log("Before async task in JavaScript...");
asyncTask().then(() => {
    console.log("After async task in JavaScript...");
});

What are Trait functions?

In Rust, trait functions, also known as associated functions or static functions, are functions defined within a trait that can be called without an instance of the implementing type. Unlike regular methods in traits that operate on an instance of the type, trait functions are associated with the trait itself rather than specific instances.

Here's an example that demonstrates the use of a trait function:

trait Shape {
    fn area() -> f64;
}

struct Rectangle {
    width: f64,
    height: f64,
}

impl Shape for Rectangle {
    fn area() -> f64 {
        2.0 * (self.width + self.height)
    }
}

fn main() {
    let rect = Rectangle {
        width: 5.0,
        height: 3.0,
    };

    let rect_area = Rectangle::area(); // Calling the trait function

    println!("Rectangle area: {}", rect_area);
}

In the example above, we define a trait called Shape with a trait function area(). The area() function does not take any parameters and returns a floating-point value representing the area of the shape.

The Rectangle struct implements the Shape trait and provides an implementation for the area() function. Note that since the trait function is not associated with a specific instance of the implementing type, it does not have access to the instance's fields and cannot use self or &self as a parameter.

In the given code, f64 refers to a specific data type in Rust called a 64-bit floating-point number. The letter "f" indicates that it is a floating-point number, and "64" represents the number of bits used to represent the number, determining its precision.

In Rust, the self parameter is a special keyword used in method definitions to refer to the instance of a struct or enum on which the method is being called. It allows methods to access and manipulate the data within that instance. The self parameter plays a crucial role in defining object-oriented behaviour in Rust.

In the main() function, we create an instance of Rectangle and call the area() function directly on the trait Shape using the Rectangle::area() syntax.

Trait functions are useful when you want to define behaviour that is associated with a trait but does not depend on the specific state of the implementing type. They provide a way to define common functionality for multiple types without requiring an instance of those types.

It's important to note that trait functions cannot be overridden by implementing types. Each implementing type will use the same implementation of the trait function defined in the trait itself.

"Explain Like I'm Five" Explanation of Trait Functions.

Imagine you have different kinds of animals, like dogs, cats, and birds. Each animal can make a sound, but they make different sounds. The dog barks the cat meows, and the bird chirps. Trait functions in Rust are like special abilities that each animal has.

A normal function is like a command that you give to a specific animal. For example, if you want the dog to bark, you tell it to "bark()" using a normal function. But the cat and bird don't understand the "bark()" command because they have different abilities.

Now, imagine we have a Trait called "MakeSound". This Trait tells us that each animal should have a special ability called "make_sound()". When we use this Trait, we can call the "make_sound()" function on any animal, and it will make its unique sound. So, no matter if it's a dog, cat, or bird, they all have their way of making a sound using the "make_sound()" function.

Trait functions help us define a set of abilities that different types of things can have. They make it easier for us to work with different objects consistently. Normal functions, on the other hand, are specific to one type of thing and can't be used with other types.

Can I use async-await in Trait functions?

Unfortunately, it is not possible to directly use the async keyword inside a trait function in Rust. Trait functions are synchronous and cannot suspend their execution or await asynchronous operations. However, there are workarounds you can use.

One option is to define a regular method in the trait and implement the asynchronous logic within that method. Another approach is to separate traits, where one trait contains regular methods and another trait specifically handles asynchronous operations with methods returning a Future.

1. Use a regular method: Instead of using a trait function, you can define a regular method in the trait that takes an &mut self or &self parameter and implement the asynchronous logic within the method body. The implementing type can then use async code inside the method implementation.

2. Combine traits and async functions: You can define a trait with regular methods and another trait specifically for asynchronous operations. The trait for asynchronous operations can include methods that return a Future. Implement both traits for the appropriate types and use the methods from the appropriate trait based on whether you need synchronous or asynchronous behaviour.

Here's an example illustrating these approaches:

trait SyncTrait {
    fn sync_method(&self);
}

trait AsyncTrait {
    async fn async_method(&self);
}

struct MyStruct {}

impl SyncTrait for MyStruct {
    fn sync_method(&self) {
        println!("Sync method called");
    }
}

impl AsyncTrait for MyStruct {
    async fn async_method(&self) {
        println!("Async method called");
    }
}

#[tokio::main]
async fn main() {
    let my_struct = MyStruct {};

    my_struct.sync_method();

    my_struct.async_method().await;
}

In the example above, MyStruct implements both SyncTrait and AsyncTrait. The sync_method is a regular method, while the async_method is an async method. By using separate traits, you can choose the appropriate method based on your needs.

Remember to include the necessary dependencies, such as the tokio crate, to enable async/await functionality.

Overall, while you cannot directly use the async keyword within a trait function, you can achieve similar functionality by combining traits and regular methods or using a separate trait for asynchronous operations.

Currently, this feature of using async-await in trait function is only available in Rust Nightly.

Rust Nightly refers to a distribution channel or version of the Rust programming language that provides access to the latest and experimental features before they are stabilized and included in the stable release. It allows developers to experiment with bleeding-edge features, language enhancements, and performance improvements that are not yet available in the stable version. Nightly builds can be installed alongside the stable Rust version, enabling developers to test and provide feedback on upcoming changes. However, due to the experimental nature of Nightly, it is not recommended for production use as it may contain bugs or breaking changes. Rust Nightly provides a valuable platform for early adopters and contributors to explore upcoming language advancements and contribute to the Rust ecosystem's development.

What will be the benefit of using async-await in Trait functions in Rust?

Using async-await in trait functions would bring several benefits in Rust:

1. Asynchronous Operations: Async-await allows for the execution of asynchronous operations, such as making API calls, reading from files, or waiting for events. By incorporating async-await into trait functions, you can define asynchronous behaviour within traits, enabling types implementing those traits to perform non-blocking, concurrent operations.

   With async-await in Trait functions, it becomes easier to work with things like files. You can tell them to load a file, and while they are loading it, you can do other things. Once the file is loaded, they will let you know so you can continue working with it.

2. Simplified Asynchronous Code: Async-await simplifies the syntax and structure of asynchronous code. It eliminates the need for complex callback mechanisms or manual handling of futures and promises. By incorporating async-await into trait functions, you can write asynchronous code in a more straightforward and readable manner, enhancing code maintainability and reducing the chance of errors.

3. Interoperability: Traits play a crucial role in Rust's type system, providing a way to define common behaviour across different types. By incorporating async-await into trait functions, you can define asynchronous behaviour that can be shared and implemented by various types. This promotes code reuse, modularity, and interoperability between different parts of your application.

4. Consistent API Design: Async-await in trait functions helps maintain consistency in the API design. When using traits to define behaviour, having the ability to incorporate async-await ensures that both synchronous and asynchronous implementations adhere to the same interface. This makes it easier to reason about the behaviour of types implementing the trait and promotes a cohesive and unified API.

5. Enhanced Concurrency: Async-await in Trait functions would enable concurrent execution of multiple asynchronous tasks. This can lead to improved performance and responsiveness, as tasks can be scheduled and executed independently, taking full advantage of available system resources.

By enabling async-await in trait functions, Rust would provide developers with more flexibility in expressing asynchronous behaviour, promoting code reusability, modularity, and better organization of asynchronous code within their applications.

Conclusion:

In conclusion, the potential implementation of async-await in Trait functions in Rust opens up exciting possibilities for developers. It would allow the seamless integration of asynchronous behaviour into traits, providing a clean and intuitive way to handle complex operations. By combining the power of traits with async-await, Rust developers would gain increased flexibility, improved code organization, and enhanced code reusability. Asynchronous Trait functions would enable efficient handling of I/O operations, network requests, and other asynchronous tasks within Rust's strong and safe concurrency model. This feature would unlock a new level of productivity and performance in Rust applications, making it an even more compelling choice for building robust and scalable systems. The future of async-await in Trait functions holds great promise, empowering developers to harness the full potential of Rust's concurrency capabilities.

Points/Terminologies you should Remember:

(You can skip this entire section, as it is made for those who have a knack for reading a summarised version for recapitulation)

Async and await are keywords used in asynchronous programming.

• Async: It marks a function as asynchronous, allowing it to run concurrently with other operations. It returns a promise or future object that represents an ongoing computation.

• Await: It is used within an async function to pause its execution until a promise is resolved. It allows writing asynchronous code in a more sequential and synchronous style, improving readability.

Benefits:

• Readability: Async/await makes asynchronous code easier to understand and follow, as it resembles traditional synchronous code structures.

• Error Handling: It simplifies error handling by using try-catch blocks around await expressions.

• Concurrency: Asynchronous operations enable concurrent execution, improving performance and responsiveness.

Trait Functions of Rust

• Trait functions in Rust are a way to define behaviour that can be shared across multiple types. They allow you to specify methods that must be implemented by any type that wants to adhere to a particular trait. Trait functions provide a common interface for different types, enabling code reuse and promoting modularity in Rust programs

  Benefits

• Code Reusability: Traits allow you to define common behaviour that can be implemented by different types. This promotes code reuse, as multiple types can implement the same trait and share the same functionality. It eliminates the need for duplicating code and leads to more concise and modular codebases.

• Abstraction: Traits provide a way to abstract over different types and treat them uniformly. You can define functions or methods that accept trait objects, allowing you to work with different types as long as they implement the required trait. This abstraction enables writing generic code that can operate on a variety of types without knowing their specific implementations.

• Polymorphism: Traits enable polymorphism in Rust. You can define functions or methods that accept trait objects or generic parameters bounded by a trait. This allows for dynamic dispatch, where the specific implementation of the trait is determined at runtime based on the actual type. Polymorphism enhances code flexibility and extensibility.

• Static Duck Typing: Traits provide a form of duck typing in Rust. If a type implements a trait, it can be treated as if it has the behaviour defined by that trait, regardless of its concrete type. This allows for flexible composition of functionality and decouples code from specific types.

• Trait Bounds and Generic Constraints: Traits can be used as bounds for generic types and functions, specifying the required behaviour or capabilities of the type parameters. This ensures that the generic code can only be instantiated with types that fulfil the specified trait bounds. Trait bounds enable compile-time guarantees and help prevent errors by enforcing constraints on generic code.

• Trait Implementations for External Types: Traits allow you to implement behaviour for external types that you don't own. This feature, called "trait impl for foreign types" or "orphan rules," allows you to extend the functionality of external types by implementing traits on them. This is particularly useful when working with external libraries or types defined in other modules.

• Code Organization and Documentation: Traits provide a structured way to organize and document behaviour. By defining traits, you can specify the expected functionality and behaviour for types implementing the trait. This enhances code readability, maintainability, and documentation, making it easier for other developers to understand and use your code.

Nightly Rust

• Nightly Rust refers to a specific distribution of the Rust programming language that provides access to the latest features, improvements, and experimental capabilities. It is a version of Rust that is continuously updated and contains cutting-edge developments that have not yet been stabilized for use in the stable release. Nightly Rust is designed for developers who want to explore new language features, contribute to the language's development, or experiment with bleeding-edge functionality.

  Nightly Rust allows developers to stay ahead of the curve and take advantage of the most recent advancements in the language.