milestone marker for surgery

src/iterators.rs

@@ -6,6 +6,8 @@ use crate::parser::ast::*;
 use std::cell::Cell;
 use std::collections::VecDeque;
 use std::fmt;
+use std::fmt::Debug;
+use std::hash::{Hash, Hasher};
 use std::iter::*;
 use std::rc::Rc;
 use std::vec::Vec;
@@ -35,6 +37,58 @@ impl<'a> TermRef<'a> {
     }
 }
 
+#[derive(Clone, Debug)]
+pub(crate) struct RcMutPtr<T: Debug> {
+    owned: Rc<T>,
+    ptr: *mut Rc<T>,
+}
+
+impl<T: Debug> RcMutPtr<T> {
+    #[inline]
+    pub(crate) fn new(rc: &Rc<T>) -> Self {
+        Self { owned: rc.clone(), ptr: rc as *const _ as *mut _ }
+    }
+
+    #[inline]
+    pub(crate) fn owned(&self) -> Rc<T> {
+        self.owned.clone()
+    }
+
+    #[inline]
+    pub(crate) fn set(&mut self, var_b_marker: &Rc<T>) {
+        self.owned = var_b_marker.clone();
+
+        unsafe {
+            if !self.ptr.is_null() {
+                *self.ptr = self.owned.clone();
+            }
+        }
+    }
+}
+
+impl<T: Debug> From<T> for RcMutPtr<T> {
+    #[inline]
+    fn from(value: T) -> RcMutPtr<T> {
+        let owned = Rc::new(value);
+        RcMutPtr { owned, ptr: std::ptr::null_mut() }
+    }
+}
+
+impl<T: Debug + PartialEq> PartialEq for RcMutPtr<T> {
+    fn eq(&self, rhs: &Self) -> bool {
+        &self.owned == &rhs.owned
+    }
+}
+
+impl<T: Debug + Eq> Eq for RcMutPtr<T> {}
+
+impl<T: Debug + Hash> Hash for RcMutPtr<T> {
+    #[inline(always)]
+    fn hash<H: Hasher>(&self, hasher: &mut H) {
+        self.owned.hash(hasher)
+    }
+}
+
 #[derive(Debug)]
 pub(crate) enum TermIterState<'a> {
     AnonVar(Level),
@@ -45,7 +99,7 @@ pub(crate) enum TermIterState<'a> {
     InitialPartialString(Level, &'a Cell<RegType>, &'a String, &'a Box<Term>),
     FinalPartialString(Level, &'a Cell<RegType>, &'a String, &'a Box<Term>),
     CompleteString(Level, &'a Cell<RegType>, Atom),
-    Var(Level, &'a Cell<VarReg>, Rc<String>),
+    Var(Level, &'a Cell<VarReg>, RcMutPtr<String>),
 }
 
 impl<'a> TermIterState<'a> {
@@ -65,7 +119,7 @@ impl<'a> TermIterState<'a> {
             Term::CompleteString(cell, atom) => {
                 TermIterState::CompleteString(lvl, cell, *atom)
             }
-            Term::Var(cell, var) => TermIterState::Var(lvl, cell, var.clone()),
+            Term::Var(cell, var) => TermIterState::Var(lvl, cell, RcMutPtr::new(var)),
         }
     }
 }
@@ -106,7 +160,7 @@ impl<'a> QueryIterator<'a> {
                 *name,
                 terms,
             ),
-            Term::Var(cell, var) => TermIterState::Var(Level::Root, cell, var.clone()),
+            Term::Var(cell, var) => TermIterState::Var(Level::Root, cell, RcMutPtr::new(var)),
         };
 
         QueryIterator {
@@ -129,13 +183,13 @@ impl<'a> QueryIterator<'a> {
                 }
             }
             &QueryTerm::UnblockedCut(ref cell) => {
-                let state = TermIterState::Var(Level::Root, cell, Rc::new("!".to_string()));
+                let state = TermIterState::Var(Level::Root, cell, RcMutPtr::from("!".to_string()));
                 QueryIterator {
                     state_stack: vec![state],
                 }
             }
             &QueryTerm::GetLevelAndUnify(ref cell, ref var) => {
-                let state = TermIterState::Var(Level::Root, cell, var.clone());
+                let state = TermIterState::Var(Level::Root, cell, RcMutPtr::new(var));
                 QueryIterator {
                     state_stack: vec![state],
                 }
@@ -213,7 +267,7 @@ impl<'a> Iterator for QueryIterator<'a> {
                     return Some(TermRef::Literal(lvl, cell, constant));
                 }
                 TermIterState::Var(lvl, cell, var) => {
-                    return Some(TermRef::Var(lvl, cell, var));
+                    return Some(TermRef::Var(lvl, cell, var.owned()));
                 }
             };
         }
@@ -279,7 +333,7 @@ impl<'a> FactIterator<'a> {
                 vec![TermIterState::Literal(Level::Root, cell, constant)]
             }
             Term::Var(cell, var) => {
-                vec![TermIterState::Var(Level::Root, cell, var.clone())]
+                vec![TermIterState::Var(Level::Root, cell, RcMutPtr::new(var))]
             }
         };
 
@@ -326,7 +380,7 @@ impl<'a> Iterator for FactIterator<'a> {
                     return Some(TermRef::Literal(lvl, cell, constant))
                 }
                 TermIterState::Var(lvl, cell, var) => {
-                    return Some(TermRef::Var(lvl, cell, var));
+                    return Some(TermRef::Var(lvl, cell, var.owned()));
                 }
                 _ => {}
             }
@@ -530,38 +584,3 @@ impl<'a> Iterator for ChunkedIterator<'a> {
         self.iter.next().map(|term| self.take_chunk(term))
     }
 }
-
-/*
-================================================================================
-
-This is a disjunction compilation experiment attempting to
-adapt the paper "Compiling Large Disjunctions" to Scryer Prolog.
-
-================================================================================
-*/
-
-enum VarInfo {
-    Perm,
-    Temp,
-    Void
-}
-
-pub struct ChunkInfo {
-    chunk_num: usize,
-    vars: Vec<(Rc<Var>, VarInfo)>,
-}
-
-pub struct BranchInfo {
-    branch_num: usize, // TODO: Rational?? or own type?
-    delta: usize, // TODO: Rational??
-    chunks: Vec<ChunkInfo>,
-}
-
-pub struct ControlIterator<'a> {
-    current_branch_num: usize, // TODO: same as above
-    state_stack: Vec<TermIterState<'a>>,
-    branch_map: IndexMap<Rc<Var>, Vec<BranchInfo>>,
-}
-
-impl ControlIterator {
-}