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

/*
    appellation: fsm <module>
    authors: @FL03
*/
use crate::ast::{FiniteStateMachineAst, HeadAst, RuleAst, RuleBlockAst, TailAst};
use proc_macro2::TokenStream;
use quote::quote;

/// Generates a block expression that builds and returns an initialized
/// `MovingHead` instance from the declared rules and optional default state.
///
/// Types (state `Q` and symbol `A`) are inferred by the compiler from the
/// literal values present in the rule expressions, avoiding the need for
/// explicit type annotations.
pub fn impl_fsm(input: &FiniteStateMachineAst) -> TokenStream {
    let FiniteStateMachineAst {
        default_state,
        rules,
        ..
    } = input;
    // convert the rules into token streams
    let rules_stream = handle_rule_block(rules);
    // generate the optional `.with_default_state(...)` call
    let with_state = default_state.as_ref().map(|ds| {
        let state = &ds.state;
        quote! { .with_default_state(#state) }
    });

    quote! {
        rstm::MovingHead::tmh(
            rstm::Program::from_iter([#(#rules_stream),*]) #with_state
        )
    }
}

fn handle_rule_block(RuleBlockAst { rules, .. }: &RuleBlockAst) -> Vec<TokenStream> {
    rules.into_iter().map(handle_rule).collect()
}

fn handle_rule(
    RuleAst {
        head: HeadAst { state, symbol, .. },
        tail:
            TailAst {
                direction,
                next_state,
                next_symbol,
                ..
            },
        ..
    }: &RuleAst,
) -> TokenStream {
    // create a rule
    quote! {
        rstm::Rule {
            head: rstm::Head::new(#state, #symbol),
            tail: rstm::Tail::new(rstm::Direction::#direction, #next_state, #next_symbol),
        }
    }
}