xmacro 0.1.1

rust macro producing multiple expansions
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

# `XMacro`

A powerful macro system for generating repetitive code using a simple and expressive syntax.

This crate provides two main components:

1. A procedural macro [library](xmacro_lib) that enables code generation through template expansion
2. Two public macros: [`xmacro!`] and [`xmacro_items!`] for direct use in your code

This crate supersedes the `code_product` crate.

## Key Features

- Define reusable code templates with substitution points
- Generate multiple variations of code using sets of values
- Support for nested scopes and named definitions
- Table-based code generation for row-wise expansion
- Clear and maintainable syntax for complex code generation

## Usage

For example given are the two sets of defintions 'Foo and Bar' and 'This and That',
showing different syntactic variants:

Normal definitions expans each-by-each:

```rust
# use xmacro::xmacro;
trait Trait<T>{}
struct This; struct That;
struct Foo<T>(T); struct Bar<T>(T);
xmacro!{
    // Rather elaborate form with named definitions:
    $(T:    (This) (That))
    $(Type: (Foo)  (Bar))
    // and inline define `T` to expand to `Foo` and `Bar`
    impl Trait<$T> for $Type<$T> {}
}
```

or

```rust
# use xmacro::xmacro;
# trait Trait<T>{}
# struct This; struct That;
# struct Foo<T>(T); struct Bar<T>(T);
xmacro!{
    // Alternative form inlining/short definition and reference by index:
    impl Trait<$(This That)> for $(Foo Bar)<$0> {}
}
```

or use the table syntax expands per table row and gives more control what gets expansed:

```rust
# use xmacro::xmacro;
# trait Trait<T>{}
# struct This; struct That;
# struct Foo<T>(T); struct Bar<T>(T);
xmacro!{
    // Tables have a header line followed by a vertical list of expansions
    // they would be more interesting when defining more than one thing in the header
    $[
        T:      Type:
        (This)  (Foo)
        (That)  (Foo)
        (This)  (Bar)
        (That)  (Bar)
    ]
    // and inline define `T` to expand to `Foo` and `Bar`
    impl Trait<$T> for $Type<$T> {}
}
```

either of the above will expand four times to:

```rust,ignore
# trait Trait<T>{}
# struct This; struct That;
# struct Foo<T>(T); struct Bar<T>(T);
impl Trait<This> for Foo<This> {}
impl Trait<That> for Foo<That> {}
impl Trait<This> for Bar<This> {}
impl Trait<That> for Bar<That> {}
```






Please refer to the [xmacro_lib](xmacro_lib)  crate for a elaborate
description of the macro syntax and semantic.