Rust Random Topics - #002 "Unlock the Power of Compile-Time Calculations with Rust Macros!"

Discover how Rust's macro system effortlessly pre-computes sums at compile-time, streamlining your code for runtime efficiency—dive into the magic of { 0 $(+$a)* }!

The fragment { 0 $(+$a)* } from a Rust macro is all about compile-time expansion. At compile time, Rust takes this template and applies it to the arguments you've passed to the macro, expanding it into a complete expression that sums those arguments starting from 0. This is not something that happens at runtime; the final summing expression is fully determined before your program ever runs.

For a simple example, let's consider the macro being invoked as add_as!(1, 2, 3):

1. Starting Point: The macro starts with the template { 0 $(+$a)* }, which tells it to begin with 0.
2. Compile-time Expansion: During compilation, Rust sees the add_as!(1, 2, 3) call and starts expanding it using the provided template. The $(+$a)* part is where the magic happens. Rust understands it needs to repeat + $a for each argument you've provided (1, 2, 3 in this case). So, it replaces $(+$a)* with + 1 + 2 + 3.
3. Final Expansion: After the expansion, the original macro call add_as!(1, 2, 3) is fully expanded to the expression { 0 + 1 + 2 + 3 }. This is the summing operation that was constructed entirely at compile time.

Thus, by the time your program runs, the add_as! macro call has been replaced with a simple, hardcoded sum { 0 + 1 + 2 + 3 }, which evaluates to 6. This demonstrates how macros in Rust allow for powerful compile-time code generation and manipulation based on the inputs provided to them.