uor-foundation-macros 0.2.1

Proc macro crate for the UOR Foundation — provides the uor! DSL macro
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

//! Surface syntax serializer for round-trip property.
//!
//! Converts a `ParsedNode` back to canonical EBNF surface syntax.

use crate::parser::ParsedNode;

/// Serialize a parsed node to its canonical EBNF surface syntax string.
pub fn serialize(node: &ParsedNode) -> String {
    match node {
        ParsedNode::Literal { value, level } => match level {
            Some(l) => format!("{value}@{l}"),
            None => format!("{value}"),
        },
        ParsedNode::StringLiteral(s) => format!("\"{s}\""),
        ParsedNode::Variable(name) => name.clone(),
        ParsedNode::Application { op, args } => {
            let arg_strs: Vec<String> = args.iter().map(serialize).collect();
            format!("{}({})", op, arg_strs.join(", "))
        }
        ParsedNode::Lift { operand, target } => {
            format!("lift({}, {})", serialize(operand), target)
        }
        ParsedNode::Project { operand, target } => {
            format!("project({}, {})", serialize(operand), target)
        }
        ParsedNode::TypeDecl {
            name,
            type_params,
            constraints,
        } => {
            let params = if type_params.is_empty() {
                String::new()
            } else {
                format!("({})", type_params.join(", "))
            };
            let mut s = format!("type {name}{params} {{");
            for (kind, args) in constraints {
                let arg_strs: Vec<String> = args
                    .iter()
                    .map(|(n, e)| format!("{n}: {}", serialize(e)))
                    .collect();
                s.push_str(&format!(" {kind}({});", arg_strs.join(", ")));
            }
            s.push_str(" }");
            s
        }
        ParsedNode::Binding {
            name,
            type_name,
            value,
        } => {
            format!("let {name} : {type_name} = {};", serialize(value))
        }
        ParsedNode::Assertion { lhs, rhs } => {
            format!("assert {} = {};", serialize(lhs), serialize(rhs))
        }
        ParsedNode::EffectDecl { name, props } => {
            let mut s = format!("effect {name} {{");
            for (prop_name, value) in props {
                s.push_str(&format!(" {prop_name}: {};", serialize(value)));
            }
            s.push_str(" }");
            s
        }
        ParsedNode::SourceDecl {
            name,
            type_name,
            via,
        } => {
            format!("source {name} : {type_name} via {via};")
        }
        ParsedNode::SinkDecl {
            name,
            type_name,
            via,
        } => {
            format!("sink {name} : {type_name} via {via};")
        }
        ParsedNode::Match {
            scrutinee,
            arms,
            otherwise,
        } => {
            let mut s = format!("match {scrutinee} {{");
            for (pat, expr) in arms {
                s.push_str(&format!(" {pat} => {};", serialize(expr)));
            }
            s.push_str(&format!(" otherwise => {};", serialize(otherwise)));
            s.push_str(" }");
            s
        }
        ParsedNode::TryExpr { body, recover_arms } => {
            let mut s = format!("try {} {{", serialize(body));
            for (kind, expr) in recover_arms {
                s.push_str(&format!(" recover {kind} => {};", serialize(expr)));
            }
            s.push_str(" }");
            s
        }
        ParsedNode::Recurse {
            name,
            param,
            measure,
            base_arms,
            step_expr,
        } => {
            let mut s = format!("recurse {name}({param}) measure {measure}");
            for (pred, expr) in base_arms {
                s.push_str(&format!(" base {pred} => {}", serialize(expr)));
            }
            s.push_str(&format!(" step => {}", serialize(step_expr)));
            s
        }
        ParsedNode::Unfold {
            name,
            type_name,
            seed,
        } => {
            format!("unfold {name} : {type_name} from {}", serialize(seed))
        }
    }
}