From b2154cb6903bc2b39e4c0183f6b4e371ff7e8ab0 Mon Sep 17 00:00:00 2001
From: Matt Hunzinger <matthunz2@gmail.com>
Date: Tue, 26 Nov 2024 14:38:14 -0500
Subject: [PATCH] Rename Ref to Signal and Mut to SignalMut to avoid name
 conflicts

---
 README.md               |  8 ++---
 examples/ecs/counter.rs |  6 ++--
 examples/ecs/http.rs    |  9 ++----
 examples/ecs/timer.rs   |  6 ++--
 src/compose.rs          |  8 ++---
 src/ecs.rs              | 39 ++++++++++++------------
 src/lib.rs              | 66 ++++++++++++++++++++---------------------
 7 files changed, 70 insertions(+), 72 deletions(-)

diff --git a/README.md b/README.md
index 28fb902..724a31a 100644
--- a/README.md
+++ b/README.md
@@ -33,7 +33,7 @@ This crate provides a generic library that lets you define reactive components (
 ```rust
 // Counter UI example.
 
-use actuate::prelude::{Mut, *};
+use actuate::prelude::*;
 use bevy::prelude::*;
 
 // Counter composable.
@@ -53,10 +53,10 @@ impl Compose for Counter {
         .content((
             spawn(Text::new(format!("High five count: {}", count))),
             spawn(Text::new("Up high")).observe(move |_trigger: In<Trigger<Pointer<Click>>>| {
-                Mut::update(count, |x| *x += 1)
+                SignalMut::update(count, |x| *x += 1)
             }),
             spawn(Text::new("Down low")).observe(move |_trigger: In<Trigger<Pointer<Click>>>| {
-                Mut::update(count, |x| *x -= 1)
+                SignalMut::update(count, |x| *x -= 1)
             }),
             if *count == 0 {
                 Some(spawn(Text::new("Gimme five!")))
@@ -107,7 +107,7 @@ struct App {
 impl Compose for App {
     fn compose(cx: Scope<Self>) -> impl Compose {
         // Get a mapped reference to the app's `name` field.
-        let name = Ref::map(cx.me(), |me| &me.name).into();
+        let name = Signal::map(cx.me(), |me| &me.name).into();
 
         User { name }
     }
diff --git a/examples/ecs/counter.rs b/examples/ecs/counter.rs
index 3bebc25..3be4d8a 100644
--- a/examples/ecs/counter.rs
+++ b/examples/ecs/counter.rs
@@ -1,6 +1,6 @@
 // Counter UI example.
 
-use actuate::prelude::{Mut, *};
+use actuate::prelude::*;
 use bevy::prelude::*;
 
 // Counter composable.
@@ -20,10 +20,10 @@ impl Compose for Counter {
         .content((
             spawn(Text::new(format!("High five count: {}", count))),
             spawn(Text::new("Up high")).observe(move |_trigger: In<Trigger<Pointer<Click>>>| {
-                Mut::update(count, |x| *x += 1)
+                SignalMut::update(count, |x| *x += 1)
             }),
             spawn(Text::new("Down low")).observe(move |_trigger: In<Trigger<Pointer<Click>>>| {
-                Mut::update(count, |x| *x -= 1)
+                SignalMut::update(count, |x| *x -= 1)
             }),
             if *count == 0 {
                 Some(spawn(Text::new("Gimme five!")))
diff --git a/examples/ecs/http.rs b/examples/ecs/http.rs
index 593b5cc..4f0f494 100644
--- a/examples/ecs/http.rs
+++ b/examples/ecs/http.rs
@@ -1,9 +1,6 @@
 // HTTP UI example
 
-use actuate::{
-    executor::ExecutorContext,
-    prelude::{Mut, Ref, *},
-};
+use actuate::{executor::ExecutorContext, prelude::*};
 use bevy::prelude::*;
 use serde::Deserialize;
 use std::collections::HashMap;
@@ -34,7 +31,7 @@ impl Compose for Breed<'_> {
                 ..default()
             })
             .content(compose::from_iter(
-                Ref::map(cx.me(), |me| me.families),
+                Signal::map(cx.me(), |me| me.families),
                 |family| spawn(Text::from(family.to_string())),
             )),
         ))
@@ -63,7 +60,7 @@ impl Compose for BreedList {
                 .await
                 .unwrap();
 
-            Mut::update(breeds, |breeds| *breeds = json.message);
+            SignalMut::update(breeds, |breeds| *breeds = json.message);
         });
 
         // Render the currently loaded breeds.
diff --git a/examples/ecs/timer.rs b/examples/ecs/timer.rs
index 473cefc..e4e1af7 100644
--- a/examples/ecs/timer.rs
+++ b/examples/ecs/timer.rs
@@ -1,6 +1,6 @@
 // Timer UI example.
 
-use actuate::prelude::{Mut, *};
+use actuate::prelude::*;
 use bevy::prelude::*;
 
 // Timer composable.
@@ -12,7 +12,9 @@ impl Compose for Timer {
         let current_time = use_mut(&cx, Time::default);
 
         // Use the `Time` resource from the ECS world, updating the `current_time`.
-        use_world(&cx, move |time: Res<Time>| Mut::set(current_time, *time));
+        use_world(&cx, move |time: Res<Time>| {
+            SignalMut::set(current_time, *time)
+        });
 
         // Spawn a `Text` component, updating it when this scope is re-composed.
         spawn(Text::new(format!("Elapsed: {:?}", current_time.elapsed())))
diff --git a/src/compose.rs b/src/compose.rs
index 931ee2f..56405a5 100644
--- a/src/compose.rs
+++ b/src/compose.rs
@@ -88,7 +88,7 @@ impl<C: Compose> Compose for Option<C> {
 /// Create a composable from an iterator.
 pub fn from_iter<'a, I, C>(
     iter: I,
-    f: impl Fn(Ref<'a, I::Item>) -> C + 'a,
+    f: impl Fn(Signal<'a, I::Item>) -> C + 'a,
 ) -> FromIter<'a, I, I::Item, C>
 where
     I: IntoIterator + Clone + Data,
@@ -122,7 +122,7 @@ impl Drop for AnyItemState {
 #[must_use = "Composables do nothing unless composed or returned from other composables."]
 pub struct FromIter<'a, I, Item, C> {
     iter: I,
-    f: Box<dyn Fn(Ref<'a, Item>) -> C + 'a>,
+    f: Box<dyn Fn(Signal<'a, Item>) -> C + 'a>,
 }
 
 unsafe impl<I, Item, C> Data for FromIter<'_, I, Item, C>
@@ -161,7 +161,7 @@ where
 
                     let item_ref: &Item = &state.item;
                     let item_ref: &Item = unsafe { mem::transmute(item_ref) };
-                    let compose = (cx.me().f)(Ref {
+                    let compose = (cx.me().f)(Signal {
                         value: item_ref,
                         generation: &cx.generation as _,
                     });
@@ -250,7 +250,7 @@ where
             cx.is_parent_changed.set(true);
         }
 
-        Ref::map(cx.me(), |me| &me.content)
+        Signal::map(cx.me(), |me| &me.content)
     }
 
     fn name() -> Option<Cow<'static, str>> {
diff --git a/src/ecs.rs b/src/ecs.rs
index aea5253..e6e9ec6 100644
--- a/src/ecs.rs
+++ b/src/ecs.rs
@@ -1,6 +1,6 @@
 use crate::{
     composer::{Composer, Update, Updater},
-    prelude::{Ref, *},
+    prelude::{Signal, *},
 };
 use bevy_app::{App, Plugin};
 use bevy_ecs::{
@@ -153,22 +153,6 @@ where
     }
 }
 
-#[derive(Data)]
-struct CompositionContent<C> {
-    content: C,
-    target: Entity,
-}
-
-impl<C: Compose> Compose for CompositionContent<C> {
-    fn compose(cx: Scope<Self>) -> impl Compose {
-        use_provider(&cx, || SpawnContext {
-            parent_entity: cx.me().target,
-        });
-
-        Ref::map(cx.me(), |me| &me.content)
-    }
-}
-
 impl<C> Component for Composition<C>
 where
     C: Compose + Send + Sync + 'static,
@@ -181,12 +165,11 @@ where
                 let mut composition = world.get_mut::<Composition<C>>(entity).unwrap();
 
                 let content = composition.content.take().unwrap();
-
                 let target = composition.target.unwrap_or(entity);
 
                 let rt = world.non_send_resource_mut::<Runtime>();
-
                 let (tx, rx) = mpsc::channel();
+
                 rt.composers.borrow_mut().insert(
                     entity,
                     RuntimeComposer {
@@ -203,6 +186,22 @@ where
     }
 }
 
+#[derive(Data)]
+struct CompositionContent<C> {
+    content: C,
+    target: Entity,
+}
+
+impl<C: Compose> Compose for CompositionContent<C> {
+    fn compose(cx: Scope<Self>) -> impl Compose {
+        use_provider(&cx, || SpawnContext {
+            parent_entity: cx.me().target,
+        });
+
+        Signal::map(cx.me(), |me| &me.content)
+    }
+}
+
 fn compose(world: &mut World) {
     let mut rt = world.non_send_resource_mut::<Runtime>();
     rt.lock = None;
@@ -603,7 +602,7 @@ impl<C: Compose> Compose for Spawn<'_, C> {
             }
         });
 
-        Ref::map(cx.me(), |me| &me.content)
+        Signal::map(cx.me(), |me| &me.content)
     }
 }
 
diff --git a/src/lib.rs b/src/lib.rs
index cfbe158..41c0dd5 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -3,7 +3,7 @@
 //! This crate provides a generic library that lets you define reactive components (also known as composables).
 //!
 //! ```no_run
-//! use actuate::prelude::{Mut, *};
+//! use actuate::prelude::*;
 //! use bevy::prelude::*;
 //!
 //! // Counter composable.
@@ -23,10 +23,10 @@
 //!         .content((
 //!             spawn(Text::new(format!("High five count: {}", count))),
 //!             spawn(Text::new("Up high")).observe(move |_trigger: In<Trigger<Pointer<Click>>>| {
-//!                 Mut::update(count, |x| *x += 1)
+//!                 SignalMut::update(count, |x| *x += 1)
 //!             }),
 //!             spawn(Text::new("Down low")).observe(move |_trigger: In<Trigger<Pointer<Click>>>| {
-//!                 Mut::update(count, |x| *x -= 1)
+//!                 SignalMut::update(count, |x| *x -= 1)
 //!             }),
 //!             if *count == 0 {
 //!                 Some(spawn(Text::new("Gimme five!")))
@@ -53,7 +53,7 @@
 //! ## Borrowing
 //! Composables can borrow from their ancestors, as well as state.
 //! ```no_run
-//! use actuate::prelude::{Ref, *};
+//! use actuate::prelude::*;
 //! use bevy::prelude::*;
 //!
 //! #[derive(Data)]
@@ -76,7 +76,7 @@
 //! impl Compose for App {
 //!     fn compose(cx: Scope<Self>) -> impl Compose {
 //!         // Get a mapped reference to the app's `name` field.
-//!         let name = Ref::map(cx.me(), |me| &me.name).into();
+//!         let name = Signal::map(cx.me(), |me| &me.name).into();
 //!
 //!         User { name }
 //!     }
@@ -130,7 +130,7 @@ pub mod prelude {
         compose::{self, Compose, DynCompose, Memo},
         data::{data, Data, DataField, FieldWrap, FnField, StateField, StaticField},
         use_callback, use_context, use_drop, use_local_task, use_memo, use_mut, use_provider,
-        use_ref, Cow, Map, Mut, Ref, RefMap, Scope, ScopeState,
+        use_ref, Cow, Map, RefMap, Scope, ScopeState, Signal, SignalMut,
     };
 
     #[cfg(feature = "ecs")]
@@ -220,8 +220,8 @@ impl<'a, T> From<RefMap<'a, T>> for Cow<'a, T> {
     }
 }
 
