better code structure, especially with unsafe.

Cargo.lock

···
  "basedrop",
  "cpal",
  "crossbeam-utils",
+ "futures-io",
  "futures-lite",
  "hound",
  "rtrb",

simple-left-right/src/inner.rs

···
 use core::{cell::UnsafeCell, hint::unreachable_unchecked, sync::atomic::AtomicU8};
 
 #[derive(PartialEq, Eq, Clone, Copy, Debug)]
-pub enum Ptr {
+pub(crate) enum Ptr {
     Value1,
     Value2,
 }
 
 impl Ptr {
-    #[inline]
-    pub fn switch(&mut self) {
+    pub(crate) fn switch(&mut self) {
         *self = match self {
             Ptr::Value1 => Self::Value2,
             Ptr::Value2 => Self::Value1,
         };
     }
-}
+
+    /// SAFETY: Assumes no read bits (lower two) are set
+    pub(crate) unsafe fn from_u8_no_read(value: u8) -> Self {
+        match value {
+            0b000 => Self::Value1,
+            0b100 => Self::Value2,
+            // SAFETY: unsafe fn. communicated in docs
+            _ => unsafe { unreachable_unchecked() },
+        }
+    }
 
-impl From<u8> for Ptr {
-    #[inline]
-    fn from(value: u8) -> Self {
+    /// ignores potentially set read bits.
+    /// SAFETY: no bits except the for bottom three can be set
+    pub(crate) unsafe fn from_u8_ignore_read(value: u8) -> Self {
         match value & 0b100 {
             0b000 => Self::Value1,
             0b100 => Self::Value2,
-            // SAFETY: Internal Library Value only.
+            // SAFETY: unsafe fn. communicated in docs
             _ => unsafe { unreachable_unchecked() },
         }
     }
 }
 
 #[derive(Debug)]
-pub enum ReadState {
+pub(crate) enum ReadState {
     None,
     Value(Ptr),
-    /// Is written before loading the ptr value and then instantly overwritten with the specific ptr value
-    /// This makes sure the Writer doesn't swap and load between loading the ptr and setting the read
-    Both,
 }
 
 impl ReadState {
     /// is writing on the passed ptr parameter valid with the current read state?
     #[inline]
-    pub fn can_write(&self, ptr: Ptr) -> bool {
+    pub(crate) fn can_write(&self, ptr: Ptr) -> bool {
         match self {
             ReadState::None => true,
             ReadState::Value(p) => *p != ptr,
-            ReadState::Both => false,
         }
     }
-}
 
-impl From<Ptr> for ReadState {
-    #[inline]
-    fn from(value: Ptr) -> Self {
-        Self::Value(value)
-    }
-}
-
-impl From<u8> for ReadState {
-    #[inline]
-    fn from(value: u8) -> Self {
+    /// SAFETY: only the read state bits are set
+    pub(crate) unsafe fn from_u8_ignore_ptr(value: u8) -> Self {
         match value & 0b011 {
             0b00 => Self::None,
             0b01 => Self::Value(Ptr::Value1),
             0b10 => Self::Value(Ptr::Value2),
-            0b11 => Self::Both,
             // SAFETY: Internal Library Value only.
             _ => unsafe { unreachable_unchecked() },
         }
     }
 }
 
+impl From<Ptr> for ReadState {
+    #[inline]
+    fn from(value: Ptr) -> Self {
+        Self::Value(value)
+    }
+}
+
 #[derive(Debug)]
-pub struct Shared<T> {
+pub(crate) struct Shared<T> {
     pub value_1: UnsafeCell<T>,
     pub value_2: UnsafeCell<T>,
     /// bit 0: is value 1 being read
···
 unsafe impl<T: Send + Sync> Sync for Shared<T> {}
 
 impl<T> Shared<T> {
-    pub fn get_value(&self, ptr: Ptr) -> &UnsafeCell<T> {
+    pub(crate) fn get_value(&self, ptr: Ptr) -> &UnsafeCell<T> {
         match ptr {
             Ptr::Value1 => &self.value_1,
             Ptr::Value2 => &self.value_2,

simple-left-right/src/lib.rs

···
     clippy::missing_safety_doc,
     clippy::undocumented_unsafe_blocks
 )]
-
 #![cfg_attr(not(feature = "std"), no_std)]
 
 extern crate alloc;
 
 #[cfg(feature = "std")]
-use std::thread;
-#[cfg(feature = "std")]
 use core::time::Duration;
+#[cfg(feature = "std")]
+use std::thread;
 
 use core::{
-    hint::assert_unchecked,
+    cell::UnsafeCell,
     marker::PhantomData,
     mem::MaybeUninit,
     ops::Deref,
-    sync::atomic::{fence, AtomicU8, Ordering}
+    sync::atomic::{fence, AtomicU8, Ordering},
 };
 
 use alloc::{collections::vec_deque::VecDeque, sync::Arc};
···
         // sets the corresponding read bit to the write ptr bit
         // happens as a single atomic operation so the 'double read' state isn't needed
         // ptr bit doesnt get changed
+        // always Ok, as the passed closure never returns None
         let update_result =
             self.inner
                 .state
                 .fetch_update(Ordering::Relaxed, Ordering::Acquire, |value| {
                     // SAFETY: At this point no Read bit is set, as creating a ReadGuard requires a &mut Reader and the Guard holds the &mut Reader
                     unsafe {
-                        assert_unchecked(value & 0b011 == 0);
-                    }
-                    match value.into() {
-                        Ptr::Value1 => Some(0b001),
-                        Ptr::Value2 => Some(0b110),
+                        match Ptr::from_u8_no_read(value) {
+                            Ptr::Value1 => Some(0b001),
+                            Ptr::Value2 => Some(0b110),
+                        }
                     }
                 });
 
-        // SAFETY: the passed clorusure always returns Some, so fetch_update never returns Err
-        let ptr = unsafe { update_result.unwrap_unchecked().into() };
+        // here the read ptr and read state of update_result match. maybe the atomic was already changed, but that doesn't matter.
+        // we continue working with the state that we set.
+
+        // SAFETY: the passed closure always returns Some, so fetch_update never returns Err
+        let ptr = unsafe {
+            // here it doesn't matter if we create the Ptr from the read bits or from the ptr bit, as they match
+            Ptr::from_u8_ignore_read(update_result.unwrap_unchecked())
+        };
 
-        // SAFETY: the Writer always sets the Read bit to the opposite of its write_ptr
+        // SAFETY: the Writer allowed the read on this value because the ptr bit was set. The read bit has been set
         let data = unsafe { self.inner.get_value(ptr).get().as_ref().unwrap_unchecked() };
 
-        // SAFETY: the read_state is set to the value that is being
         ReadGuard {
             data,
             state: &self.inner.state,
···
     pub fn swap(self) {}
 
     /// Gets the value currently being written to.
-    #[must_use]
     pub fn read(&self) -> &T {
         self.writer.read()
     }
···
     fn get_data_mut(&mut self) -> &mut T {
         // SAFETY: When creating the writeguad it is checked that the reader doesnt have access to the same data
         // This function requires &mut self so there also isn't any ref created by writeguard.
-        unsafe { self.get_data_ptr().as_mut().unwrap() }
-    }
-
-    fn get_data_ptr(&self) -> *mut T {
-        self.writer.shared.get_value(self.writer.write_ptr).get()
+        // SAFETY: the ptr is never null, therefore unwrap_unchecked
+        unsafe {
+            self.writer
+                .shared
+                .get_value(self.writer.write_ptr)
+                .get()
+                .as_mut()
+                .unwrap_unchecked()
+        }
     }
 }
 
···
     /// Blocks if the Reader has a `ReadGuard` pointing to the old value.
     ///
     /// Uses a Spinlock because for anything else the OS needs to be involved and `Reader` can't talk to the OS.
-    #[cfg(not(feature = "std"))]
     pub fn lock(&mut self) -> WriteGuard<'_, T, O> {
         let backoff = crossbeam_utils::Backoff::new();
 
···
             // operation has to be aquire, but only the time it breaks the loop
             let state = self.shared.state.load(Ordering::Relaxed);
 
-            if ReadState::from(state).can_write(self.write_ptr) {
+            // SAFETY: is in state internal only value which is only set by library code
+            let state = unsafe { ReadState::from_u8_ignore_ptr(state) };
+
+            if state.can_write(self.write_ptr) {
                 // make the load operation aquire only when it actually breaks the loop
                 // the important (last) load is aquire, while all loads before are relaxed
                 fence(Ordering::Acquire);
···
     }
 
     /// Blocks if the Reader has a `ReadGuard` pointing to the old value.
-    /// 
+    ///
     /// Uses a spin-lock, because the `Reader` can't talk to the OS. Sleeping and Yielding is done to avoid wasting cycles.
     /// Equivalent to ´lock´, except that it starts sleeping the given duration after a certaint point until the lock could be aquired.
     #[cfg(feature = "std")]
-    pub fn lock(&mut self, sleep: Duration) -> WriteGuard<'_, T, O> {
+    pub fn sleep_lock(&mut self, sleep: Duration) -> WriteGuard<'_, T, O> {
         let backoff = crossbeam_utils::Backoff::new();
 
         loop {
             // operation has to be aquire, but only the time it breaks the loop
             let state = self.shared.state.load(Ordering::Relaxed);
 
-            if ReadState::from(state).can_write(self.write_ptr) {
+            // SAFETY: is in state internal only value which is only set by library code
+            let state = unsafe { ReadState::from_u8_ignore_ptr(state) };
+
+            if state.can_write(self.write_ptr) {
                 // make the load operation aquire, only when it actually breaks the loop
                 // the important (last) load is aquire, while all loads before are relaxed
                 fence(Ordering::Acquire);
···
             // operation has to be aquire, but only the time it breaks the loop
             let state = self.shared.state.load(Ordering::Relaxed);
 
-            if ReadState::from(state).can_write(self.write_ptr) {
+            // SAFETY: is in state internal only value which is only set by library code
+            let state = unsafe { ReadState::from_u8_ignore_ptr(state) };
+
+            if state.can_write(self.write_ptr) {
                 // make the load operation aquire, only when it actually breaks the loop
                 // the important (last) load is aquire, while all loads before are relaxed
                 fence(Ordering::Acquire);
···
     pub fn try_lock(&mut self) -> Option<WriteGuard<'_, T, O>> {
         let state = self.shared.state.load(Ordering::Acquire);
 
-        if ReadState::from(state).can_write(self.write_ptr) {
+        // SAFETY: is in state internal only value which is only set by library code
+        let state = unsafe { ReadState::from_u8_ignore_ptr(state) };
+
+        if state.can_write(self.write_ptr) {
             // SAFETY: ReadState allows this
             unsafe { Some(WriteGuard::new(self)) }
         } else {
···
         let shared = unsafe {
             let shared_ptr = Arc::get_mut(&mut shared).unwrap_unchecked().as_mut_ptr();
             (&raw mut (*shared_ptr).state).write(AtomicU8::new(0b000));
-            (&raw mut (*shared_ptr).value_1).cast::<T>().write(value.clone());
-            (&raw mut (*shared_ptr).value_2).cast::<T>().write(value);
+            UnsafeCell::raw_get(&raw const (*shared_ptr).value_1).write(value.clone());
+            UnsafeCell::raw_get(&raw const (*shared_ptr).value_1).write(value);
             shared.assume_init()
         };
 
···
     /// Creates a new Writer by calling `T::default()` twice to create the two values
     ///
     /// Default impl of T needs to give the same result every time. Not upholding this doens't lead to UB, but turns the library basically useless
+    ///
+    /// Could leak a T object if T::default() panics.
     fn default() -> Self {
         let mut shared: Arc<MaybeUninit<Shared<T>>> = Arc::new_uninit();
 
···
         let shared = unsafe {
             let shared_ptr = Arc::get_mut(&mut shared).unwrap_unchecked().as_mut_ptr();
             (&raw mut (*shared_ptr).state).write(AtomicU8::new(0b000));
-            (&raw mut (*shared_ptr).value_1).cast::<T>().write(T::default());
-            (&raw mut (*shared_ptr).value_2).cast::<T>().write(T::default());
+            UnsafeCell::raw_get(&raw const (*shared_ptr).value_1).write(T::default());
+            UnsafeCell::raw_get(&raw const (*shared_ptr).value_1).write(T::default());
             shared.assume_init()
         };
 

simple-left-right/tests/tests.rs

···
 #[cfg(test)]
 mod tests {
-    use simple_left_right::Writer;
-    use std::time::Duration;
+    use simple_left_right::{Absorb, Writer};
+    use std::{cell::Cell, time::Duration};
+
+    #[derive(Clone)]
+    pub struct CounterAddOp(i32);
+
+    impl Absorb<CounterAddOp> for i32 {
+        fn absorb(&mut self, operation: CounterAddOp) {
+            *self += operation.0;
+        }
+    }
 
-    include!("utilities.rs");
+    impl Absorb<CounterAddOp> for Cell<i32> {
+        fn absorb(&mut self, operation: CounterAddOp) {
+            self.set(self.get() + operation.0);
+        }
+    }
 
     #[test]
     fn send_writer() {
···
         let mut reader = writer.build_reader().unwrap();
         let sleep = Duration::from_millis(5);
         assert_eq!(*reader.lock(), 0);
-        let mut write_lock = writer.lock(sleep);
+        let mut write_lock = writer.sleep_lock(sleep);
         assert_eq!(*write_lock.read(), 0);
         write_lock.apply_op(CounterAddOp(2));
         assert_eq!(*write_lock.read(), 2);
         drop(write_lock);
-        let write_lock = writer.lock(sleep);
+        let write_lock = writer.sleep_lock(sleep);
         assert_eq!(*write_lock.read(), 2);
         write_lock.swap();
         assert_eq!(*reader.lock(), 2);
-        assert_eq!(*writer.lock(sleep).read(), 2);
+        assert_eq!(*writer.sleep_lock(sleep).read(), 2);
     }
 
     #[test]
···
         let mut reader = writer.build_reader().unwrap();
         let sleep = Duration::from_millis(5);
 
-        writer.lock(sleep).apply_op(CounterAddOp(2));
+        writer.sleep_lock(sleep).apply_op(CounterAddOp(2));
         std::thread::spawn(move || {
             let lock = reader.lock();
             assert_eq!(*lock, 0);
···
             assert_eq!(*reader.lock(), 2);
         });
         std::thread::sleep(Duration::from_secs(1));
-        writer.lock(sleep).swap();
+        writer.sleep_lock(sleep).swap();
         // blocks until the spawned thread drops the read_lock
-        let write_lock = writer.lock(sleep);
+        let write_lock = writer.sleep_lock(sleep);
         assert_eq!(*write_lock.read(), 2);
     }
 

simple-left-right/tests/utilities.rs

···
-use simple_left_right::Absorb;
-
-#[cfg(test)]
-#[derive(Clone)]
-pub struct CounterAddOp(i32);
-
-#[cfg(test)]
-impl Absorb<CounterAddOp> for i32 {
-    fn absorb(&mut self, operation: CounterAddOp) {
-        *self += operation.0;
-    }
-}

tracker-engine/Cargo.toml

···
 categories = ["audio"]
 
 [features]
-async = ["dep:async-io", "dep:futures-lite", "dep:async-channel", "simple-left-right/async"]
+async = ["dep:async-io", "dep:futures-lite", "dep:async-channel", "dep:futures-io", "simple-left-right/async"]
 
 [dependencies]
 async-io = { version = "2.3.4", optional = true }
 futures-lite = { version = "2.3.0", optional = true }
 async-channel = { version = "2.3.1", optional = true }
+futures-io = { version = "0.3.31", optional = true }
 # added a couple features to it. pull requests don' really progress
 basedrop = "0.1.2" # miri reports Race Condition. Wait for fix or pull inside
 cpal = "0.15.3"

tracker-engine/src/live_audio.rs

···
         }
     }
 
+    // unsure wether i want to use this or untyped_callback
+    // also relevant when cpal gets made into a generic that maybe this gets useful
+    #[expect(dead_code)]
     pub fn get_typed_callback<S: cpal::SizedSample + cpal::FromSample<f32>>(
         mut self,
     ) -> impl FnMut(&mut [S], &cpal::OutputCallbackInfo) {
-        move |data, info| {
+        move |data, _info| {
             assert_eq!(
                 data.len(),
                 usize::try_from(self.config.buffer_size).unwrap()
···
     }
 }
 
+// only used for testing
+// if not testing is unused
+#[allow(dead_code)]
 fn sine(output: &mut [[f32; 2]], sample_rate: f32) {
     let mut sample_clock = 0f32;
     for frame in output {

tracker-engine/src/manager.rs

···
     /// Spinloops until no more ReadGuard to the old value exists
     pub fn edit_song(&mut self) -> SongEdit<'_> {
         SongEdit {
-            song: self.song.lock(Self::SPIN_SLEEP),
+            song: self.song.sleep_lock(Self::SPIN_SLEEP),
             gc: &mut self.gc
         }
     }

tracker-engine/src/project/song.rs

···
 }
 
 impl Song<false> {
+    // to avoid cloning patterns
+    #[expect(clippy::wrong_self_convention)]
     pub(crate) fn to_gc(self, handle: &basedrop::Handle) -> Song<true> {
         Song {
             global_volume: self.global_volume,
···
             initial_tempo: self.initial_tempo,
             pan_separation: self.pan_separation,
             pitch_wheel_depth: self.pitch_wheel_depth,
-            patterns: self.patterns.clone(),
+            patterns: self.patterns,
             pattern_order: self.pattern_order,
             volume: self.volume,
             pan: self.pan,

tracker-engine/src/sample.rs

···
         }
     }
 
-    pub fn get_ref(&self) -> SampleRef<'static, true> {
+    pub(crate) fn get_ref(&self) -> SampleRef<'static, true> {
         let data = unsafe { self.gc.deref().clone() };
         SampleRef::<'static, true>::new(data)
     }
···
         unsafe { &self.owned }
     }
 
-    pub fn get_ref<'a>(&'a self) -> SampleRef<'a, false> {
+    pub(crate) fn get_ref<'a>(&'a self) -> SampleRef<'a, false> {
         SampleRef::<'a, false>::new(unsafe { &self.owned })
     }
 
···
         out
     }
 
-    pub fn to_gc(self, handle: &basedrop::Handle) -> Sample<true> {
+    // avoids copying the underlaying data. As soon as SampleData gets ?Sized this should change
+    #[expect(clippy::wrong_self_convention)]
+    pub(crate) fn to_gc(self, handle: &basedrop::Handle) -> Sample<true> {
         let data = self.take();
         let shared = basedrop::Shared::new(handle, data);
         Sample::<true>::new(shared)