Is there a way to count with macros?

by

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 into procedural macros/compiler plugins (which as of 1.4 are unstable, and a bit harder to write).

Edit: There are probably better ways of implementing this, but I’ve spent long enough on this for today, so here goes. repeat!, a macro that actually duplicates a block of code a number of times:

main.rs

#![feature(plugin)]
#![plugin(repeat)]

fn main() {
    let mut n = 0;
    repeat!{ 4 {
        println!("hello {}", n);
        n += 1;
    }};
}

lib.rs

#![feature(plugin_registrar, rustc_private)]

extern crate syntax;
extern crate rustc;

use syntax::codemap::Span;
use syntax::ast::TokenTree;
use syntax::ext::base::{ExtCtxt, MacResult, MacEager, DummyResult};
use rustc::plugin::Registry;
use syntax::util::small_vector::SmallVector;
use syntax::ast::Lit_;
use std::error::Error;

fn expand_repeat(cx: &mut ExtCtxt, sp: Span, tts: &[TokenTree]) -> Box<MacResult + 'static> {
    let mut parser = cx.new_parser_from_tts(tts);
    let times = match parser.parse_lit() {
        Ok(lit) => match lit.node {
            Lit_::LitInt(n, _) => n,
            _ => {
                cx.span_err(lit.span, "Expected literal integer");
                return DummyResult::any(sp);
            }
        },
        Err(e) => {
            cx.span_err(sp, e.description());
            return DummyResult::any(sp);
        }
    };
    let res = parser.parse_block();

    match res {
        Ok(block) => {
            let mut stmts = SmallVector::many(block.stmts.clone());
            for _ in 1..times {
                let rep_stmts = SmallVector::many(block.stmts.clone());
                stmts.push_all(rep_stmts);
            }
            MacEager::stmts(stmts)
        }
        Err(e) => {
            cx.span_err(sp, e.description());
            DummyResult::any(sp)
        }
    }
}

#[plugin_registrar]
pub fn plugin_registrar(reg: &mut Registry) {
    reg.register_macro("repeat", expand_repeat);
}

added to Cargo.toml

[lib]
name = "repeat"
plugin = true

Note that if we really don’t want to do looping, but expanding at compile-time, we have to do things like requiring literal numbers. After all, we are not able to evaluate variables and function calls that reference other parts of the program at compile time.

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. How do I match the type of an expression in a Rust macro?
  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. How do I see the expanded macro code that’s causing my compile error?
  11. How do I use a macro across module files?
  12. What makes Lisp macros so special?
  13. Macros in Swift?
  14. How can I generate unique values in the C preprocessor?
  15. Variadic recursive preprocessor macros – is it possible?
  16. How do I show the value of a #define at compile-time?
  17. How to write macro for Notepad++?
  18. How to auto execute a macro when opening a Powerpoint presentation?
  19. Mathematica: Unevaluated vs Defer vs Hold vs HoldForm vs HoldAllComplete vs etc etc
  20. Can I convert a string to enum without macros in Rust?
  21. Is there a way to get the field names of a struct in a macro?
  22. Why does my string not match when reading user input from stdin?
  23. Can I do type introspection with trait objects and then downcast it?
  24. How can I have a collection of objects that differ by their associated type?
  25. Why doesn’t println! work in Rust unit tests?
  26. Why do I get “type annotations needed” when using Iterator::collect?
  27. How can I create enums with constant values in Rust?
  28. Creating a method definition tree from a method symbol and a body
  29. Can’t implement a trait I don’t own for all types that implement a trait I do own
  30. Lazy sequence generation in Rust

Leave a Comment