scryer-prolog 0.8.68

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

use std::cell::Cell;
use std::fmt;
use std::vec::Vec;

pub type Var = String;

pub type Atom = String;

pub enum TopLevel {
    Fact(Term),
    Query(Term)
}

#[derive(Clone, Copy)]
pub enum Level {
    Shallow, Deep
}

impl fmt::Display for Level {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            &Level::Shallow => write!(f, "A"),
            &Level::Deep => write!(f, "X")
        }
    }
}

#[derive(Clone, Copy)]
pub enum Reg {
    ArgAndNorm(usize, usize),
    Norm(usize)
}

impl Reg {
    pub fn has_arg(&self) -> bool {
        match self {
            &Reg::ArgAndNorm(_, _) => true,
            _ => false
        }
    }

    pub fn norm(&self) -> usize {
        match self {
            &Reg::ArgAndNorm(_, norm) | &Reg::Norm(norm) => norm
        }
    }
}

pub enum Term {
    Atom(Cell<usize>, Atom),
    Clause(Cell<usize>, Atom, Vec<Box<Term>>),
    Var(Cell<Reg>, Var)
}

pub enum TermRef<'a> {
    Atom(Level, &'a Cell<usize>, &'a Atom),
    Clause(Level, &'a Cell<usize>, &'a Atom, &'a Vec<Box<Term>>),
    Var(Level, &'a Cell<Reg>, &'a Var)
}

#[derive(Clone)]
pub enum FactInstruction {
    GetStructure(Level, Atom, usize, usize),
    GetValue(usize, usize),
    GetVariable(usize, usize),
    Proceed,
    UnifyVariable(usize),
    UnifyValue(usize)
}

pub enum QueryInstruction {
    Call(Atom, usize),
    PutStructure(Level, Atom, usize, usize),
    PutValue(usize, usize),
    PutVariable(usize, usize),
    SetVariable(usize),
    SetValue(usize),
}

pub type CompiledFact = Vec<FactInstruction>;

pub type CompiledQuery = Vec<QueryInstruction>;

#[derive(Clone, Copy, PartialEq)]
pub enum Addr {
    HeapCell(usize),
    RegNum(usize)
}

#[derive(Clone)]
pub enum HeapCellValue {
    NamedStr(usize, Atom),
    Ref(usize),
    Str(usize),
}

pub type Heap = Vec<HeapCellValue>;

pub type Registers = Vec<HeapCellValue>;

impl Term {
    pub fn subterms(&self) -> usize {
        match self {
            &Term::Clause(_, _, ref terms) => terms.len(),
            _ => 1
        }
    }

    pub fn name(&self) -> &Atom {
        match self {
            &Term::Atom(_, ref atom)
            | &Term::Var(_, ref atom)
            | &Term::Clause(_, ref atom, _) => atom
        }
    }

    pub fn arity(&self) -> usize {
        match self {
            &Term::Atom(_, _) | &Term::Var(_, _) => 0,
            &Term::Clause(_, _, ref child_terms) => child_terms.len()
        }
    }
}