diff --git a/packages/signals/src/global/memo.rs b/packages/signals/src/global/memo.rs
index 23284f8ec..b34eff989 100644
--- a/packages/signals/src/global/memo.rs
+++ b/packages/signals/src/global/memo.rs
@@ -51,7 +51,7 @@ impl<T: PartialEq + 'static> GlobalMemo<T> {
     }
 }
 
-impl<T: PartialEq + 'static> crate::ReadableRef for GlobalMemo<T> {
+impl<T: PartialEq + 'static> Readable<T> for GlobalMemo<T> {
     type Ref<R: ?Sized + 'static> = generational_box::GenerationalRef<std::cell::Ref<'static, R>>;
 
     fn map_ref<I, U: ?Sized, F: FnOnce(&I) -> &U>(ref_: Self::Ref<I>, f: F) -> Self::Ref<U> {
@@ -64,9 +64,7 @@ impl<T: PartialEq + 'static> crate::ReadableRef for GlobalMemo<T> {
     ) -> Option<Self::Ref<U>> {
         <UnsyncStorage as AnyStorage>::try_map(ref_, f)
     }
-}
 
-impl<T: PartialEq + 'static> Readable<T> for GlobalMemo<T> {
     #[track_caller]
     fn read(&self) -> Self::Ref<T> {
         self.signal().read()
diff --git a/packages/signals/src/global/signal.rs b/packages/signals/src/global/signal.rs
index bc3698149..34da37429 100644
--- a/packages/signals/src/global/signal.rs
+++ b/packages/signals/src/global/signal.rs
@@ -1,6 +1,5 @@
 use crate::read::Readable;
 use crate::write::Writable;
-use crate::WritableRef;
 use crate::Write;
 use dioxus_core::prelude::{IntoAttributeValue, ScopeId};
 use generational_box::{AnyStorage, GenerationalRef, UnsyncStorage};
@@ -70,7 +69,7 @@ impl<T: 'static> GlobalSignal<T> {
     }
 }
 
-impl<T: 'static> crate::ReadableRef for GlobalSignal<T> {
+impl<T: 'static> Readable<T> for GlobalSignal<T> {
     type Ref<R: ?Sized + 'static> = generational_box::GenerationalRef<std::cell::Ref<'static, R>>;
 
     fn map_ref<I, U: ?Sized, F: FnOnce(&I) -> &U>(ref_: Self::Ref<I>, f: F) -> Self::Ref<U> {
@@ -83,9 +82,7 @@ impl<T: 'static> crate::ReadableRef for GlobalSignal<T> {
     ) -> Option<Self::Ref<U>> {
         <UnsyncStorage as AnyStorage>::try_map(ref_, f)
     }
-}
 
-impl<T: 'static> Readable<T> for GlobalSignal<T> {
     #[track_caller]
     fn read(&self) -> Self::Ref<T> {
         self.signal().read()
@@ -97,7 +94,7 @@ impl<T: 'static> Readable<T> for GlobalSignal<T> {
     }
 }
 
-impl<T: 'static> WritableRef for GlobalSignal<T> {
+impl<T: 'static> Writable<T> for GlobalSignal<T> {
     type Mut<R: ?Sized + 'static> = Write<R, UnsyncStorage>;
 
     fn map_mut<I, U: ?Sized + 'static, F: FnOnce(&mut I) -> &mut U>(
@@ -113,9 +110,7 @@ impl<T: 'static> WritableRef for GlobalSignal<T> {
     ) -> Option<Self::Mut<U>> {
         Write::filter_map(ref_, f)
     }
-}
 