-impl<'a, T> From<Ref<'a, T>> for Cow<'a, T> {
-    fn from(value: Ref<'a, T>) -> Self {
+impl<'a, T> From<Signal<'a, T>> for Cow<'a, T> {
+    fn from(value: Signal<'a, T>) -> Self {
         RefMap::from(value).into()
     }
 }
@@ -247,7 +247,7 @@ unsafe impl<T: Data> Data for Cow<'_, T> {}
 #[derive(Debug)]
 pub enum RefMap<'a, T> {
     /// Reference to a value.
-    Ref(Ref<'a, T>),
+    Ref(Signal<'a, T>),
     /// Mapped reference to a value.
     Map(Map<'a, T>),
 }
@@ -277,8 +277,8 @@ impl<T: Hash> Hash for RefMap<'_, T> {
     }
 }
 
-impl<'a, T> From<Ref<'a, T>> for RefMap<'a, T> {
-    fn from(value: Ref<'a, T>) -> Self {
+impl<'a, T> From<Signal<'a, T>> for RefMap<'a, T> {
+    fn from(value: Signal<'a, T>) -> Self {
         RefMap::Ref(value)
     }
 }
@@ -363,13 +363,13 @@ impl<T> Hash for Map<'_, T> {
 ///
 /// Memoizing this value will use pointer-equality for higher-performance.
 ///
