macro_loop 0.4.3

A macro for writing repetitive Rust code using loops, conditionals, and bindings
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

use derive_syn_parse::Parse;
use proc_macro2::TokenStream;
use quote::ToTokens;
use syn::{
    Ident, Token,
    token::{Bracket, Paren},
};

use super::*;

#[derive(Parse)]
pub enum Frag {
    #[allow(private_interfaces)]
    #[peek(Token![for], name = "for")]
    For(FragFor),

    #[allow(private_interfaces)]
    #[peek(Token![if], name = "if")]
    If(FragIf),

    #[allow(private_interfaces)]
    #[peek(Token![let], name = "let")]
    Let(FragLet),

    #[allow(private_interfaces)]
    #[peek(Paren, name = "`()`")]
    Expr(FragExpr),

    #[allow(private_interfaces)]
    #[peek(Bracket, name = "`[]`")]
    Ident(FragConcat),

    #[peek(Ident, name = "a name")]
    Name(FragName),

    #[peek(Token![@], name = "`@`")]
    Cancel(Token![@]),
}

pub trait ApplyFragment {
    fn apply<'s: 'v, 'v>(
        &'s self,
        namespace: &mut Namespace<'v, 'v>,
        tokens: &mut TokenStream,
    ) -> syn::Result<()>;
}

impl ApplyFragment for Frag {
    fn apply<'s: 'v, 'v>(
        &'s self,
        namespace: &mut Namespace<'v, 'v>,
        tokens: &mut TokenStream,
    ) -> syn::Result<()> {
        match self {
            Self::For(self_) => self_.apply(namespace, tokens),
            Self::If(self_) => self_.apply(namespace, tokens),
            Self::Let(self_) => self_.apply(namespace, tokens),
            Self::Expr(self_) => self_.apply(namespace, tokens),
            Self::Ident(self_) => self_.apply(namespace, tokens),
            Self::Name(self_) => self_.apply(namespace, tokens),

            Self::Cancel(self_) => Ok(self_.to_tokens(tokens)),
        }
    }
}