Create a 'def_union' macro for creating a union-like enum - rust

Question

I'd like to create a 'def_union' macro that creates a union-like enum with From support.
macro_rules! def_union
{
($name:ident $(< $( $param:tt $( : $bound_lt0:tt $(+ $bound_lt:tt )* )? ),+ >)?
{
$($type_name:ident : $type:ty),*
}) =>
{
enum $name $(< $( $param $( : $bound_lt0 $(+ $bound_lt )* )? ),+ >)?
{
$(
$type_name($type)
),*
}
$(
impl $(< $( $param:tt $( : $bound_lt0:tt $(+ $bound_lt:tt )* )? ),+ >)?
From<$type> for $name $(< $( $param $( : $bound_lt0 $(+ $bound_lt )* )? ),+ >)?
{
fn from(value: $type) -> $name
{
$name::$type_name(value)
}
}
)*
};
}
trait UnionValue {}
def_union!
(
UnionType<Value0: UnionValue, Value1: UnionValue, String>
{
Value0: Value0,
Value1: Value1,
Other: String
}
);
fn main()
{
}
https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=2c2f13988dc3b51431db4fe0b40a6706
Unfortunatelly the output is:
Compiling playground v0.0.1 (/playground)
error: meta-variable `param` repeats 1 time, but `r#type` repeats 3 times
--> src/main.rs:15:10
|
15 | $(
| __________^
16 | | impl $(< $( $param:tt $( : $bound_lt0:tt $(+ $bound_lt:tt )* )? ),+ >)?
17 | | From<$type> for $name $(< $( $param $( : $bound_lt0 $(+ $bound_lt )* )? ),+ >)?
18 | | {
... |
23 | | }
24 | | )*
| |_________^
error: could not compile `playground` due to previous error
The problem is with the generic parameters. I don't know a workaround.
EDIT: Added discriminator trait for the generic parameters.

Answer 1

I will assume you want to solve the error and not just implement particular macro.
To solve this error you may choose to use helper macro. The trick is not apparent at first so lets show the code. (with comments)
macro_rules! def_union {
(
$name:ident$(<$($param_name:ident$(($($param_bounds:tt)*))?),+>)? {
$($type_name:ident: $type:ty),*
}
) => {
enum $name $(<$($param_name$(: $($param_bounds)*)?),+>)? {
$(
$type_name($type)
),*
}
def_union!(#$name ($)
($(<$($param_name$(: $($param_bounds)*)?),+>)?)
($name $(<$($param_name),*>)?));
$(
$name!($type_name $type);
)*
};
// here we generate helper macro that will break the repetition paradox.
// all of the outer repeating parts are passed to later outputted macro
// the `$t` is used as escape token that allows us to output new macro
(#$name:ident ($t:tt) ($($generics:tt)*) ($($type:tt)*)) => {
macro_rules! $name {
($t name:ident $t type:ty) => {
impl$($generics)* From<$t type> for $($type)* {
fn from(value: $t type) -> Self {
Self::$t name(value)
}
}
};
}
};
}
trait UnionValue {}
// I removed generic parameters because they were conflicting each other.
// I also altered syntax a bit to simplify the macro, you can choose to
// make it more like rust syntax
def_union!(
UnionType<Value0(UnionValue)> {
Value0: Value0,
Value2: usize
}
);
fn main() {}