-/// This reference can be mapped to inner values with [`Ref::map`].
-pub struct Ref<'a, T> {
+/// This reference can be mapped to inner values with [`Signal::map`].
+pub struct Signal<'a, T> {
     value: &'a T,
     generation: *const Cell<u64>,
 }
 
-impl<'a, T> Ref<'a, T> {
+impl<'a, T> Signal<'a, T> {
     /// Map this reference to a value of type `U`.
     pub fn map<U>(me: Self, f: fn(&T) -> &U) -> Map<'a, U> {
         Map {
@@ -387,7 +387,7 @@ impl<'a, T> Ref<'a, T> {
     }
 }
 
-impl<T> Deref for Ref<'_, T> {
+impl<T> Deref for Signal<'_, T> {
     type Target = T;
 
     fn deref(&self) -> &Self::Target {
@@ -395,7 +395,7 @@ impl<T> Deref for Ref<'_, T> {
     }
 }
 
-impl<T> Hash for Ref<'_, T> {
+impl<T> Hash for Signal<'_, T> {
     fn hash<H: Hasher>(&self, state: &mut H) {
         (self.value as *const T).hash(state);
         self.generation.hash(state);
@@ -403,7 +403,7 @@ impl<T> Hash for Ref<'_, T> {
 }
 
 /// Mutable reference to a value of type `T`.
-pub struct Mut<'a, T> {
+pub struct SignalMut<'a, T> {
     /// Pointer to the boxed value.
     ptr: NonNull<T>,
 
@@ -417,7 +417,7 @@ pub struct Mut<'a, T> {
     phantom: PhantomData<&'a ()>,
 }
 
