diff --git a/src/praetor/mod.rs b/src/praetor/mod.rs
index a19deef..1e24237 100644
--- a/src/praetor/mod.rs
+++ b/src/praetor/mod.rs
@@ -89,7 +89,10 @@ mod util {
     // anything, but generally have an alignment of 8, and can be specified to
     // be aligned to `n` with `#[repr(align(n))]`.
     #[repr(transparent)]
-    pub struct TaggedAtomicPtr<T, const BITS: usize>(AtomicPtr<()>, PhantomData<T>);
+    pub struct TaggedAtomicPtr<T, const BITS: usize> {
+        ptr: AtomicPtr<()>,
+        _pd: PhantomData<T>,
+    }
 
     impl<T, const BITS: usize> TaggedAtomicPtr<T, BITS> {
         const fn mask() -> usize {
@@ -99,16 +102,16 @@ mod util {
         pub fn new(ptr: *mut T, tag: usize) -> TaggedAtomicPtr<T, BITS> {
             debug_assert!(core::mem::align_of::<T>().ilog2() as usize >= BITS);
             let mask = Self::mask();
-            Self(
-                AtomicPtr::new(ptr.with_addr((ptr.addr() & !mask) | (tag & mask)).cast()),
-                PhantomData,
-            )
+            Self {
+                ptr: AtomicPtr::new(ptr.with_addr((ptr.addr() & !mask) | (tag & mask)).cast()),
+                _pd: PhantomData,
+            }
         }
 
         pub fn ptr(&self, order: Ordering) -> NonNull<T> {
             unsafe {
                 NonNull::new_unchecked(
-                    self.0
+                    self.ptr
                         .load(order)
                         .map_addr(|addr| addr & !Self::mask())
                         .cast(),
@@ -117,7 +120,7 @@ mod util {
         }
 
         pub fn tag(&self, order: Ordering) -> usize {
-            self.0.load(order).addr() & Self::mask()
+            self.ptr.load(order).addr() & Self::mask()
         }
 
         /// returns tag
@@ -137,12 +140,12 @@ mod util {
             ) -> Result<*mut (), *mut ()>,
         ) -> Result<usize, usize> {
             let mask = Self::mask();
-            let old_ptr = self.0.load(failure);
+            let old_ptr = self.ptr.load(failure);
 
             let old = old_ptr.map_addr(|addr| (addr & !mask) | (old & mask));
             let new = old_ptr.map_addr(|addr| (addr & !mask) | (new & mask));
 
-            let result = cmpxchg(&self.0, old, new, success, failure);
+            let result = cmpxchg(&self.ptr, old, new, success, failure);
 
             result
                 .map(|ptr| ptr.addr() & mask)
@@ -191,10 +194,10 @@ mod util {
             let mask = Self::mask();
             let ptr = ptr.cast::<()>();
             loop {
-                let old = self.0.load(failure);
+                let old = self.ptr.load(failure);
                 let new = ptr.map_addr(|addr| (addr & !mask) | (old.addr() & mask));
                 if self
-                    .0
+                    .ptr
                     .compare_exchange_weak(old, new, success, failure)
                     .is_ok()
                 {
@@ -206,11 +209,11 @@ mod util {
         pub fn set_tag(&self, tag: usize, success: Ordering, failure: Ordering) {
             let mask = Self::mask();
             loop {
-                let ptr = self.0.load(failure);
+                let ptr = self.ptr.load(failure);
                 let new = ptr.map_addr(|addr| (addr & !mask) | (tag & mask));
 
                 if self
-                    .0
+                    .ptr
                     .compare_exchange_weak(ptr, new, success, failure)
                     .is_ok()
                 {
@@ -221,7 +224,7 @@ mod util {
 
         pub fn ptr_and_tag(&self, order: Ordering) -> (NonNull<T>, usize) {
             let mask = Self::mask();
-            let ptr = self.0.load(order);
+            let ptr = self.ptr.load(order);
             let tag = ptr.addr() & mask;
             let ptr = ptr.map_addr(|addr| addr & !mask);
             let ptr = unsafe { NonNull::new_unchecked(ptr.cast()) };