Make the comma optional As DK. points out, the trailing comma can be made optional. Rust 1.32 You can use the ? macro repeater to write this and disallow multiple trailing commas: ($Name:ident { $($Variant:ident),* $(,)? }) => { // ^^^^^ Previous versions This allows multiple trailing commas: ($Name:ident { $($Variant:ident),* $(,)* }) => { … Read more
No. Macros operate on the Abstract Syntax Tree, so they reason at the syntactic level: they reason about tokens and their spelling. For example: fn main() { let v = 3; } In this case, the AST will look something like: fn main \_ let-binding v \_ literal 3 If you ask a macro whether … Read more
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 … Read more
While the ordinary macro system does not enable you to repeat the macro expansion many times, there is no problem with using a for loop in the macro: macro_rules! many_greetings { ($times:expr) => {{ for _ in 0..$times { println!(“Hello”); } }}; } If you really need to repeat the macro, you have to look … Read more
It’s possible to write a macro that evaluates to the number of arguments it’s called with. (I couldn’t find a link to the place where I first saw it.) So you could write MAX_OF_N() that would work as you’d like, but you’d still need all the numbered macros up until some limit: #define MAX_OF_1(a) (a) … Read more
I know that this is a long time after the original query, but this may still be useful. This can be done in GCC using the stringify operator “#”, but it requires two stages. #define XSTR(x) STR(x) #define STR(x) #x The value of a macro can then be displayed with: #pragma message “The value of … Read more
Currently this is not supported in stable. However there is a feature in nightly called concat_idents: concat_idents!(my_test_, $id) See Rust docs Issue Update: it seems there aren’t near-term plans to add this into stable releases, see issue.
To give the short answer, macros are used for defining language syntax extensions to Common Lisp or Domain Specific Languages (DSLs). These languages are embedded right into the existing Lisp code. Now, the DSLs can have syntax similar to Lisp (like Peter Norvig’s Prolog Interpreter for Common Lisp) or completely different (e.g. Infix Notation Math … Read more
If you’re using GCC or MSVC, there is __COUNTER__. Other than that, you could do something vomit-worthy, like: #ifndef USED_1 #define USED_1 1 #else #ifndef USED_2 #define USED_2 2 /* many many more */ #endif #endif
In this case you should add a default value for the “macro” parameters. Swift 2.2 and higher func log(message: String, function: String = #function, file: String = #file, line: Int = #line) { print(“Message \”\(message)\” (File: \(file), Function: \(function), Line: \(line))”) } log(“Some message”) Swift 2.1 and lower func log(message: String, function: String = __FUNCTION__, … Read more