scryer-prolog 0.8.81

A modern Prolog implementation written mostly in Rust.
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

use l0::ast::{Atom, Term, FactInstruction, QueryInstruction, Var};
use l0::iterators::{BreadthFirstIterator, PostOrderIterator};

use std::collections::{HashSet};
use std::fmt;
use std::vec::{Vec};

impl fmt::Display for QueryInstruction {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            &QueryInstruction::PutStructure(ref a, ref s, ref r) =>
                write!(f, "put_structure {}/{}, X{}", a, s, r),
            &QueryInstruction::SetVariable(ref r) =>
                write!(f, "set_variable X{}", r),
            &QueryInstruction::SetValue(ref r) =>
                write!(f, "set_value X{}", r),
        }
    }
}

impl fmt::Display for FactInstruction {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            &FactInstruction::GetStructure(ref a, ref s, ref r) =>
                write!(f, "get_structure {}/{}, X{}", a, s, r),
            &FactInstruction::UnifyVariable(ref r) =>
                write!(f, "unify_variable X{}", r),
            &FactInstruction::UnifyValue(ref r) =>
                write!(f, "unify_value X{}", r)
        }
    }
}

pub trait CompilationTarget<'a> {
    type Iterator : Iterator<Item=&'a Term>;
    
    fn iter(term: &'a Term) -> Self::Iterator;

    fn to_structure(name: Atom, arity: usize, cell_num: usize) -> Self;
    fn to_value(cell_num: usize) -> Self;
    fn to_variable(cell_num: usize) -> Self;
}

impl<'a> CompilationTarget<'a> for FactInstruction {
    type Iterator = BreadthFirstIterator<'a>;
    
    fn iter(term: &'a Term) -> Self::Iterator {
        term.breadth_first_iter()
    }

    fn to_structure(name: Atom, arity: usize, cell_num: usize) -> Self {
        FactInstruction::GetStructure(name, arity, cell_num)
    }

    fn to_value(cell_num: usize) -> Self {
        FactInstruction::UnifyValue(cell_num)
    }

    fn to_variable(cell_num: usize) -> Self {
        FactInstruction::UnifyVariable(cell_num)
    }
}

impl<'a> CompilationTarget<'a> for QueryInstruction {
    type Iterator = PostOrderIterator<'a>;

    fn iter(term: &'a Term) -> Self::Iterator {
        term.post_order_iter()
    }

    fn to_structure(name: Atom, arity: usize, cell_num: usize) -> Self {
        QueryInstruction::PutStructure(name, arity, cell_num)
    }

    fn to_value(cell_num: usize) -> Self {
        QueryInstruction::SetValue(cell_num)
    }

    fn to_variable(cell_num: usize) -> Self {
        QueryInstruction::SetVariable(cell_num)
    }
}

fn subterm_to_instr<'a, Target>(subterm:  &'a Term,
                                bindings: &mut HashSet<&'a Var>)
                                -> Target
    where Target: CompilationTarget<'a>
{
    match subterm {
        &Term::Atom(ref cell_num, _) =>
            Target::to_value(cell_num.get()),
        &Term::Var(ref cell_num, ref atom) if bindings.contains(atom) =>
            Target::to_value(cell_num.get()),
        &Term::Var(ref cell_num, ref atom) => {
            bindings.insert(atom);
            Target::to_variable(cell_num.get())
        },
        &Term::Clause(ref cell_num, _, _) =>
            Target::to_value(cell_num.get())
    }
}

pub fn compile_target<'a, Target>(term: &'a Term) -> Vec<Target>
    where Target: CompilationTarget<'a>
{
    let mut iter     = Target::iter(term);
    let mut target   = Vec::<Target>::new();
    let mut bindings = HashSet::new();

    while let Some(term) = iter.next() {
        match term {
            &Term::Atom(ref cell_num, ref atom) =>
                target.push(Target::to_structure(atom.clone(), 0, cell_num.get())),
            &Term::Clause(ref cell_num, ref atom, ref terms) => {
                target.push(Target::to_structure(atom.clone(), 0, cell_num.get()));

                for subterm in terms {
                    target.push(subterm_to_instr(subterm.as_ref(), &mut bindings));
                }
            },
            _ => {},
        };
    }

    target
}