-impl<'a, T: 'static> Mut<'a, T> {
+impl<'a, T: 'static> SignalMut<'a, T> {
     /// Queue an update to this value, triggering an update to the component owning this value.
     pub fn update(me: Self, f: impl FnOnce(&mut T) + 'static) {
         let mut ptr = me.ptr;
@@ -439,7 +439,7 @@ impl<'a, T: 'static> Mut<'a, T> {
 
     /// Queue an update to this value, triggering an update to the component owning this value.
     pub fn set(me: Self, value: T) {
-        Mut::update(me, |x| *x = value)
+        SignalMut::update(me, |x| *x = value)
     }
 
     /// Queue an update to this value wtihout triggering an update.
@@ -454,15 +454,15 @@ impl<'a, T: 'static> Mut<'a, T> {
     }
 
     /// Convert this mutable reference to an immutable reference.
-    pub fn as_ref(me: Self) -> Ref<'a, T> {
-        Ref {
+    pub fn as_ref(me: Self) -> Signal<'a, T> {
+        Signal {
             value: unsafe { me.ptr.as_ref() },
             generation: me.generation,
         }
     }
 }
 
-impl<T> Deref for Mut<'_, T> {
+impl<T> Deref for SignalMut<'_, T> {
     type Target = T;
 
     fn deref(&self) -> &Self::Target {
@@ -520,7 +520,7 @@ macro_rules! impl_pointer {
         )*
     };
 }
