如何在Rust中获取函数或闭包的参数元信息？

Rust作为静态编译型语言，无法像R、Python这类动态语言一样在运行时直接获取函数参数元信息，但可以通过以下几种编译期或代码生成的方式实现需求：

1. 自定义宏提取编译期信息 #

通过编写宏在编译阶段匹配函数的参数结构，获取参数数量与类型：

获取参数数量 #

macro_rules! count_args {
    ($func:expr) => {{
        fn _count_args<T>(_: fn(T)) -> usize { 1 }
        fn _count_args<T, U>(_: fn(T, U)) -> usize { 2 }
        fn _count_args<T, U, V>(_: fn(T, U, V)) -> usize { 3 }
        // 可根据需求扩展更多参数数量的匹配分支
        _count_args($func)
    }};
}

// 使用示例
fn foo(a: i32, b: &str) {}
fn bar(x: f64) {}

fn main() {
    println!("foo的参数数量: {}", count_args!(foo)); // 输出 2
    println!("bar的参数数量: {}", count_args!(bar)); // 输出 1
}

获取参数类型 #

结合std::any::type_name宏实现：

use std::any::type_name;

macro_rules! arg_types {
    ($func:expr) => {{
        fn _arg_types<T>(_: fn(T)) -> Vec<&'static str> {
            vec![type_name::<T>()]
        }
        fn _arg_types<T, U>(_: fn(T, U)) -> Vec<&'static str> {
            vec![type_name::<T>(), type_name::<U>()]
        }
        _arg_types($func)
    }};
}

// 使用示例
fn foo(a: i32, b: &str) {}

fn main() {
    println!("foo的参数类型: {:?}", arg_types!(foo)); // 输出 ["i32", "&str"]
}

这类宏的局限性是需要预先定义支持的参数数量上限，但能保证编译期的准确性。

2. 过程宏实现灵活元信息提取 #

如果需要支持任意数量的参数、自动生成元信息代码，过程宏是更优选择。它能在编译时解析函数的语法树，提取完整的参数结构：

use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, ItemFn};

#[proc_macro_attribute]
pub fn track_args(_attr: TokenStream, item: TokenStream) -> TokenStream {
    let input = parse_macro_input!(item as ItemFn);
    let fn_name = &input.sig.ident;
    let args = &input.sig.inputs;
    
    // 收集参数类型名称，处理self参数
    let arg_types: Vec<_> = args.iter().map(|arg| {
        match arg {
            syn::FnArg::Typed(pat_type) => {
                let ty = &pat_type.ty;
                quote!(type_name::<#ty>())
            }
            _ => quote!("self"),
        }
    }).collect();
    
    let arg_count = args.len();
    
    // 生成附加的元信息查询函数
    let expanded = quote! {
        #input
        
        impl #fn_name {
            pub fn arg_count() -> usize {
                #arg_count
            }
            
            pub fn arg_types() -> Vec<&'static str> {
                vec![#(#arg_types),*]
            }
        }
    };
    
    expanded.into()
}

使用时需要在Cargo.toml中添加proc-macro2、syn、quote等依赖，标记函数后即可通过函数名::arg_count()和函数名::arg_types()获取元信息。

3. 第三方库实现有限运行时反射 #

Rust标准库无内置运行时反射，但可以使用reflect、dyno等第三方库。不过这类库功能受限，需要额外代码标注，性能也不如编译期方案，仅在特殊场景下适用。

总结：简单场景用自定义宏即可，复杂需求优先选择过程宏，运行时反射谨慎使用。

内容的提问来源于stack exchange，提问作者ypa y yhm