-impl<T: 'static> Writable<T> for GlobalSignal<T> {
     #[track_caller]
     fn try_write(&self) -> Result<Self::Mut<T>, generational_box::BorrowMutError> {
         self.signal().try_write()
diff --git a/packages/signals/src/read.rs b/packages/signals/src/read.rs
index 1fc4dfaa3..cbf543520 100644
--- a/packages/signals/src/read.rs
+++ b/packages/signals/src/read.rs
@@ -1,25 +1,19 @@
 use std::ops::Deref;
 
-/// A trait for utilities around a mutable reference
-pub trait ReadableRef {
+/// A trait for states that can be read from like [`crate::Signal`], [`crate::GlobalSignal`], or [`crate::ReadOnlySignal`]. You may choose to accept this trait as a parameter instead of the concrete type to allow for more flexibility in your API. For example, instead of creating two functions, one that accepts a [`crate::Signal`] and one that accepts a [`crate::GlobalSignal`], you can create one function that accepts a [`Readable`] type.
+pub trait Readable<T: 'static = ()> {
     /// The type of the reference.
     type Ref<R: ?Sized + 'static>: Deref<Target = R>;
 
     /// Map the reference to a new type.
-    fn map_ref<I, U: ?Sized + 'static, F: FnOnce(&I) -> &U>(
-        ref_: Self::Ref<I>,
-        f: F,
-    ) -> Self::Ref<U>;
+    fn map_ref<I, U: ?Sized, F: FnOnce(&I) -> &U>(ref_: Self::Ref<I>, f: F) -> Self::Ref<U>;
 
     /// Try to map the reference to a new type.
-    fn try_map_ref<I, U: ?Sized + 'static, F: FnOnce(&I) -> Option<&U>>(
+    fn try_map_ref<I, U: ?Sized, F: FnOnce(&I) -> Option<&U>>(
         ref_: Self::Ref<I>,
         f: F,
     ) -> Option<Self::Ref<U>>;
-}
 
-/// A trait for states that can be read from like [`crate::Signal`], [`crate::GlobalSignal`], or [`crate::ReadOnlySignal`]. You may choose to accept this trait as a parameter instead of the concrete type to allow for more flexibility in your API. For example, instead of creating two functions, one that accepts a [`crate::Signal`] and one that accepts a [`crate::GlobalSignal`], you can create one function that accepts a [`Readable`] type.
-pub trait Readable<T: 'static>: ReadableRef {
     /// Get the current value of the state. If this is a signal, this will subscribe the current scope to the signal. If the value has been dropped, this will panic.
     fn read(&self) -> Self::Ref<T>;
 
diff --git a/packages/signals/src/read_only_signal.rs b/packages/signals/src/read_only_signal.rs
index 1f827efe4..156f6ef33 100644
--- a/packages/signals/src/read_only_signal.rs
+++ b/packages/signals/src/read_only_signal.rs
@@ -1,4 +1,4 @@
-use crate::{read::Readable, ReadableRef, Signal, SignalData};
+use crate::{read::Readable, Signal, SignalData};
 use std::{mem::MaybeUninit, ops::Deref};
 
 use dioxus_core::{prelude::IntoAttributeValue, ScopeId};
@@ -41,7 +41,7 @@ impl<T: 'static, S: Storage<SignalData<T>>> ReadOnlySignal<T, S> {
     }
 }
 
