meta-language 0.33.0

A self-describing links-network core for lossless language representation
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

use crate::link_network::LinkType;

pub struct SelfDescriptionRoot {
    pub term: &'static str,
    pub link_type: LinkType,
    pub references: &'static [&'static str],
}

pub const SELF_DESCRIPTION_ROOTS: &[SelfDescriptionRoot] = &[
    SelfDescriptionRoot {
        term: "link",
        link_type: LinkType::Link,
        references: &["reference", "reference"],
    },
    SelfDescriptionRoot {
        term: "reference",
        link_type: LinkType::Reference,
        references: &["link", "link"],
    },
    SelfDescriptionRoot {
        term: "relation link",
        link_type: LinkType::Relation,
        references: &["link", "reference"],
    },
    SelfDescriptionRoot {
        term: "language",
        link_type: LinkType::Language,
        references: &["grammar", "concept"],
    },
    SelfDescriptionRoot {
        term: "grammar",
        link_type: LinkType::Grammar,
        references: &["language", "relation link"],
    },
    SelfDescriptionRoot {
        term: "type",
        link_type: LinkType::Type,
        references: &["Type", "concept"],
    },
    SelfDescriptionRoot {
        term: "Type",
        link_type: LinkType::Type,
        references: &["Type", "Type"],
    },
    SelfDescriptionRoot {
        term: "concept",
        link_type: LinkType::Concept,
        references: &["link", "language"],
    },
    SelfDescriptionRoot {
        term: "point",
        link_type: LinkType::Concept,
        references: &["point", "point"],
    },
    SelfDescriptionRoot {
        term: "field",
        link_type: LinkType::Field,
        references: &["relation link", "reference"],
    },
    SelfDescriptionRoot {
        term: "trivia",
        link_type: LinkType::Trivia,
        references: &["region", "link"],
    },
    SelfDescriptionRoot {
        term: "region",
        link_type: LinkType::Region,
        references: &["language", "link"],
    },
    SelfDescriptionRoot {
        term: "object",
        link_type: LinkType::Object,
        references: &["link", "reference"],
    },
];

pub fn definition_expression(term: &str, references: &[&str]) -> String {
    let mut expression = String::from("(");
    expression.push_str(term);
    expression.push(':');
    for reference in references {
        expression.push(' ');
        expression.push_str(reference);
    }
    expression.push(')');
    expression
}