Rust macro with dots in token trees - rust

Question

I'm trying to create a Rust macro that generates endpoints like "/api/v2/stats/<token>".
I thought it would be cool to make it like warp path does it: warp::path!("sum" / u32 / u32).
But in warp, they do not need to support token trees with dots, i.e. expressions, and retrieve their values...
What I got so far is this:
macro_rules! path {
() => {};
($next:tt $($tail:tt)*) => {{
println!(stringify!($next));
path!($($tail)*);
}};
}
fn main() {
struct Data {
event: String,
token: String,
}
let data = Data {
event: String::from("stats"),
token: String::from("a1b2c3d4"),
};
path!("/api/v2" / data.event / data.token)
}
playground: https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=babf87265cc6060fc1695019e30e38bf
This shows what the macro is seeing:
"/api/v2"
/
data
.
event
/
data
.
token
I know token trees can be reinterpreted as expressions later, so there should be a way to keep tt's in tail, split slashes from "anything else", and get those as expressions to retrieve their values, but I'm not seeing how...
How could I make it return the String "/api/v2/stats/a1b2c3d4"?
More examples of inputs and expected outputs:
struct Conf<'a> {env: &'a str};
let conf = Conf { env: "dev" };
let subsystem = "stats";
path!("/"); // root: "/"
path!("/api/v1" / data.event / "results"); // "/api/v1/stats/results"
path!("/api/v2/errors" / conf.env / subsystem); // "/api/v2/errors/dev/stats"
EDIT: I kinda did it with expressions, which it not that expressive, more of a workaround, but it works:
macro_rules! path {
($($path:expr),+) => {{
let mut s = [$($path),+].into_iter().flat_map(|p| [p, "/"]).collect::<String>();
s.pop();
s
}}
}
Limitations: it only accepts commas, the path parts have to be &str so I have to manually reference them, and most of all, this could be better represented as a function, but is something to start with:
let result_url = path!("/api/v2", &data.event, &data.token);
Thank you!

Answer 1

You can use a tt muncher to achieve this:
macro_rules! path {
(#munch / ) => {
String::from("/")
};
(#munch / $part:literal $(/)* ) => {
format!("/{}", $part)
};
(#munch / $part:literal / $($tail:tt)* ) => {
format!("/{}{}", $part, path!(#munch / $($tail)*))
};
(#munch / $($parts:ident).+ $(/)* ) => {
format!("/{}", & $($parts).+)
};
(#munch / $($parts:ident).+ / $($tail:tt)* ) => {
format!("/{}{}", & $($parts).+, path!(#munch / $($tail)*))
};
(/ $($input:tt)*) => {
path!(#munch / $($input)*)
};
}
playground
Currently this produces nested format! calls. In order to avoid that you'll probably also need to use an accumulator. This kinda stuff interests me so I'm working on a version with an accumulator.
Edit: And here's the accumulator version
macro_rules! path {
(/) => {
String::from("/")
};
(/ $($input:tt)*) => {
path!(#munch { / $($input)* } => ())
};
(#munch { / $part:literal $(/)* } => ($($accum:expr),*)) => {
path!(#done ($( $accum, )* $part))
};
(#munch { / $part:literal / $($tail:tt)* } => ($($accum:expr),*)) => {
path!(#munch { / $($tail)* } => ($( $accum, )* $part ))
};
(#munch { / $($parts:ident).+ $(/)* } => ($($accum:expr),*)) => {
path!(#done ($( $accum, )* & $($parts).+ ))
};
(#munch { / $($parts:ident).+ / $($tail:tt)* } => ($($accum:expr),*)) => {
path!(#munch { / $($tail)* } => ($( $accum, )* & $($parts).+ ))
};
(#replace_expr $_t:tt => $sub:expr) => { $sub };
(#done ($($accum:expr),*)) => {
format!(
concat!($( path!(#replace_expr ($accum) => "/{}"), )*),
$( $accum, )*
)
};
}
playground
Edit2: per your request, another version which uses two accumulators to support a leading literal
macro_rules! path {
(/) => {
String::from("/")
};
(/ $($input:tt)*) => {
path!(#munch { / $($input)* } -> () : ())
};
($part:literal $(/)*) => {
String::from($part)
};
($part:literal $($input:tt)*) => {
path!(#munch { $($input)* } -> ("{}") : ($part))
};
(#munch { / $part:literal $(/)* } -> ($($fmt_accum:literal),*) : ($($args_accum:expr),*)) => {
path!(#done ($( $fmt_accum, )* "/{}") : ($( $args_accum, )* $part))
};
(#munch { / $part:literal / $($tail:tt)* } -> ($($fmt_accum:literal),*) : ($($args_accum:expr),*)) => {
path!(#munch { / $($tail)* } -> ($( $fmt_accum, )* "/{}") : ($( $args_accum, )* $part ))
};
(#munch { / $($parts:ident).+ $(/)* } -> ($($fmt_accum:literal),*) : ($($args_accum:expr),*)) => {
path!(#done ($( $fmt_accum, )* "/{}") : ($( $args_accum, )* & $($parts).+ ))
};
(#munch { / $($parts:ident).+ / $($tail:tt)* } -> ($($fmt_accum:literal),*) : ($($args_accum:expr),*)) => {
path!(#munch { / $($tail)* } -> ($( $fmt_accum, )* "/{}") : ($( $args_accum, )* & $($parts).+ ))
};
(#done ($($fmt_accum:literal),*) : ($($args_accum:expr),*)) => {
format!(
concat!($( $fmt_accum, )*),
$( $args_accum, )*
)
};
}
playground