-impl<T, S: Storage<SignalData<T>>> ReadableRef for ReadOnlySignal<T, S> {
+impl<T, S: Storage<SignalData<T>>> Readable<T> for ReadOnlySignal<T, S> {
     type Ref<R: ?Sized + 'static> = S::Ref<R>;
 
     fn map_ref<I, U: ?Sized, F: FnOnce(&I) -> &U>(ref_: Self::Ref<I>, f: F) -> Self::Ref<U> {
@@ -54,9 +54,7 @@ impl<T, S: Storage<SignalData<T>>> ReadableRef for ReadOnlySignal<T, S> {
     ) -> Option<Self::Ref<U>> {
         S::try_map(ref_, f)
     }
-}
 
-impl<T, S: Storage<SignalData<T>>> Readable<T> for ReadOnlySignal<T, S> {
     /// Get the current value of the signal. This will subscribe the current scope to the signal.  If you would like to read the signal without subscribing to it, you can use [`Self::peek`] instead.
     ///
     /// If the signal has been dropped, this will panic.
@@ -72,6 +70,7 @@ impl<T, S: Storage<SignalData<T>>> Readable<T> for ReadOnlySignal<T, S> {
         self.inner.peek()
     }
 }
+
 impl<T> IntoAttributeValue for ReadOnlySignal<T>
 where
     T: Clone + IntoAttributeValue,
diff --git a/packages/signals/src/rt.rs b/packages/signals/src/rt.rs
index b96e9ec64..00f1a7ba9 100644
--- a/packages/signals/src/rt.rs
+++ b/packages/signals/src/rt.rs
@@ -11,9 +11,7 @@ use generational_box::{GenerationalBox, Owner, Storage};
 
 use crate::Effect;
 use crate::Readable;
-use crate::ReadableRef;
 use crate::Writable;
-use crate::WritableRef;
 
 fn current_owner<S: Storage<T>, T>() -> Rc<Owner<S>> {
     match Effect::current() {
@@ -150,7 +148,7 @@ impl<T: 'static, S: Storage<T>> CopyValue<T, S> {
     }
 }
 
-impl<T: 'static, S: Storage<T>> ReadableRef for CopyValue<T, S> {
+impl<T: 'static, S: Storage<T>> Readable<T> for CopyValue<T, S> {
     type Ref<R: ?Sized + 'static> = S::Ref<R>;
 
     fn map_ref<I, U: ?Sized, F: FnOnce(&I) -> &U>(ref_: Self::Ref<I>, f: F) -> Self::Ref<U> {
@@ -163,9 +161,7 @@ impl<T: 'static, S: Storage<T>> ReadableRef for CopyValue<T, S> {
     ) -> Option<Self::Ref<U>> {
         S::try_map(ref_, f)
     }
-}
 
-impl<T: 'static, S: Storage<T>> Readable<T> for CopyValue<T, S> {
     fn read(&self) -> Self::Ref<T> {
         self.value.read()
     }
@@ -175,7 +171,7 @@ impl<T: 'static, S: Storage<T>> Readable<T> for CopyValue<T, S> {
     }
 }
 
-impl<T: 'static, S: Storage<T>> WritableRef for CopyValue<T, S> {
+impl<T: 'static, S: Storage<T>> Writable<T> for CopyValue<T, S> {
     type Mut<R: ?Sized + 'static> = S::Mut<R>;
 
     fn map_mut<I, U: ?Sized, F: FnOnce(&mut I) -> &mut U>(
@@ -191,9 +187,7 @@ impl<T: 'static, S: Storage<T>> WritableRef for CopyValue<T, S> {
     ) -> Option<Self::Mut<U>> {
         S::try_map_mut(mut_, f)
     }
-}
 
-impl<T: 'static, S: Storage<T>> Writable<T> for CopyValue<T, S> {
     fn try_write(&self) -> Result<Self::Mut<T>, generational_box::BorrowMutError> {
         self.value.try_write()
     }
diff --git a/packages/signals/src/signal.rs b/packages/signals/src/signal.rs
index ee31e56fc..845bef847 100644
--- a/packages/signals/src/signal.rs
+++ b/packages/signals/src/signal.rs
@@ -1,6 +1,6 @@
 use crate::{
     read::Readable, write::Writable, Effect, EffectInner, GlobalMemo, GlobalSignal, MappedSignal,
-    ReadOnlySignal, ReadableRef, WritableRef,
+    ReadOnlySignal,
 };
 use std::{
     any::Any,
@@ -399,7 +399,7 @@ impl<T: 'static, S: Storage<SignalData<T>>> Signal<T, S> {
     }
 }
 
