rstm-macros 0.1.6

procedural macros focused on streamlining the composition of Turing machines and their rules.
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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

/*
    Appellation: rule_ast <module>
    Created At: 2026.01.11:11:41:13
    Contrib: @FL03
*/
use syn::parse::{Parse, ParseStream};
use syn::punctuated::Punctuated;
use syn::token::Paren;
use syn::{Expr, Ident, Token, braced, parenthesized};

/// The abstract syntax tree for the head of a rule / Turing machine: `(state, symbol)`
#[derive(Clone)]
pub struct HeadAst {
    #[allow(dead_code)]
    pub group: Paren,
    pub state: Expr,
    #[allow(dead_code)]
    pub comma: Token![,],
    pub symbol: Expr,
}
/// The abstract syntax tree for the tail of a rule / Turing machine: `{Left|Right|Stay}(state, symbol)`
#[derive(Clone)]
pub struct TailAst {
    pub direction: Ident,
    #[allow(dead_code)]
    pub group: Paren,
    pub next_state: Expr,
    #[allow(dead_code)]
    pub comma: Token![,],
    pub next_symbol: Expr,
}

/// The abstract syntax tree for a single operation rule
///
/// `(state, symbol) -> Direction(next_state, next_symbol)`
#[derive(Clone)]
pub struct RuleAst {
    pub head: HeadAst,
    #[allow(dead_code)]
    pub rarrow: Token![->],
    pub tail: TailAst,
}

pub struct RuleBlockAst {
    #[allow(dead_code)]
    pub key: crate::keywords::rules,
    #[allow(dead_code)]
    pub colon: Token![:],
    pub rules: Punctuated<RuleAst, Token![,]>,
    #[allow(dead_code)]
    pub semi: Option<Token![;]>,
}

/*
 ************* Implementations *************
*/

impl RuleAst {
    #[allow(dead_code)]
    /// returns the string representation of the rule
    pub fn as_token_stream(&self) -> proc_macro2::TokenStream {
        // deconstruct the rule ast
        let RuleAst {
            head: HeadAst { state, symbol, .. },
            tail:
                TailAst {
                    direction,
                    next_state,
                    next_symbol,
                    ..
                },
            ..
        } = self;
        // create a rule
        quote::quote! {
            rstm::Rule {
                head: rstm::Head {
                    state: #state,
                    symbol: #symbol,
                },
                tail: rstm::Tail {
                    direction: rstm::Direction::#direction,
                    next_state: #next_state,
                    write_symbol: #next_symbol,
                }
            }
        }
    }
}

impl Parse for HeadAst {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        let content;
        let group = parenthesized! { content in input };
        let state = content.parse::<Expr>()?;
        let comma = content.parse::<Token![,]>()?;
        let symbol = content.parse::<Expr>()?;
        Ok(Self {
            group,
            state,
            comma,
            symbol,
        })
    }
}

impl Parse for TailAst {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        let direction = input.parse::<Ident>()?;
        let content;
        let group = parenthesized! { content in input };
        let next_state = content.parse::<Expr>()?;
        let comma = content.parse::<Token![,]>()?;
        let next_symbol = content.parse::<Expr>()?;
        Ok(Self {
            direction,
            next_state,
            next_symbol,
            group,
            comma,
        })
    }
}

impl Parse for RuleAst {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        let head = input.parse::<HeadAst>()?;
        let rarrow = input.parse::<Token![->]>()?;
        let tail = input.parse::<TailAst>()?;
        Ok(Self { head, rarrow, tail })
    }
}

impl Parse for RuleBlockAst {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        let key = input.parse::<crate::keywords::rules>()?;
        let colon = input.parse::<Token![:]>()?;
        let content;
        let _ = braced! { content in input };
        let rules = content.parse_terminated(RuleAst::parse, Token![,])?;
        // if present, consume the optional semicolon after the rules block
        let semi = if content.peek(Token![;]) {
            Some(content.parse()?)
        } else {
            None
        };
        Ok(Self {
            key,
            colon,
            rules,
            semi,
        })
    }
}