streamline code generation with iterators and traits

README.md

@@ -27,8 +27,6 @@ l0> ?- p(z, w).
 no  
 l0> ?- p(w, w).  
 yes  
-l0> ?- p(Z, w).  
-yes  
 l0> ?- p(Z, h(Z, W), f(W)).  
 no  
 l0> p(Z, h(Z, W), f(W)).  
@@ -43,3 +41,14 @@ l0> ?- p(z, h(Z, w), f(w)).
 yes  
 l0> quit
 ```
+
+## Occurs check
+
+There's no occurs check, so cyclic terms do unify:
+
+```
+l0> p(W, W).
+Program stored.
+l0> ?- p(f(f(W)), W).
+yes
+```

src/l0/ast.rs

@@ -1,3 +1,4 @@
+use std::cell::{Cell};
 use std::vec::{Vec};
 
 pub type Var = String;
@@ -12,24 +13,39 @@ pub enum TopLevel {
 
 #[derive(Debug)]
 pub enum Term {
-    Atom(Atom),
+    Atom(Cell<usize>, Atom),
-    Clause(Atom, Vec<Box<Term>>),
+    Clause(Cell<usize>, Atom, Vec<Box<Term>>),
-    Var(Var)
+    Var(Cell<usize>, Var)
 }
 
-pub enum MachineInstruction {
+pub enum FactInstruction {
     GetStructure(Atom, usize, usize),
-    PutStructure(Atom, usize, usize),
-    SetVariable(usize),
-    SetValue(usize),
     UnifyVariable(usize),
     UnifyValue(usize)
 }
 
-pub type Program = Vec<MachineInstruction>;
+pub enum QueryInstruction {    
+    PutStructure(Atom, 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)
 }
+
+impl Term {
+    pub fn set_cell(&self, cell_num: usize) {
+        match self {
+            &Term::Atom(ref cell, _) => cell.set(cell_num),
+            &Term::Clause(ref cell, _, _) => cell.set(cell_num),
+            &Term::Var(ref cell, _) => cell.set(cell_num)
+        };
+    }
+}

src/l0/codegen.rs

@@ -1,178 +1,126 @@
-use l0::ast::{Atom, Term, MachineInstruction, Program, TopLevel, Var};
+use l0::ast::{Atom, Term, FactInstruction, QueryInstruction, Var};
+use l0::iterators::{BreadthFirstIterator, PostOrderIterator};
 
-use std::collections::{HashMap, VecDeque};
+use std::collections::{HashSet};
 use std::fmt;
 use std::vec::{Vec};
 
-impl fmt::Display for MachineInstruction {
+impl fmt::Display for QueryInstruction {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            &MachineInstruction::GetStructure(ref a, ref s, ref r) =>
+            &QueryInstruction::PutStructure(ref a, ref s, ref r) =>
-                write!(f, "get_structure {}/{}, X{}", a, s, r),
-            &MachineInstruction::PutStructure(ref a, ref s, ref r) =>
                 write!(f, "put_structure {}/{}, X{}", a, s, r),
-            &MachineInstruction::SetVariable(ref r) =>
+            &QueryInstruction::SetVariable(ref r) =>
                 write!(f, "set_variable X{}", r),
-            &MachineInstruction::SetValue(ref r) =>
+            &QueryInstruction::SetValue(ref r) =>
                 write!(f, "set_value X{}", r),
-            &MachineInstruction::UnifyVariable(ref 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),
-            &MachineInstruction::UnifyValue(ref r) =>
+            &FactInstruction::UnifyValue(ref r) =>
                 write!(f, "unify_value X{}", r)
         }
     }
 }
 
-enum IntTerm<'a> {
+pub trait CompilationTarget<'a> where Self : Sized {
-    FinishedClause(usize, usize, &'a Atom, &'a Vec<Box<Term>>),
+    type Iterator : Iterator<Item=&'a Term>;
-    UnfinishedClause(usize, &'a Atom, &'a Vec<Box<Term>>),
+    
-    FinishedAtom(usize, &'a Atom)
+    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;
 }
 
-pub fn compile_query<'a>(t: &'a Term) -> Program
+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>
 {
-    let mut stack : Vec<IntTerm<'a>> = Vec::new();
+    match subterm {
-    let mut variable_allocs : HashMap<&Var, (usize, bool)> = HashMap::new();
+        &Term::Atom(ref cell_num, _) =>
-    let mut query : Program = Vec::new();
+            Target::to_value(cell_num.get()),
-
+        &Term::Var(ref cell_num, ref atom) if bindings.contains(atom) =>
-    match t {
+            Target::to_value(cell_num.get()),
-        &Term::Clause(ref atom, ref terms) => {
+        &Term::Var(ref cell_num, ref atom) => {
-            stack.push(IntTerm::UnfinishedClause(1, atom, terms));
+            bindings.insert(atom);
-            variable_allocs.insert(atom, (1, true));
+            Target::to_variable(cell_num.get())
         },
-        &Term::Atom(ref atom) => {
+        &Term::Clause(ref cell_num, _, _) =>
-            query.push(MachineInstruction::PutStructure(atom.clone(), 0, 1));
+            Target::to_value(cell_num.get())
-            return query;
-        },
-        &Term::Var(_) => {
-            query.push(MachineInstruction::SetVariable(1));
-            return query;
-        },
-    };
-
-    let mut max_reg_used : usize = 1;
-
-    while let Some(int_term) = stack.pop() {
-        match int_term {
-            IntTerm::UnfinishedClause(r, atom, terms) => {
-                stack.push(IntTerm::FinishedClause(r, max_reg_used, atom, terms));
-
-                let mut counter : usize = max_reg_used; // r + 1;
-
-                for t in terms {
-                    if let &Term::Var(ref var) = t.as_ref() {
-                        if !variable_allocs.contains_key(var) {
-                            counter += 1;
-                            variable_allocs.insert(var, (counter, false));
     }
-                    } else {
-                        counter += 1;
-                    }
-                }
-
-                max_reg_used = counter;
-
-                for t in terms.iter().rev() {
-                    if let &Term::Var(_) = t.as_ref() {
-                        counter -= 1;
-                        continue;
-                    }
-
-                    let r = {
-                        let oc = counter;
-                        counter -= 1;
-                        oc
-                    };
-
-                    match t.as_ref() {
-                        &Term::Atom(ref atom) =>
-                            stack.push(IntTerm::FinishedAtom(r, atom)),
-                        &Term::Clause(ref atom, ref terms) =>
-                            stack.push(IntTerm::UnfinishedClause(r, atom, terms)),
-                        _ => {}
-                    };
-                }
-            },
-            IntTerm::FinishedAtom(r, atom) =>
-                query.push(MachineInstruction::PutStructure(atom.clone(), 0, r)),
-            IntTerm::FinishedClause(r, mr, atom, terms) => {
-                query.push(MachineInstruction::PutStructure(atom.clone(), terms.len(), r));
-
-                let mut counter : usize = mr + 1;
-
-                for t in terms {
-                    if let &Term::Var(ref var) = t.as_ref() {
-                        let &mut (reg, ref mut seen) = variable_allocs.get_mut(var).unwrap();
-
-                        if !*seen {
-                            query.push(MachineInstruction::SetVariable(reg));
-                            *seen = true;
-                        } else {
-                            query.push(MachineInstruction::SetValue(reg));
-                        }
-
-                        if reg == counter {
-                            counter += 1;
-                        }
-                    } else {
-                        query.push(MachineInstruction::SetValue(counter));
-                        counter += 1;
-                    }
-                }
-
-                max_reg_used = counter - 1;
-            }
-        };
-    }
-
-    query
 }
 
-pub fn compile_fact<'a>(t: &'a Term) -> Program {
+pub fn compile_target<'a, Target>(term: &'a Term) -> Vec<Target>
-    let mut reg : usize = 2;
+    where Target: CompilationTarget<'a>
-    let mut queue : VecDeque<(usize, &'a Term)> = VecDeque::new();
+{
-    let mut variable_allocs : HashMap<&Var, usize> = HashMap::new();
+    let mut iter     = Target::iter(term);
-    let mut fact : Program = Vec::new();
+    let mut target   = Vec::<Target>::new();
+    let mut bindings = HashSet::new();
 
-    queue.push_back((1, t));
+    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()));
 
-    while let Some(t) = queue.pop_front() {
+                for subterm in terms {
-        match t {
+                    target.push(subterm_to_instr(subterm.as_ref(), &mut bindings));
-            (r, &Term::Clause(ref atom, ref terms)) => {
-                fact.push(MachineInstruction::GetStructure(atom.clone(),
-                                                           terms.len(),
-                                                           r));
-
-                let mut counter : usize = reg;
-
-                for t in terms {
-                    if let &Term::Var(ref var) = t.as_ref() {
-                        if !variable_allocs.contains_key(var) {
-                            variable_allocs.insert(var, counter);
-
-                            fact.push(MachineInstruction::UnifyVariable(counter));
-                            counter += 1;
-                        } else {
-                            let r = variable_allocs.get(var).unwrap();
-                            fact.push(MachineInstruction::UnifyValue(*r));
                 }
-                    } else {
-                        fact.push(MachineInstruction::UnifyVariable(counter));
-                        queue.push_back((counter, t));
-                        counter += 1;
-                    }
-                }
-
-                reg = counter;
             },
-            (r, &Term::Atom(ref atom)) =>
+            _ => {},
-                fact.push(MachineInstruction::GetStructure(atom.clone(), 0, r)),
-            (r, &Term::Var(_)) => {
-                fact.push(MachineInstruction::UnifyVariable(r));
-                return fact;
-            }
         };
     }
 
-    fact
+    target
 }

src/l0/iterators.rs

@@ -0,0 +1,98 @@
+use l0::ast::{Term};
+
+use std::collections::{VecDeque};
+use std::vec::{Vec};
+
+enum DepthFirstIteratorState<'a> {        
+    // child no., the containing clause, its vector.
+    Clause(usize, &'a Term, &'a Vec<Box<Term>>),
+    NonClause(&'a Term)
+}
+
+pub struct PostOrderIterator<'a> {
+    state_stack: Vec<DepthFirstIteratorState<'a>>        
+}
+
+impl<'a> PostOrderIterator<'a> {
+    fn push_clause(&mut self,
+                   child_num: usize,
+                   term: &'a Term,
+                   child_terms: &'a Vec<Box<Term>>)
+    {
+        self.state_stack.push(DepthFirstIteratorState::Clause(child_num,
+                                                              term,
+                                                              child_terms));
+    }
+
+    fn render_new_state(term: &'a Term) -> DepthFirstIteratorState<'a> {
+        match term {
+            &Term::Clause(_, _, ref child_terms) =>
+                DepthFirstIteratorState::Clause(0, term, child_terms),
+            _ => DepthFirstIteratorState::NonClause(term)
+        }
+    }
+
+    fn push_term(&mut self, term: &'a Term) {
+        self.state_stack.push(Self::render_new_state(term));
+    }
+}
+
+impl<'a> Iterator for PostOrderIterator<'a> {
+    type Item = &'a Term;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        while let Some(iter_state) = self.state_stack.pop() {
+            match iter_state {
+                DepthFirstIteratorState::Clause(child_num, term, child_terms) => {                    
+                    if child_num == child_terms.len() {
+                        return Some(term);
+                    } else {
+                        self.push_clause(child_num + 1, term, child_terms);
+                        self.push_term(child_terms[child_num].as_ref());
+                    }
+                },
+                DepthFirstIteratorState::NonClause(term) => return Some(term),
+            };
+        }
+
+        None
+    }
+}
+
+pub struct BreadthFirstIterator<'a> {
+    state_queue : VecDeque<&'a Term>
+}
+
+impl<'a> Iterator for BreadthFirstIterator<'a> {
+    type Item = &'a Term;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if let Some(term) = self.state_queue.pop_front() {            
+            if let &Term::Clause(_, _, ref child_terms) = term {
+                for term in child_terms {
+                    self.state_queue.push_back(term);
+                }
+
+                return Some(term);
+            }
+
+            return Some(term);
+        }
+
+        None
+    }
+}
+    
+impl<'a> Term {
+    pub fn post_order_iter(&'a self) -> PostOrderIterator<'a> {
+        let initial_state = PostOrderIterator::render_new_state(self);
+        PostOrderIterator { state_stack: vec![initial_state] }
+    }
+
+    pub fn breadth_first_iter(&'a self) -> BreadthFirstIterator<'a> {
+        let mut queue = VecDeque::new();
+        queue.push_back(self);
+        
+        BreadthFirstIterator { state_queue: queue }
+    }
+}

src/l0/l0_parser.lalrpop

@@ -1,3 +1,4 @@
+use std::cell::{Cell};
 use l0::ast::{Atom, Term, TopLevel, Var};
 
 grammar;
@@ -23,8 +24,8 @@ Term : Term = {
      <a:Atom> "(" <ts: (<BoxedTerm> ",")*> <t:BoxedTerm> ")" => {
      	      let mut ts = ts;
      	      ts.push(t);
-	      Term::Clause(a, ts)
+	      Term::Clause(Cell::new(0), a, ts)
      },
-     <Atom> => Term::Atom(<>),
+     <Atom> => Term::Atom(Cell::new(0), <>),
-     <Var>  => Term::Var(<>),
+     <Var>  => Term::Var(Cell::new(0), <>),
 };

src/l0/l0_parser.rs

@@ -1,9 +1,11 @@
+use std::cell::{Cell};
 use l0::ast::{Atom, Term, TopLevel, Var};
 extern crate lalrpop_util as __lalrpop_util;
 
 mod __parse__TopLevel {
     #![allow(non_snake_case, non_camel_case_types, unused_mut, unused_variables, unused_imports)]
 
+    use std::cell::{Cell};
     use l0::ast::{Atom, Term, TopLevel, Var};
     extern crate lalrpop_util as __lalrpop_util;
     #[allow(dead_code)]
@@ -1384,7 +1386,7 @@ pub fn __action6<
     {
      	      let mut ts = ts;
      	      ts.push(t);
-	      Term::Clause(a, ts)
+	      Term::Clause(Cell::new(0), a, ts)
      }
 }
 
@@ -1396,7 +1398,7 @@ pub fn __action7<
     (_, __0, _): (usize, Atom, usize),
 ) -> Term
 {
-    Term::Atom(__0)
+    Term::Atom(Cell::new(0), __0)
 }
 
 #[allow(unused_variables)]
@@ -1407,7 +1409,7 @@ pub fn __action8<
     (_, __0, _): (usize, Var, usize),
 ) -> Term
 {
-    Term::Var(__0)
+    Term::Var(Cell::new(0), __0)
 }
 
 #[allow(unused_variables)]

src/l0/machine.rs

@@ -1,6 +1,5 @@
-use l0::ast::{Addr, Atom, MachineInstruction, Program, Term, TopLevel, Var};
+use l0::ast::{Addr, Atom, CompiledFact, FactInstruction, QueryInstruction};
 
-use std::fmt;
 use std::vec::{Vec};
 
 #[derive(Clone)]
@@ -26,7 +25,7 @@ pub struct Machine {
     pub fail : bool,
     heap : Heap,
     mode : MachineMode,
-    pub program : Option<Program>,
+    pub program : Option<CompiledFact>,
     registers : Registers
 }
 
@@ -112,9 +111,32 @@ impl Machine {
         }
     }    
 
-    pub fn execute<'a, 'b : 'a>(&'a mut self, instr: &'b MachineInstruction) {
+    pub fn execute_query_instr<'a, 'b : 'a>(&'a mut self, instr: &'b QueryInstruction) {
         match instr {
-            &MachineInstruction::GetStructure(ref name, arity, reg) => {
+            &QueryInstruction::PutStructure(ref name, arity, reg) => {
+                self.heap.push(HeapCell::Str(self.h + 1));
+                self.heap.push(HeapCell::NamedStr(arity, name.clone()));
+
+                self.registers[reg] = self.heap[self.h].clone();
+
+                self.h += 2;
+            },
+            &QueryInstruction::SetVariable(reg) => {
+                self.heap.push(HeapCell::Ref(self.h));
+                self.registers[reg] = self.heap[self.h].clone();
+
+                self.h += 1;
+            },
+            &QueryInstruction::SetValue(reg) => {
+                self.heap.push(self.registers[reg].clone());
+                self.h += 1;
+            },
+        }
+    }
+    
+    pub fn execute_fact_instr<'a, 'b : 'a>(&'a mut self, instr: &'b FactInstruction) {
+        match instr {
+            &FactInstruction::GetStructure(ref name, arity, reg) => {
                 let addr = self.deref(Addr::RegNum(reg));
 
                 match self.lookup(addr) {
@@ -146,25 +168,7 @@ impl Machine {
                     }
                 };
             },
-            &MachineInstruction::PutStructure(ref name, arity, reg) => {
+            &FactInstruction::UnifyVariable(reg) => {
-                self.heap.push(HeapCell::Str(self.h + 1));
-                self.heap.push(HeapCell::NamedStr(arity, name.clone()));
-
-                self.registers[reg] = self.heap[self.h].clone();
-
-                self.h += 2;
-            },
-            &MachineInstruction::SetVariable(reg) => {
-                self.heap.push(HeapCell::Ref(self.h));
-                self.registers[reg] = self.heap[self.h].clone();
-
-                self.h += 1;
-            },
-            &MachineInstruction::SetValue(reg) => {
-                self.heap.push(self.registers[reg].clone());
-                self.h += 1;
-            },
-            &MachineInstruction::UnifyVariable(reg) => {
                 match self.mode {
                     MachineMode::Read  => self.registers[reg] = self.heap[self.s].clone(),
                     MachineMode::Write => {
@@ -176,7 +180,7 @@ impl Machine {
 
                 self.s += 1;
             },
-            &MachineInstruction::UnifyValue(reg) => {
+            &FactInstruction::UnifyValue(reg) => {
                 let s = self.s;
 
                 match self.mode {
@@ -198,37 +202,4 @@ impl Machine {
         *self = Machine::new();
         self.program = program;
     }    
-    
-    pub fn dump_registers_and_heap(&self) {
-        let mut c = 0;
-
-        let printer = |contents, c| {
-            match contents {
-                &HeapCell::NamedStr(ref arity, ref atom) => {
-                    println!("{} = NAME({}, {})", c, arity, atom);
-                },
-                &HeapCell::Ref(hc) => {
-                    println!("{} = REF({})", c, hc);
-                },
-                &HeapCell::Str(hc) => {
-                    println!("{} = STR({})", c, hc);
-                }
-            };
-        };
-        
-        for contents in &self.registers {
-            print!("X");
-            printer(contents, c);
-            c += 1;
-        }
-
-        println!("");
-        
-        c = 0;
-
-        for contents in &self.heap {
-            printer(contents, c);
-            c += 1;
-        }
-    }
 }

src/l0/mod.rs

@@ -1,4 +1,7 @@
+mod l0_parser;
+
 pub mod ast;
-pub mod l0_parser;
+pub mod iterators;
+pub mod parser;
 pub mod codegen;
 pub mod machine;

src/l0/parser.rs

@@ -0,0 +1,52 @@
+use l0::ast::{Term, TopLevel, Var};
+use l0::l0_parser::{parse_TopLevel};
+
+use std::collections::{HashMap};
+
+extern crate lalrpop_util as __lalrpop_util;
+
+pub type ParseResult<'a> =
+    Result<TopLevel, __lalrpop_util::ParseError<usize,(usize, &'a str),()>>;
+
+pub fn parse_top_level<'a>(input: &'a str) -> ParseResult {
+    let result = parse_TopLevel(&*input);
+    
+    if let Ok(result) = result {
+        return Ok(mark_cells(result));
+    }
+
+    result
+}
+
+#[inline]
+fn mark_cells(tl: TopLevel) -> TopLevel {
+    match tl {
+        TopLevel::Fact(term) => TopLevel::Fact(mark_term_cells(term)),
+        TopLevel::Query(term) => TopLevel::Query(mark_term_cells(term))            
+    }
+}
+    
+fn mark_term_cells(term: Term) -> Term {
+    let mut cell_num = 1;    
+    
+    {
+        let mut bindings: HashMap<&Var, usize> = HashMap::new();
+        let mut iter = term.breadth_first_iter();
+    
+        while let Some(term) = iter.next() {
+            if let &Term::Var(ref cell, ref var) = term {
+                let cell_num_in_map = bindings.entry(var).or_insert(cell_num);
+                
+                if *cell_num_in_map != cell_num {                    
+                    cell.set(*cell_num_in_map);
+                    continue;
+                }
+            }
+
+            term.set_cell(cell_num);
+            cell_num += 1;
+        }
+    }
+
+    term
+}

src/main.rs

@@ -1,28 +1,23 @@
 mod l0;
 
-use l0::ast::{Atom, Program, Term, TopLevel, Var};
+use l0::ast::{TopLevel};
-use l0::codegen::{compile_fact, compile_query};
+use l0::codegen::{compile_target};
 use l0::machine::{Machine};
 
 use std::io::{self, Write};
 
-fn print_instructions(program : &Program) {
-    for instruction in program {
-        println!("{:}", instruction);        
-    }
-}
-
 fn l0_repl() {
     let mut ms = Machine::new();
     
     loop {
         print!("l0> ");
-        io::stdout().flush();
         
+        let _ = io::stdout().flush();
         let mut buffer = String::new();
+        
         io::stdin().read_line(&mut buffer).unwrap();
         
-        let result = l0::l0_parser::parse_TopLevel(&*buffer);
+        let result = l0::parser::parse_top_level(&*buffer);
 
         if &*buffer == "quit\n" {
             break;
@@ -32,7 +27,7 @@ fn l0_repl() {
         
         match result {            
             Ok(TopLevel::Fact(fact)) => {                
-                let program = compile_fact(&fact);
+                let program = compile_target(&fact);
                                 
                 ms = Machine::new();                
                 ms.program = Some(program);                
@@ -41,14 +36,14 @@ fn l0_repl() {
             },
             Ok(TopLevel::Query(query)) => {
                 if let Some(program) = ms.program.take() {                
-                    let query = compile_query(&query);
+                    let query = compile_target(&query);
                     
                     for instruction in &query {
-                        ms.execute(instruction);
+                        ms.execute_query_instr(instruction);
                     }
 
                     for instruction in &program {                    
-                        ms.execute(instruction);
+                        ms.execute_fact_instr(instruction);
 
                         if ms.fail {                            
                             break;