In Rust, an async function is a special type of function that is marked with the `async` keyword. It allows you to write asynchronous code that can perform non-blocking operations and interact with futures. Async functions are a key component of Rust's asynchronous programming model and are used to work with asynchronous computations.

Here are some important points to understand about async functions in Rust :

1. Asynchronous Execution : An async function is executed asynchronously, meaning it can pause its execution and resume later without blocking the thread. This allows the function to perform other tasks or wait for external events while waiting for futures to complete.

2. Suspension Points : Inside an async function, you can use the `await` keyword to suspend the function's execution until a future completes. When encountering an `await` expression, the function yields control back to the executor or runtime, allowing it to perform other tasks. Once the awaited future completes, the async function resumes its execution.

3. Future Return Type : An async function returns a future that represents the completion of its computation. The future's `Output` type corresponds to the type of the value that the async function eventually produces or the error it may encounter. The `Output` type is inferred by the Rust compiler based on the code inside the async function.

4. Asynchronous Workflow : Async functions enable you to write code that appears to be sequential and synchronous while executing asynchronously. You can use regular control flow constructs like loops, conditionals, and function calls within an async function, making it easier to reason about asynchronous code. Here's an example of an async function in Rust :

async fn fetch_data(url: &str) -> Result<String, reqwest::Error> {
    let response = reqwest::get(url).await?;
    response.text().await
}​

In this example :

* The `fetch_data` function is marked as `async`.
* Inside the function, two `await` expressions are used to wait for futures to complete: `reqwest::get(url).await` and `response.text().await`.
* The function returns a `Result<String, reqwest::Error>` future representing the eventual result of the computation.

To execute an async function, you typically need an executor or a runtime that drives the execution of futures. Libraries like Tokio or async-std provide the necessary runtime support to execute async functions and manage the scheduling of tasks.

Async functions, combined with futures and the Rust async ecosystem, offer a powerful and efficient way to handle asynchronous operations and build high-performance, non-blocking applications in Rust.