before trait

diff --git a/src/lib.rs b/src/lib.rs
index ffd998e34239dcb52fdc98309f1d46bef35944c2..f61f7a211034c5fbe5aa4c4449ede7cedb0bd0f7 100644 (file)
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -10,11 +10,11 @@ pub struct NoAliasSingleton {
 }
 
 impl NoAliasSingleton {
-    pub fn as_ref<'a>(&'a mut self) -> NoAlias<'a> {
-        NoAlias(PhantomData)
+    pub fn ref_token<'a>(&'a mut self) -> RefToken<'a> {
+        RefToken(PhantomData)
     }
-    pub fn as_mut<'a>(&'a mut self) -> NoAlias<'a> {
-        NoAlias(PhantomData)
+    pub fn mut_token<'a>(&'a mut self) -> MutToken<'a> {
+        MutToken(PhantomData)
     }
 }
 
@@ -24,16 +24,25 @@ impl NoAliasSingleton {
 } */   
 
 
-// Not Clone or Copy
-pub struct NoAlias<'a>(
+#[derive(Debug, Clone, Copy)]
+pub struct RefToken<'a>(
+    PhantomData<&'a NoAliasSingleton>,
+);
+#[derive(Debug)]
+pub struct MutToken<'a>(
     PhantomData<&'a mut NoAliasSingleton>,
 );
+impl<'a> MutToken<'a>{
+    pub fn ref_token(&'a self) -> RefToken<'a> {
+        RefToken(PhantomData)
+    }
+}
 
-impl<'a> NoAlias<'a> {
-    pub fn reborrow<'s: 'a>(&'s mut self) -> NoAlias<'a> {
+/*impl<'a> MutToken<'a> {
+    pub fn reborrow<'s: 'a>(&'s mut self) -> MutToken<'a> {
         todo!()
     }
-}
+}*/
 
 pub struct Ptr<T> {
     // invariant over T?
@@ -62,10 +71,10 @@ TODO lifetime is hard
 */
 
     #[inline]
-    pub fn borrow<'na>(self, na: &'na NoAlias<'na>) -> &'na T { todo!() }
+    pub fn borrow<'na>(self, na: &'na RefToken<'na>) -> &'na T { todo!() }
 
     #[inline]
-    pub fn borrow_mut<'na>(self, g: &mut NoAlias<'na>) -> &'na mut T {
+    pub fn borrow_mut<'na>(self, g: &mut MutToken<'na>) -> &'na mut T {
         todo!()
     }
 
@@ -87,7 +96,7 @@ TODO lifetime is hard
     /// ("used" means passed to any method in this library).
     ///
     /// (The compiler will check that no borrows are live.)
-    pub unsafe fn free_heap(self, g: &mut NoAlias) -> T { todo!() }
+    pub unsafe fn free_heap(self, g: &mut MutToken) -> T { todo!() }
 }
 
 /*struct MultiAccessor<'a, R, const N: usize> {
@@ -99,7 +108,7 @@ impl NoAliasSingleton {
     /// There must be only one `NoAliasSingleton` used with each `Ptr`.
     ///
     /// That is, it is unsound to use the same `Ptr` (or any copy of it)
-    /// with `NoAlias`es derived from
+    /// with `MutToken`es derived from
     /// two (or more) different `NoAliasSingleton`s.
     ///
     /// The easiest way to do this is to have only one `NoAliasSingleton`.
@@ -111,7 +120,7 @@ impl NoAliasSingleton {
     pub unsafe fn init() -> Self { todo!() }
 }
 
-impl<'a> NoAlias<'a> {
+impl<'a> MutToken<'a> {
 /*
     pub fn multi(&mut self) -> MultiAccessor<(), 0> { todo!() }
 */
@@ -121,7 +130,7 @@ impl<'a> NoAlias<'a> {
 impl MultiAccessor<'a, R, const N: usize> {
     pub fn finish(self) -> R { todo!() }
 
-    pub fn borrow<T>(self, p: &mut NoAlias
+    pub fn borrow<T>(self, p: &mut MutToken
 */
 
 #[cfg(test)]
@@ -161,21 +170,22 @@ mod tests {
             }
 
             pub fn front(&self) -> Option<&T> {
-                let noalias = self.noalias.as_ref();
+                let tok = self.noalias.ref_token();
                 let head = self.head?;
-                Some(self.head.borrow(noalias))
+                Some(&head.borrow(&tok).data)
             }
 
             pub fn front_mut(&mut self) -> Option<&T> {
-                let noalias = self.noalias.as_mut();
+                let mut tok = self.noalias.mut_token();
+                let tok = &mut tok;
                 let head = self.head?;
-                Some(self.head.borrow_mut(noalias))
+                Some(&mut head.borrow_mut(tok).data)
             }
 
             pub fn pop_front(&mut self) -> Option<T> {
-                let mut noalias = self.noalias.as_mut();
-                let noalias = &mut noalias;
-                self.pop_front_inner(
+                let mut noalias = self.noalias.mut_token();
+                let tok = &mut noalias;
+                Self::pop_front_inner(
                     noalias,
                     &mut self.head,
                     &mut self.tail,
@@ -185,12 +195,12 @@ mod tests {
             // We wouldn't do this, since it's daft, but
             // it lets us demonstrate passing a NoAlias.
             fn pop_front_inner(
-                noalias: NoAlias,
-                head: &mut Option<Ptr<T>>,
-                tail: &mut Option<Ptr<T>>,
+                noalias: MutToken,
+                head: &mut Option<Ptr<Node<T>>>,
+                tail: &mut Option<Ptr<Node<T>>>,
             ) -> Option<T> {
-                let deleting = *head?;
-                let new_head = deleting.borrow(noalias).next;
+                let deleting = (*head)?;
+                let new_head = deleting.borrow(&noalias.ref_token()).next;
                 *head = new_head;
                 if let Some(new_head) = new_head {
                     new_head.borrow_mut(noalias).back = None;