How do I match the type of an expression in a Rust macro?

by

Rust macros aren’t able to do that. Macros operate at the syntactic level, not at the semantic level. That means that although the compiler knows it has an expression (syntax), it doesn’t know what the type of the expression’s value (semantic) is at the moment the macro is expanded.

A workaround would be to pass the expected type to the macro:

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

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

Or, more simply, define multiple macros.

If you want to do static (compile-time) dispatch based on the type of an expression, you can use traits. Define a trait with the necessary methods, then implement the trait for the types you need. You can implement a trait for any type (including primitives and types from other libraries) if the impl block is in the same crate as the trait definition.

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

Note: You could also write $e.process() in the macro’s body, but then the macro might call an unrelated process method.

More Related Contents:

  1. Is it possible to declare variables procedurally using Rust macros?
  2. Can a Rust macro create new identifiers?
  3. Generating documentation in macros
  4. How to prefix/suffix identifiers within a macro? [duplicate]
  5. Is there a way to count with macros?
  6. Can macros match against constant arguments instead of literals?
  7. How to allow optional trailing commas in macros?
  8. How to embed a Rust macro variable into documentation?
  9. How to enforce that a type implements a trait at compile time?
  10. What makes Lisp macros so special?
  11. Macros in Swift?
  12. How can I generate unique values in the C preprocessor?
  13. Variadic recursive preprocessor macros – is it possible?
  14. How do I show the value of a #define at compile-time?
  15. How to write macro for Notepad++?
  16. How to auto execute a macro when opening a Powerpoint presentation?
  17. Mathematica: Unevaluated vs Defer vs Hold vs HoldForm vs HoldAllComplete vs etc etc
  18. Can I convert a string to enum without macros in Rust?
  19. Is there a way to get the field names of a struct in a macro?
  20. Why do try!() and ? not compile when used in a function that doesn’t return Option or Result?
  21. When is it appropriate to use an associated type versus a generic type?
  22. Split a module across several files
  23. How to disable unused code warnings in Rust?
  24. What is the syntax to match on a reference to an enum?
  25. Why can’t I return an &str value generated from a String?
  26. is it possible to filter on a vector in-place?
  27. What does the question mark mean in a type parameter bound?
  28. What is the prelude?
  29. Why does Valgrind not detect a memory leak in a Rust program using nightly 1.29.0?
  30. What is the null pointer optimization in Rust?

Leave a Comment