Rust异步函数增强库async_fn使用指南

async_fn是一个为Rust异步编程提供高阶工具和语法糖的库，它简化了异步函数的编写和使用，提供了更强大的抽象能力。

主要特性

1. 提供更简洁的异步函数定义语法
2. 支持异步函数的高级组合
3. 提供更灵活的异步控制流
4. 简化错误处理

安装

在Cargo.toml中添加依赖：

[dependencies]
async_fn = "0.3"

基本用法

1. 定义异步函数

use async_fn::async_fn;

#[async_fn]
fn fetch_data(url: &str) -> Result<String, reqwest::Error> {
    reqwest::get(url).await?.text().await
}

2. 异步函数组合

use async_fn::{async_fn, compose};

#[async_fn]
async fn get_user_id(name: &str) -> Result<i32, String> {
    // 模拟数据库查询
    Ok(42)
}

#[async_fn]
async fn get_user_profile(id: i32) -> Result<String, String> {
    // 模拟获取用户资料
    Ok(format!("Profile for user {}", id))
}

// 组合两个异步函数
let get_profile_by_name = compose!(get_user_id, get_user_profile);

async {
    let profile = get_profile_by_name("Alice").await?;
    println!("{}", profile);
    Ok::<(), String>(())
};

3. 错误处理增强

use async_fn::{async_fn, try_with};

#[async_fn]
async fn process_data(data: &str) -> Result<String, String> {
    if data.is_empty() {
        Err("Empty data".to_string())
    } else {
        Ok(data.to_uppercase())
    }
}

async {
    let result = try_with!(
        process_data("hello"),
        process_data("world"),
        process_data("")
    );
    
    match result {
        Ok((r1, r2, r3)) => println!("Success: {}, {}, {:?}", r1, r2, r3),
        Err(e) => println!("Error: {}", e),
    }
};

4. 异步控制流

use async_fn::{async_fn, async_if};

#[async_fn]
async fn is_available() -> bool {
    // 检查资源是否可用
    true
}

#[async_fn]
async fn use_resource() -> String {
    // 使用资源
    "Resource used".to_string()
}

#[async_fn]
async fn wait_for_resource() -> String {
    // 等待资源
    "Waited for resource".to_string()
}

async {
    let result = async_if!(
        is_available().await => use_resource().await,
        _ => wait_for_resource().await
    );
    
    println!("{}", result);
};

高级特性

异步函数柯里化

use async_fn::{async_fn, curry};

#[async_fn]
async fn add(a: i32, b: i32) -> i32 {
    a + b
}

async {
    let add_five = curry!(add(5));
    let result = add_five(3).await; // 结果为8
    println!("5 + 3 = {}", result);
};

异步函数记忆化

use async_fn::{async_fn, memoize};
use std::time::Duration;

#[async_fn]
async fn expensive_computation(x: i32) -> i32 {
    tokio::time::sleep(Duration::from_secs(1)).await;
    x * x
}

async {
    let memoized = memoize!(expensive_computation);
    
    // 第一次调用会执行计算
    let result1 = memoized(2).await; // 耗时1秒
    // 第二次调用相同参数会返回缓存结果
    let result2 = memoized(2).await; // 立即返回
    
    assert_eq!(result1, result2);
};

完整示例

下面是一个完整的示例，展示了如何使用async_fn库的各种功能：

use async_fn::{async_fn, compose, try_with, async_if, curry, memoize};
use std::time::Duration;
use reqwest;

// 1. 定义异步函数
#[async_fn]
async fn fetch_user_data(user_id: i32) -> Result<String, reqwest::Error> {
    let url = format!("https://api.example.com/users/{}", user_id);
    reqwest::get(&url).await?.text().await
}

// 2. 异步函数组合示例
#[async_fn]
async fn get_user_id(username: &str) -> Result<i32, String> {
    // 模拟数据库查询
    Ok(match username {
        "alice" => 1,
        "bob" => 2,
        _ => return Err("User not found".to_string())
    })
}

#[async_fn]
async fn get_user_permissions(user_id: i32) -> Result<Vec<String>, String> {
    // 模拟权限查询
    Ok(vec!["read".to_string(), "write".to_string()])
}

// 3. 错误处理增强示例
#[async_fn]
async fn validate_input(input: &str) -> Result<String, String> {
    if input.len() < 5 {
        Err("Input too short".to_string())
    } else {
        Ok(input.to_string())
    }
}

// 4. 异步控制流示例
#[async_fn]
async fn check_service_status() -> bool {
    // 模拟服务状态检查
    true
}

#[async_fn]
async fn use_service() -> String {
    // 模拟服务使用
    "Service used successfully".to_string()
}

#[async_fn]
async fn fallback_service() -> String {
    // 模拟备用服务
    "Used fallback service".to_string()
}

// 5. 柯里化示例
#[async_fn]
async fn multiply(a: i32, b: i32) -> i32 {
    a * b
}

// 6. 记忆化示例
#[async_fn]
async fn calculate_fibonacci(n: u32) -> u64 {
    tokio::time::sleep(Duration::from_millis(100)).await;
    match n {
        0 => 0,
        1 => 1,
        _ => calculate_fibonacci(n-1).await + calculate_fibonacci(n-2).await
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 1. 基本异步函数使用
    let user_data = fetch_user_data(1).await?;
    println!("User data: {}", user_data);
    
    // 2. 函数组合
    let get_permissions_by_name = compose!(get_user_id, get_user_permissions);
    let permissions = get_permissions_by_name("alice").await?;
    println!("Permissions: {:?}", permissions);
    
    // 3. 错误处理
    let validation_result = try_with!(
        validate_input("hello"),
        validate_input("world"),
        validate_input("hi")
    );
    
    match validation_result {
        Ok((r1, r2, r3)) => println!("Valid inputs: {}, {}, {:?}", r1, r2, r3),
        Err(e) => println!("Validation error: {}", e),
    }
    
    // 4. 异步控制流
    let service_result = async_if!(
        check_service_status().await => use_service().await,
        _ => fallback_service().await
    );
    println!("Service result: {}", service_result);
    
    // 5. 柯里化
    let double = curry!(multiply(2));
    println!("2 * 5 = {}", double(5).await);
    
    // 6. 记忆化
    let memoized_fib = memoize!(calculate_fibonacci);
    
    // 第一次调用会计算
    let start = std::time::Instant::now();
    let fib1 = memoized_fib(10).await;
    println!("Fib(10) = {}, took {:?}", fib1, start.elapsed());
    
    // 第二次调用相同参数会立即返回缓存结果
    let start = std::time::Instant::now();
    let fib2 = memoized_fib(10).await;
    println!("Fib(10) = {}, took {:?}", fib2, start.elapsed());
    
    Ok(())
}

注意事项

1. async_fn宏会转换函数签名，确保在正确的位置使用
2. 组合函数时要注意错误类型的统一
3. 记忆化功能适用于纯函数或有相同输入总是返回相同结果的函数

async_fn库为Rust异步编程提供了更高级的抽象能力，可以显著减少样板代码，使异步逻辑更清晰易读。