-impl_pointer!(Ref, Map, Mut);
+impl_pointer!(Signal, Map, SignalMut);
 
 /// Map of [`TypeId`] to context values.
 #[derive(Clone, Default)]
@@ -598,8 +598,8 @@ pub struct Scope<'a, C> {
 
 impl<'a, C> Scope<'a, C> {
     /// Get a [`Ref`] to this composable.
-    pub fn me(self) -> Ref<'a, C> {
-        Ref {
+    pub fn me(self) -> Signal<'a, C> {
+        Signal {
             value: self.me,
             generation: &self.state.generation,
         }
@@ -653,7 +653,7 @@ struct MutState<T> {
 /// Use a mutable reference to a value of type `T`.
 ///
 /// `make_value` will only be called once to initialize this value.
-pub fn use_mut<T: 'static>(cx: ScopeState, make_value: impl FnOnce() -> T) -> Mut<'_, T> {
+pub fn use_mut<T: 'static>(cx: ScopeState, make_value: impl FnOnce() -> T) -> SignalMut<'_, T> {
     let hooks = unsafe { &mut *cx.hooks.get() };
 
     let idx = cx.hook_idx.get();
@@ -671,7 +671,7 @@ pub fn use_mut<T: 'static>(cx: ScopeState, make_value: impl FnOnce() -> T) -> Mu
     };
     let state: &mut MutState<T> = any.downcast_mut().unwrap();
 
-    Mut {
+    SignalMut {
         ptr: unsafe { NonNull::new_unchecked(&mut state.value as *mut _) },
         scope_is_changed: &cx.is_changed,
         generation: &state.generation,
@@ -785,7 +785,7 @@ impl<T: PartialEq + 'static> Memoize for T {
     }
 }
 
-impl<T> Memoize for Ref<'_, T> {
+impl<T> Memoize for Signal<'_, T> {
     type Value = u64;
 
     fn memoized(self) -> Self::Value {
@@ -812,7 +812,7 @@ impl<T> Memoize for RefMap<'_, T> {
     }
 }
 
-impl<T> Memoize for Mut<'_, T> {
+impl<T> Memoize for SignalMut<'_, T> {
     type Value = u64;
 
     fn memoized(self) -> Self::Value {
@@ -848,7 +848,7 @@ where
 /// Use a memoized value of type `T` with a dependency of type `D`.
 ///
 /// `make_value` will update the returned value whenver `dependency` is changed.
-pub fn use_memo<D, T>(cx: ScopeState, dependency: D, make_value: impl FnOnce() -> T) -> Ref<T>
+pub fn use_memo<D, T>(cx: ScopeState, dependency: D, make_value: impl FnOnce() -> T) -> Signal<T>
 where
     D: Memoize,
     T: 'static,
@@ -864,14 +864,14 @@ where
         if let Some(dependency) = dependency_cell.take() {
             if dependency != *hash_mut {
                 let value = make_value();
-                Mut::with(value_mut, move |update| *update = value);
+                SignalMut::with(value_mut, move |update| *update = value);
 
-                Mut::with(hash_mut, move |dst| *dst = dependency);
+                SignalMut::with(hash_mut, move |dst| *dst = dependency);
             }
         }
     }
 
-    Mut::as_ref(value_mut)
+    SignalMut::as_ref(value_mut)
 }
 
 /// Use a function that will be called when this scope is dropped.