Counting length of repetition in macro

Question

I'm trying to implement a macro to allow MATLAB-esque matrix creation. I've got a basic working macro but I still have a long way to go.

I want to be able to enforce the right structure (same number of elements in each row) but I'm not sure how to do this within the macro. I think I want to enforce that each internal repetition has the same length - is this something I can do?

Here is my code so far:

pub struct Matrix<T> {
    pub cols: usize,
    pub rows: usize,
    pub data: Vec<T>
}

macro_rules! mat {
    ( $($( $x:expr ),*);* ) => {
        {
            let mut vec = Vec::new();
            let mut rows = 0;

            $(
                $(
                    vec.push($x);
                )*
                rows += 1;
            )*
            Matrix { cols : vec.len()/rows, rows: rows, data: vec}
        }
    };
}

It works but as you can see isn't very safe. It has no restrictions on the structure.

I want to do a lot more with this macro but I think this is a good start!

Update:

Here is some playground code for a crappy implementation I worked out. If anyone has any better suggestions please let me know! Otherwise I'll close this myself.

Answer 1

First, to quickly address the title of your question: see the Counting chapter in The Little Book of Rust Macros. To summarise: there is no direct way, you need to write a macro that expands to something you can count in regular code.

Now, to address your actual question: hoo boy.

It's not so much counting that you want, it's to fail at compile time if the sub-sequences have different lengths.

First of all, there's no clean way to trigger a compilation failure from a macro. You can trigger some other pre-existing error, but you can't control the actual error message.

Secondly, there's no easy way to do "variable" comparisons in macros at all. You can sometimes compare against a fixed token sequence, but you're not doing that here.

So it's doubly not-really-doable.

The simplest thing to do is check the lengths during construction at runtime, and return an error or panic if they don't match.

---

Is it actually impossible? I don't believe so. If you're willing to accept inscrutable error messages and a massive jump in complexity, you can check for length equality between two token sequences like so:

macro_rules! tts_equal_len {
    (($_lhs:tt $($lhs_tail:tt)*), ($_rhs:tt $($rhs_tail:tt)*)) => {
        tts_equal_len!(($($lhs_tail)*), ($($rhs_tail)*))
    };
    (($($_lhs_tail:tt)+), ()) => { do_something_bad!() };
    ((), ($($_rhs_tail:tt)+)) => { do_something_bad!() };
    ((), ()) => { do_something_good!() };
}

macro_rules! do_something_bad { () => { { println!("kaboom!") } } }
macro_rules! do_something_good { () => { { println!("no kaboom!") } } }

fn main() {
    tts_equal_len!((,,,), (,,,));
    tts_equal_len!((,,,), (,,));
    tts_equal_len!((,), (,,));
}

Again, the real problem is finding some way to fail at compile time such that the user will understand why compilation failed.

Answer 2

macro_rules! count {
    () => (0usize);
    ( $x:tt $($xs:tt)* ) => (1usize + count!($($xs)*));
}

macro_rules! mat {
    ( $( $x:expr ),* ) => { {
        let vec = vec![$($x),*];
        Matrix { cols : vec.len(), rows: 1, data: vec }
    } };
    ( $( $x0:expr ),* ; $($( $x:expr ),*);* ) => { {
        let mut _assert_width0 = [(); count!($($x0)*)];
        let mut vec = Vec::new();
        let rows = 1usize;
        let cols = count!($($x0)*);

        $( vec.push($x0); )*

        $(
            let rows = rows + 1usize;
            let _assert_width = [(); count!($($x)*)];
            _assert_width0 = _assert_width;
            $( vec.push($x); )*
        )*

        Matrix { cols : cols, rows: rows, data: vec }
    } }
}

playground

The count! macro expands to a constant expression that represents the number of arguments it got as input. It's just a helper for the mat! macro. If you need to count a lot of items and the compiler can't cope with it, see the Counting chapter in The Little Book of Rust Macros, which has more complex macros for counting.

My version of the macro uses dummy variables and assignments to verify that the width of all rows are the same. First off, I changed the macro's pattern to handle the first row separately from the subsequent rows. The first variable, _assert_width0, is initialized with an array of units ((), which makes the array take no memory), with the size of the array being the number of items in the first row. Then, _assert_width is also initialized with an array of units, with the size of the array being the number of items in each subsequent row. Then, _assert_width is assigned to _assert_width0. The magic here is that this line will raise a compiler error if the width of a row doesn't match the width of the first row, since the types of the array won't match (you might have e.g. [(); 3] and [(); 4]). The error isn't super clear if you don't know what's going on in the macro, though:

<anon>:38:24: 38:37 error: mismatched types:
 expected `[(); 3]`,
    found `[(); 4]`
(expected an array with a fixed size of 3 elements,
    found one with 4 elements) [E0308]
<anon>:38           _assert_width0 = _assert_width;
                                     ^~~~~~~~~~~~~
<anon>:47:13: 47:44 note: in this expansion of mat! (defined in <anon>)
<anon>:38:24: 38:37 help: see the detailed explanation for E0308