cleanup

src/lib.rs

···
 
     /// this function never blocks. (`fetch_update` loop doesn't count)
     pub fn lock(&mut self) -> ReadGuard<'_, T> {
-        let shared_ref = self.shared_ref();
-
+        // SAFETY: value just locked
+        let value = unsafe { &*self.shared_ref().lock_read().get() };
         ReadGuard {
-            shared: shared_ref,
-            value: shared_ref.lock_read(),
-            reader: PhantomData,
+            value,
+            reader: self,
         }
     }
 }
···
 /// Doesn't implement Clone as that would require refcounting to know when to unlock.
 #[derive(Debug)]
 pub struct ReadGuard<'a, T> {
-    shared: &'a Shared<T>,
-    value: Ptr,
-    /// `PhantomData` makes the borrow checker prove that there only ever is one `ReadGuard`.
-    /// This allows resetting the readstate without some kind of counter
-    reader: PhantomData<&'a mut Reader<T>>,
+    reader: &'a Reader<T>,
+    value: &'a T,
 }
 
 impl<T> Deref for ReadGuard<'_, T> {
     type Target = T;
 
     fn deref(&self) -> &Self::Target {
-        // SAFETY: ReadGuard was created, so the Writer knows not to write in this spot
-        unsafe { self.shared.get_value_ref(self.value) }
+        self.value
     }
 }
 
···
     }
 }
 
-// /// SAFETY: behaves like a ref to T. https://doc.rust-lang.org/std/marker/trait.Sync.html
-// unsafe impl<T: Sync> Send for ReadGuard<'_, T> {}
-// /// SAFETY: behaves like a ref to T. https://doc.rust-lang.org/std/marker/trait.Sync.html
-// unsafe impl<T: Sync> Sync for ReadGuard<'_, T> {}
-
 impl<T> Drop for ReadGuard<'_, T> {
     fn drop(&mut self) {
         // release the read lock
-        self.shared.release_read_lock();
+        self.reader.shared_ref().release_read_lock();
     }
 }
 
···
 /// Dropping this makes all changes available to the Reader.
 #[derive(Debug)]
 pub struct WriteGuard<'a, T, O> {
+    // can't hold a mut ref to T, as then it wouldn't be possible to write to both at the same time,
+    // which is an optimization i want to keep.
     writer: &'a mut Writer<T, O>,
 }
 

src/shared.rs

···
 }
 
 impl<T> Shared<T> {
-    pub(crate) fn lock_read(&self) -> Ptr {
+    pub(crate) fn lock_read(&self) -> &UnsafeCell<T> {
         // fetch update loop could be replaced with:
         // - set read state to both
         // - read read ptr
···
         // SAFETY: fetch_update closure always returns Some, so the result is alwyays Ok
         let result = unsafe { result.unwrap_unchecked() };
         // result is the previous value, so the read_state isn't set, only the read_ptr
-        State::new(result).read_ptr()
+        let ptr = State::new(result).read_ptr();
+        self.get_value(ptr)
     }
 
     pub(crate) fn release_read_lock(&self) {