Create sum of ones till N using macro in Rust

Question

I would like to create a macro for transforming count!(5) into 1+1+1+1+1. The final reason is to use count!(N) - 1 into a structure definition where N is a const generics.

macro_rules! count {
    (1) => {0};
    (2) => { 1 + count!(1)};
    ($n: tt) => { 1 + count!($n - 1)};
}

struct WindowIterator<I, Item, const N: usize> {
    iter: I,
    values: Box<[Item; count!(N) - 1 ]>,
    index: usize,
}

With this definition, I receive an error like no rules expected the token N .

How can I change my code for making it correct?

Your plan will not work since macros are expanded before any type deduction or template instantiation; that and macros only work via tokens, not values. However, I'm puzzled by the idea in the first place since your code compiles using N directly: playground. — kmdreko
– kmdreko, Commented Dec 4, 2021 at 22:01
updated the questions. I need to create an array with length N-1 — allevo
– allevo, Commented Dec 5, 2021 at 11:07

Jihyeon Kim · Accepted Answer · 2021-12-05 16:58:47Z

3

Sadly, it's not possible with current stable Rust. Current Rust support for const generics is MVP, and const generics with complex expressions are not supported in stable build.

However, it's possible with Rust nightly build.

#![feature(generic_const_exprs)]

struct WindowIterator<I, Item, const N: usize>
where
    [Item; N - 1]: Sized,
{
    iter: I,
    values: Box<[Item; N - 1]>,
    index: usize,
}

Rust Playground link of the example above

You can check out further details in this official Rust blog post about const generics.

edited Dec 5, 2021 at 16:58

answered Dec 5, 2021 at 9:18

Jihyeon Kim

1195 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

allevo Over a year ago

updated the questions. I need to create an array with length N-1

Chayim Friedman · Accepted Answer · 2021-12-05 11:39:04Z

Macro expansion works on raw tokens. If you follow the macro expansion process...

#![feature(log_syntax)]

macro_rules! count {
    (1) => {{
        log_syntax!(MatchOne count!(1));
        0
    }};
    (2) => {{
        log_syntax!(MatchTwo count!(2));
        0
    }};
    ($n:tt) => {{
        log_syntax!(MatchNumber count!($n));
        1 + count!($n - 1)
    }};
    ($($n:tt)*) => {{
        log_syntax!(MatchAny count!($($n)*));
    }};
}

Playground.

Outputs:

MatchNumber count! (5)
MatchAny count! (5 - 1)

The second invocation didn't get 4, but 5 - 1, the raw tokens.

What you want can be done with procedural macros, for example:

extern crate proc_macro;

use itertools::Itertools; // When std's intersperse() will be stable, can get rid of this.
use proc_macro::{Delimiter, Group, Literal, Punct, Spacing, TokenStream, TokenTree};

#[proc_macro]
pub fn count(number: TokenStream) -> TokenStream {
    let number = number.to_string().parse().expect("expected a number"); // A simple way to parse int literal without `syn`
    let result = if number == 0 {
        TokenTree::Literal(Literal::u64_unsuffixed(0))
    } else {
        TokenTree::Group(Group::new(
            Delimiter::None,
            std::iter::repeat(TokenTree::Literal(Literal::u64_unsuffixed(1)))
                .take(number)
                .intersperse(TokenTree::Punct(Punct::new('+', Spacing::Alone)))
                .collect(),
        ))
    };
    result.into()
}

However, this is probably not what you want.

Collectives™ on Stack Overflow

Create sum of ones till N using macro in Rust

2 Answers 2

1 Comment

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

1 Comment

Comments

Your Answer

Sign up or log in

Post as a guest

Related