Início / coding / Perguntas / 79557985
Accepted
MaPo
Asked: 2025-04-06 16:50:11 +0800 CST

Enumeração dentro de macro em Rust

  • 772

Eu tenho o seguinte código de ferrugem

use std::any::Any;
use std::rc::Rc;

fn main() {
    let mut variables = Vec::<Rc<dyn Any>>::new();
    variables.push(Rc::new(1_i32));
    variables.push(Rc::new(false));
    variables.push(Rc::new(4.53_f64));

    let integer: i32 = *variables[0].clone().downcast::<i32>().unwrap();
    let boolean: bool = *variables[1].clone().downcast::<bool>().unwrap();
    let floating: f64 = *variables[2].clone().downcast::<f64>().unwrap();

    let my_goal: (i32, bool, f64) = (integer, boolean, floating)

    println!("{:?}", my_goal);

que eu quero automatizar usando uma macro. ( Eu sei que isso não é o ideal, mas isso é apenas um MWE para fazer uma pergunta sobre macros )

Em particular, quero criar uma tupla que faça downcasting Anypara tipos fornecidos

Minha primeira tentativa é:

macro_rules! my_macro {
    ($vector:ident; $($type:ty),*) => {
        // ($($type),*)
        //println!("{:?}", $vector);
        //$(println!("{:?}", stringify!($type));)*
        let idx = 0;
        ($(
                *$vector[0].clone().downcast::<$type>().unwrap()
        ),*)
    };
}

que está errado por causa do 0hardcoded. Eu tentei várias maneiras de declarar uma variável e incrementá-la ao longo da macro, mas elas falharam. Como posso fazer?

generics

1 respostas

  1. Best Answer

    Tenho certeza de que você falhou em declarar a variável porque usou apenas um único conjunto de chaves quando, na verdade, seriam necessárias duas dentro da macro, depois da seta grande .

    Suponho que esta seja a macro que você procura:

    macro_rules! tuple_downcast {
    ($vector:ident; ($($type:ty),*)) => {{
        let mut iter = $vector.into_iter();
        (
            $(
                *iter.next()
                    .expect("The vector contains less elements than the type tuple.")
                    .clone()
                    .downcast::<$type>()
                    .expect("The value can not be downcasted to the specified type."),
            )*
        )
    }};
}

    você pode usar assim:

    use std::any::Any;
use std::rc::Rc;

macro_rules! tuple_downcast {
    ($vector:ident; ($($type:ty),*)) => {{
        let mut iter = $vector.into_iter();
        (
            $(
                *iter.next()
                    .expect("The vector contains less elements than the type tuple.")
                    .clone()
                    .downcast::<$type>()
                    .expect("The value can not be downcasted to the specified type."),
            )*
        )
    }};
}

fn main() {
    let mut variables = Vec::<Rc<dyn Any>>::new();
    variables.push(Rc::new(1_i32));
    variables.push(Rc::new(false));
    variables.push(Rc::new(4.53_f64));

    let integer: i32 = *variables[0].clone().downcast::<i32>().unwrap();
    let boolean: bool = *variables[1].clone().downcast::<bool>().unwrap();
    let floating: f64 = *variables[2].clone().downcast::<f64>().unwrap();

    let my_goal: (i32, bool, f64) = (integer, boolean, floating);

    println!("{:?}", my_goal);

    let mut variables = Vec::<Rc<dyn Any>>::new();
    variables.push(Rc::new(1_i32));
    variables.push(Rc::new(false));
    variables.push(Rc::new(4.53_f64));

    let my_goal = tuple_downcast!(variables; (i32, bool, f64));

    println!("{:?}", my_goal);
}

    O que resulta na seguinte saída:

    (1, false, 4.53)
(1, false, 4.53)

    Alternativamente, se você realmente deseja usar um índice para acessar os elementos:

    macro_rules! tuple_downcast {
    ($vector:ident; ($($type:ty),*)) => {{
        let mut idx = 0;
        (
            $({
                let value = *$vector[idx].clone()
                    .downcast::<$type>()
                    .unwrap();
                idx += 1;

                value
            }),*
        )
    }};
}
    • 1

relate perguntas