async-recursion macro

Procedural macro for recursive async functions.

Documentation
Cargo package: async-recursion

Motivation

Consider the following recursive implementation of the fibonacci numbers:

async fn fib(n : u32) -> u64 {
   match n {
       0     => panic!("zero is not a valid argument to fib()!"),
       1 | 2 => 1,
       3     => 2,
       _ => fib(n-1).await + fib(n-2).await
   }
}

The compiler helpfully tells us that:

error[E0733]: recursion in an `async fn` requires boxing
--> src/main.rs:1:26
  |
1 | async fn fib(n : u32) -> u64 {
  |                          ^^^ recursive `async fn`
  |
 = note: a recursive `async fn` must be rewritten to return a boxed `dyn Future`.

This crate provides an attribute macro to automatically convert an async function to one returning a boxed Future.

Example

use async_recursion::async_recursion;

#[async_recursion]
async fn fib(n : u32) -> u64 {
   match n {
       0     => panic!("zero is not a valid argument to fib()!"),
       1 | 2 => 1,
       3     => 2,
       _ => fib(n-1).await + fib(n-2).await
   }
}

?Send Option

By default the returned future has a Send bound to make sure that it can be sent between threads. If this is not desired you can mark that you would like that that bound to be left out like so:

#[async_recursion(?Send)]
async fn example() {}

In other words, #[async_recursion] modifies your function to return a BoxFuture and #[async_recursion(?Send)] modifies your function to return a LocalBoxFuture.

Installation

Add this to your Cargo.toml:

[dependencies]
async-recursion = "0.2"

License

Licensed under either of