-impl<T, S: Storage<SignalData<T>>> ReadableRef for Signal<T, S> {
+impl<T, S: Storage<SignalData<T>>> Readable<T> for Signal<T, S> {
     type Ref<R: ?Sized + 'static> = S::Ref<R>;
 
     fn map_ref<I, U: ?Sized, F: FnOnce(&I) -> &U>(ref_: Self::Ref<I>, f: F) -> Self::Ref<U> {
@@ -412,9 +412,7 @@ impl<T, S: Storage<SignalData<T>>> ReadableRef for Signal<T, S> {
     ) -> Option<Self::Ref<U>> {
         S::try_map(ref_, f)
     }
-}
 
-impl<T, S: Storage<SignalData<T>>> Readable<T> for Signal<T, S> {
     /// Get the current value of the signal. This will subscribe the current scope to the signal.  If you would like to read the signal without subscribing to it, you can use [`Self::peek`] instead.
     ///
     /// If the signal has been dropped, this will panic.
@@ -458,7 +456,7 @@ impl<T, S: Storage<SignalData<T>>> Readable<T> for Signal<T, S> {
     }
 }
 
-impl<T: 'static, S: Storage<SignalData<T>>> WritableRef for Signal<T, S> {
+impl<T: 'static, S: Storage<SignalData<T>>> Writable<T> for Signal<T, S> {
     type Mut<R: ?Sized + 'static> = Write<R, S>;
 
     fn map_mut<I, U: ?Sized + 'static, F: FnOnce(&mut I) -> &mut U>(
@@ -474,9 +472,7 @@ impl<T: 'static, S: Storage<SignalData<T>>> WritableRef for Signal<T, S> {
     ) -> Option<Self::Mut<U>> {
         Write::filter_map(ref_, f)
     }
-}
 
-impl<T: 'static, S: Storage<SignalData<T>>> Writable<T> for Signal<T, S> {
     #[track_caller]
     fn try_write(&self) -> Result<Self::Mut<T>, generational_box::BorrowMutError> {
         self.inner.try_write().map(|inner| {
diff --git a/packages/signals/src/write.rs b/packages/signals/src/write.rs
index bfd19e17f..bc448cf90 100644
--- a/packages/signals/src/write.rs
+++ b/packages/signals/src/write.rs
@@ -2,26 +2,21 @@ use std::ops::DerefMut;
 
 use crate::read::Readable;
 
-/// A trait for utilities around a mutable reference
-pub trait WritableRef {
+/// A trait for states that can be read from like [`crate::Signal`], or [`crate::GlobalSignal`]. You may choose to accept this trait as a parameter instead of the concrete type to allow for more flexibility in your API. For example, instead of creating two functions, one that accepts a [`crate::Signal`] and one that accepts a [`crate::GlobalSignal`], you can create one function that accepts a [`Writable`] type.
+pub trait Writable<T: 'static>: Readable<T> {
     /// The type of the reference.
     type Mut<R: ?Sized + 'static>: DerefMut<Target = R>;
 
     /// Map the reference to a new type.
-    fn map_mut<I, U: ?Sized + 'static, F: FnOnce(&mut I) -> &mut U>(
-        ref_: Self::Mut<I>,
-        f: F,
-    ) -> Self::Mut<U>;
+    fn map_mut<I, U: ?Sized, F: FnOnce(&mut I) -> &mut U>(ref_: Self::Mut<I>, f: F)
+        -> Self::Mut<U>;
 
     /// Try to map the reference to a new type.
-    fn try_map_mut<I, U: ?Sized + 'static, F: FnOnce(&mut I) -> Option<&mut U>>(
+    fn try_map_mut<I, U: ?Sized, F: FnOnce(&mut I) -> Option<&mut U>>(
         ref_: Self::Mut<I>,
         f: F,
     ) -> Option<Self::Mut<U>>;
-}
 
-/// A trait for states that can be read from like [`crate::Signal`], or [`crate::GlobalSignal`]. You may choose to accept this trait as a parameter instead of the concrete type to allow for more flexibility in your API. For example, instead of creating two functions, one that accepts a [`crate::Signal`] and one that accepts a [`crate::GlobalSignal`], you can create one function that accepts a [`Writable`] type.
-pub trait Writable<T: 'static>: WritableRef + Readable<T> {
     /// Get a mutable reference to the value. If the value has been dropped, this will panic.
     #[track_caller]
     fn write(&self) -> Self::Mut<T> {