Wie passe ich den Typ eines Ausdrucks in einem Rust-Makro an?

Question

Dies ist nur Pseudo-Code:

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

ich je nach Typ einen unterschiedlich erweitert Makro haben möchte, die ich an das Makro übergeben.

Dies ist, wie es das ist funktionieren würde in nicht in der Lage zu tun, 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 Makros. Makros operieren auf der syntaktischen Ebene, nicht auf der semantischen Ebene. Das bedeutet, obwohl der Compiler weiß, dass er einen Ausdruck (Syntax) hat, weiß er nicht, was der Wert des Ausdrucks (semantisch) in dem Moment ist, in dem das Makro expandiert wird.

Eine Abhilfe wäre die erwartete Art an das Makro weitergeben müssen:

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

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

Oder, einfacher gesagt, mehrere Makros definieren.

---

Wenn Sie statische (kompilieren Zeit) Versendung auf dem Typ eines Ausdrucks basierend tun möchten, können Sie Merkmale verwenden. Definieren Sie ein Merkmal mit den erforderlichen Methoden und implementieren Sie dann das Merkmal für die von Ihnen benötigten Typen. Sie können ein Merkmal für beliebigen Typ (einschließlich Grundelemente und Typen aus anderen Bibliotheken) implementieren, wenn der impl Block in der gleichen Kiste wie die Merkmaldefinition ist.

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); 
} 

Hinweis: Sie können auch $e.process() im Makro Körper schreiben könnte, aber dann das Makro möglicherweise eine unabhängige process Methode aufrufen.

Answer 2

Wie bereits erläutert, können Sie je nach Typ eines expr nicht unterschiedlich expandieren. Aber wie dieses Problem zu umgehen, können Sie die any module verwenden und versuchen, aus dem Any Charakterzug niedergeschlagenen:

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); 
} 

Displays:

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