tree-automata 0.1.2

Term Rewriting Systems
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

extern crate terms;
extern crate tree_automata as ta;

use terms::{Term, Pattern};
use ta::Automaton;

fn main() {
    let mut a = Automaton::new();

    a.add(Pattern::cons('a', &[]), (), "ab");
    a.add(Pattern::cons('b', &[]), (), "ab");
    a.add(Pattern::cons('b', &[]), (), "bc");
    a.add(Pattern::cons('c', &[]), (), "bc");

    assert!(a.configurations_for(&Pattern::cons('a', &[])).next().is_some());
    assert!(a.configurations_for(&Pattern::cons('a', &[])).next().is_some());
    assert!(a.configurations_for(&Pattern::cons('a', &[])).next().is_some());
    assert!(a.configurations_for(&Pattern::cons('a', &[])).next().is_some());

    a.add(Pattern::cons('i', &["ab".into()]), (), "i(ab)");
    a.add(Pattern::cons('j', &["ab".into()]), (), "j(ab)");
    a.add(Pattern::cons('k', &["ab".into()]), (), "k(ab)");
    a.add(Pattern::cons('l', &["ab".into()]), (), "l(ab)");
    a.add(Pattern::cons('l', &["bc".into()]), (), "l(bc)");
    a.add(Pattern::cons('m', &["bc".into()]), (), "m(bc)");
    a.add(Pattern::cons('n', &["bc".into()]), (), "n(bc)");
    a.add(Pattern::cons('o', &["bc".into()]), (), "o(bc)");

    a.add(Pattern::cons('f', &["i(ab)".into()]), (), "f(ij)|g(kl)");
    a.add(Pattern::cons('f', &["j(ab)".into()]), (), "f(ij)|g(kl)");
    a.add(Pattern::cons('g', &["k(ab)".into()]), (), "f(ij)|g(kl)");
    a.add(Pattern::cons('g', &["l(ab)".into()]), (), "f(ij)|g(kl)");
    a.add(Pattern::cons('g', &["l(bc)".into()]), (), "g(lm)|h(no)");
    a.add(Pattern::cons('g', &["m(bc)".into()]), (), "g(lm)|h(no)");
    a.add(Pattern::cons('h', &["n(bc)".into()]), (), "g(lm)|h(no)");
    a.add(Pattern::cons('h', &["o(bc)".into()]), (), "g(lm)|h(no)");

    let automata = [&a, &a];
    let positions = ["f(ij)|g(kl)".into(), "g(lm)|h(no)".into()];
    let patterns = [(), ()];
    let constraints = ();

    // g(l(b))
    let term = Term::new('g', &[Term::new('l', &[Term::new('b', &[])])]);

    let mut it = Automaton::synchronized_runs(
        &automata,
        &positions,
        &patterns,
        &constraints
    );

    // we should find term "g(l(b))"
    let mut empty = true;
    for (run, _) in it {
        empty = false;
        let t = run.first().unwrap();
        println!("term: {:?}", t);
        assert!(*t == term)
    }
    assert!(!empty);
}