Question

这只是伪代码：

macro_rules! attribute {
    $e: expr<f32> => { /* magical float stuff */ };
    $e: expr<i64> => { /* mystical int stuff */ };
};

我希望有一个不同的扩展宏，具体取决于我传递给宏的类型。

这就是它在C ++中的工作方式

template <typename T>
struct Attribute{ void operator(T)() {} };

template <>
struct Attribute<float> {
    void operator(float)(float) { /* magical float stuff */ }
};

template <>
struct Attribute<long> {
    void operator()(long) { /* mystical int stuff */ }
}

Answer 1

Rust宏无法做到这一点。宏在语法层面运行，而不是在语义层面运行。这意味着虽然编译器知道它有一个表达式（语法），但它不知道宏扩展时表达式的值（语义）是什么类型。

解决方法是将预期类型传递给宏：

macro_rules! attribute {
    ($e:expr, f32) => { /* magical float stuff */ };
    ($e:expr, i64) => { /* mystical int stuff */ };
}

fn main() {
    attribute!(2 + 2, i64);
}

或者，更简单地说，定义多个宏。

如果要根据表达式的类型执行静态（编译时）分派，可以使用特征。使用必要的方法定义特征，然后为您需要的类型实现特征。如果impl块与特征定义位于同一个包中，则可以为任何类型（包括其他库中的基元和类型）实现特征。

trait Attribute {
    fn process(&self);
}

impl Attribute for f32 {
    fn process(&self) { /* TODO */ }
}

impl Attribute for i64 {
    fn process(&self) { /* TODO */ }
}

macro_rules! attribute {
    ($e:expr) => { Attribute::process(&$e) };
}

fn main() {
    attribute!(2 + 2);
}

注意：您也可以在宏的主体中编写$e.process()，但宏可能会调用不相关的process方法。

Answer 2

如前所述，根据expr的类型，您无法进行不同的扩展。但作为解决方法，您可以使用any module并尝试从Any特征向下转发：

use std::any::Any;

macro_rules! attribute {
    ( $e:expr ) => {
        if let Some(f) = (&$e as &Any).downcast_ref::<f32>() {
            println!("`{}` is f32.", f);
        } else if let Some(f) = (&$e as &Any).downcast_ref::<f64>() {
            println!("`{}` is f64.", f);
        } else {
            println!("I dunno what is `{:?}` :(", $e);
        }
    };
}

fn main() {
    attribute!(0f32);
    attribute!(0f64);
    attribute!(0);
}

显示器：

`0` is f32.
`0` is f64.
I dunno what is `0` :(

Answer 3

虽然这里的所有答案都是正确的，但我想提供一个更类似于您的 C++ 版本的答案。 Rust 提供了自己版本的模板、泛型，它们的使用方式与使用模板的方式相同。因此，要为某些类型定义结构并实现函数：

struct Attribute<T> {
    value: T,
}

impl Attribute<u32> {
    fn call(&self) {
        println!("{} is a u32", self.value);
    }
}

impl Attribute<f64> {
    fn call(&self) {
        println!("{} is a f64", self.value);
    }
}

impl Attribute<String> {
    fn call(&self) {
        println!("{} is a string", self.value);
    }
}

我们会这样使用它：

fn main() {
    let a = Attribute{
        value: 5_u32
    };


    a.call();
}

或者简单地像这样：

Attribute{value: 6.5}.call()

遗憾的是，Rust 在其稳定版本中没有提供 () 运算符重载。您仍然可以定义一个宏来完成这项工作：

macro_rules! attribute {
    ( $e:expr ) => {
        Attribute{value: $e}.call(); 
    };
}

并使用它：

attribute!("Hello World!".to_string());

我建议使用 this answer 中显示的基于特征的方法，因为它不使用结构，而是使用特征，这被认为是更好的做法。这个答案在许多情况下可能仍然有帮助。

如何匹配Rust宏中表达式的类型？

3 个答案: