如何简化Rust跨Tokio线程异步函数HashMap的初始化代码？

针对你需要批量注册20余个异步函数到共享HashMap的场景，可以通过以下几种方式简化冗余代码：

1. 抽离辅助函数简化包装逻辑 #

把重复的异步函数装箱逻辑抽成通用辅助函数，避免每次插入都写冗长的闭包和类型转换代码：

use once_cell::sync::Lazy;
use std::sync::{Arc, RwLock};
use std::collections::HashMap;
use std::future::Future;
use std::error::Error;
use std::pin::Pin;

type BoxedResult<T> = Result<T, Box<dyn Error + Send + Sync + 'static>>;
// 简化CalcFn的类型定义，减少重复书写
type CalcFn = Box<dyn Fn(i32, i32) -> Pin<Box<dyn Future<Output = BoxedResult<i32>> + Send + Sync>> + Send + Sync + 'static>;

// 通用包装函数：将符合签名的异步函数转为CalcFn类型
fn wrap_calc<F, Fut>(f: F) -> CalcFn
where
    F: Fn(i32, i32) -> Fut + Send + Sync + 'static,
    Fut: Future<Output = BoxedResult<i32>> + Send + Sync + 'static,
{
    Box::new(move |a, b| Box::pin(f(a, b)))
}

// 示例异步函数
async fn add(a: i32, b: i32) -> BoxedResult<i32> {
    Ok(a + b)
}

async fn sub(a: i32, b: i32) -> BoxedResult<i32> {
    Ok(a - b)
}

static MAPS: Lazy<Arc<RwLock<HashMap<&'static str, CalcFn>>>> = Lazy::new(|| {
    let mut map = HashMap::new();
    // 插入操作简化为一行
    map.insert("add", wrap_calc(add));
    map.insert("sub", wrap_calc(sub));
    // 后续添加新函数只需重复上述格式
    // map.insert("mul", wrap_calc(mul));
    // map.insert("div", wrap_calc(div));
    Arc::new(RwLock::new(map))
});

2. 使用宏批量注册函数 #

如果要注册大量函数，自定义宏可以让注册逻辑更紧凑，避免重复写insert语句：

// 承接上面的类型定义和辅助函数
macro_rules! register_calcs {
    ($map:expr, $($name:literal => $func:ident),* $(,)?) => {
        $(
            $map.insert($name, wrap_calc($func));
        )*
    };
}

static MAPS: Lazy<Arc<RwLock<HashMap<&'static str, CalcFn>>>> = Lazy::new(|| {
    let mut map = HashMap::new();
    // 批量注册所有函数，逗号分隔即可
    register_calcs! {
        map,
        "add" => add,
        "sub" => sub,
        "mul" => mul,
        "div" => div,
        // 继续添加更多函数...
    }
    Arc::new(RwLock::new(map))
});

3. 用迭代器collect构建HashMap #

将函数名与函数的配对做成数组，通过迭代器直接生成HashMap，代码直观简洁：

static MAPS: Lazy<Arc<RwLock<HashMap<&'static str, CalcFn>>>> = Lazy::new(|| {
    let calc_pairs = [
        ("add", wrap_calc(add)),
        ("sub", wrap_calc(sub)),
        ("mul", wrap_calc(mul)),
        ("div", wrap_calc(div)),
        // 批量添加更多键值对...
    ];
    let map: HashMap<_, _> = calc_pairs.into_iter().collect();
    Arc::new(RwLock::new(map))
});

以上方案都能大幅减少初始化代码的冗余，其中宏和迭代器方式最适合批量注册大量函数的场景，可根据偏好选择。

内容的提问来源于stack exchange，提问作者zhaokai xie