Crate conseq

  

Imagine for-loops in a macro

This crate provides a conseq! macro to conditionally repeat a fragment of source code and substitute into each repetition a sequential numeric counter.

use conseq::conseq;

let tuple = (1000, 100, 10);
let mut sum = 0;

// Expands to:
//
//     sum += tuple.0;
//     sum += tuple.1;
//     sum += tuple.2;
//
// This cannot be written using an ordinary for-loop because elements of
// a tuple can only be accessed by their integer literal index, not by a
// variable.
conseq!(N in 0..=2 {
    sum += tuple.N;
});

assert_eq!(sum, 1110);

• If the input tokens contain a section surrounded by $[N]( … )*, where N is the name of the numeric counter, then only that part is repeated.

• The numeric counter can be pasted onto the end of some prefix to form sequential identifiers.

use conseq::conseq;

conseq!(N in 64..=127 {
    #[derive(Debug)]
    enum Demo {
        // Expands to Variant64, Variant65, ...
        $[N](
            Variant~N,
        )*
    }
});

assert_eq!("Variant99", format!("{:?}", Demo::Variant99));

• You can also use comparison operators (>, >=, <, <=, ==) inside $[ … ] to repeat the sequence conditionally.

use conseq::conseq;

let tuple = (1000, 100, 10);
let mut sum1 = 0;
let mut sum2 = 0;
let mut sum3 = 0;
let mut sum4 = 0;
let mut sum5 = 0;

conseq!(N in 0..=2 {
    $[N](sum1 += tuple.N;)*
    $[N < 1](sum2 += tuple.N;)*
    $[N < 2](sum3 += tuple.N;)*
    $[N >= 1](sum4 += tuple.N;)*
    $[N == 2](sum5 += tuple.N;)*
});

assert_eq!(sum1, 1110);
assert_eq!(sum2, 1000);
assert_eq!(sum3, 1100);
assert_eq!(sum4, 110);
assert_eq!(sum5, 10);

• Here is a more useful example

use conseq::conseq;

struct VarArgs<T> {
    tuple: T,
}
 
conseq!(N in 0..3 {
    impl<$[N < 1](T~N: PartialEq,)*> From<($[N < 1](T~N,)*)> for VarArgs<($[N < 1](T~N,)*)> {
        fn from(tuple: ($[N < 1](T~N,)*)) -> Self {
            VarArgs { tuple }
        }
    }
    impl<$[N < 2](T~N: PartialEq,)*> From<($[N < 2](T~N,)*)> for VarArgs<($[N < 2](T~N,)*)> {
        fn from(tuple: ($[N < 2](T~N,)*)) -> Self {
            VarArgs { tuple }
        }
    }
    impl<$[N < 3](T~N: PartialEq,)*> From<($[N < 3](T~N,)*)> for VarArgs<($[N < 3](T~N,)*)> {
        fn from(tuple: ($[N < 3](T~N,)*)) -> Self {
            VarArgs { tuple }
        }
    }
});

let args1 = VarArgs::from((123,));
let args2 = VarArgs::from((123, "text"));
let args3 = VarArgs::from((123, "text", 1.5));
assert_eq!(args1.tuple, (123,));
assert_eq!(args2.tuple, (123, "text"));
assert_eq!(args3.tuple, (123, "text", 1.5));

• You can also use a conseq! macro inside another conseq! macro

use conseq::conseq;

conseq!(N in 1..=3 {
    struct Struct<$[N](T~N,)*> {
        $[N](field~N: T~N,)*
        another_field: String,
    }
    impl<$[N](T~N,)*> Struct<$[N](T~N,)*> {
        fn new($[N](field~N: T~N,)*) -> Self {
            let mut another_field = String::from("");
            // I know, this is a stupid example, 
            // but I wanted to demonstrate that you can actually do that 
            conseq!(L in 'a'..='z'{ another_field.push(L); });
            Struct { $[N](field~N,)* another_field }
        }
    }
});

let s = Struct::new(1, 35.6, "abc");
assert_eq!(s.field1, 1);
assert_eq!(s.field2, 35.6);
assert_eq!(s.field3, "abc");
assert_eq!(s.another_field, "abcdefghijklmnopqrstuvwxyz");

• Byte and character ranges are supported: b'a'..=b'z', 'a'..='z'.

• If the range bounds are written in binary, octal, hex, or with zero padding, those features are preserved in any generated tokens.

use conseq::conseq;

conseq!(P in 0x000..=0x00F {
    // expands to structs Pin000, ..., Pin009, Pin00A, ..., Pin00F
    struct Pin~P;
});

Macros

conseq