Macro to run a macro over each tuple type

[joshtriplett]

In the course of implementing the Bounded trait for tuples (rust-num/num#89), I implemented a generic macro that runs the macro passed as its argument over every tuple type up to 20:

macro_rules! for_each_tuple_ {
 ( $m:ident !! ) => (
 $m! { }
 );
 ( $m:ident !! $h:ident, $($t:ident,)* ) => (
 $m! { $h $($t)* }
 for_each_tuple_! { $m !! $($t,)* }
 );
}
macro_rules! for_each_tuple {
 ( $m:ident ) => (
 for_each_tuple_! { $m !! A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, }
 );
}

There are other instances of this pattern in Rust libraries; for instance, see

rust/src/libcore/hash/mod.rs

Line 239 in 8f5b5f9

macro_rules! impl_hash_tuple {

and

rust/src/libcore/hash/mod.rs

Line 259 in 8f5b5f9

impl_hash_tuple! {}

. The latter could be replaced with for_each_tuple!(impl_hash_tuple);

Would it make sense to put something like this somewhere in the Rust standard libraries, marked as unstable since it depends on defining macros? This would be useful for anyone implementing traits on tuples.

[soltanmm]

This seems related to the future possibility of variadic generics in terms of application.

[eddyb]

@pczarn was working on "higher-order macros" at some point. If implemented, it would allow you to pass the body of a macro to another macro, as you would pass a closure to a function.

It would turn http://is.gd/XQOy1R into http://is.gd/PyRjlK, but you can see that's not working because the expanded macro body is treated differently there than it is in a regular definition using macro_rules!.

[steveklabnik]

Macro additions are really huge, because they can't be individually imported. Adding macros to the standard library is a really big deal, so I'm moving this issue to the RFCs repo: rust-lang/rfcs#1365