# Obsoletion Notice


*** This crate is superseded by the xmacro/xmacro_lib crate ***

* Migrate your projects to xmacros.
* Don't use it for new Code.


# Code Product

This crate provides two things:
 1. A [library](code_product_lib) to generate code by repetively expanding macros.  This is
    the primary objective of this crate as it enables code generation in a convenient way from
    other proc macros. The Syntax is there as well.
 2. The standalone [`product!{}`](product) and [`product_items!{}`](product_items) macros to
    generate code using the library as it is useful on its own.


## Use-Cases

This macro system is useful to generate boilerplate code that repeats in similar ways.


## Product expansion example

The name `product` is because it expands to the product (each by each) of all defined
sets. For example given are the two sets of defintions 'Foo and Bar' and 'This and That',
showing different syntactic variants:

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

or

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

either of the above will expand four times to:

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

## Linear expansion example

In `linear` expansion scopes in square brackets each definition has to define the same number
of itens. These are then iterated together. This gives more control over the expansions as
each possible combination has to be defined manually.

Exmaple: Pair Substr with &str and with CowStr and its reversed forms.

```text
product! {
    $[
        $(Lhs: (SubStr)(&str)(SubStr)(CowStr))
        $(Rhs: (&str)(SubStr)(CowStr)(SubStr))

        impl PartialOrd<$Rhs> for $Lhs {
            fn partial_cmp(&self, other: &$Rhs) -> Option<std::cmp::Ordering> {
                (**self).partial_cmp(other)
            }
        }
    ]
}
```