improved documentation and refactored naming to be more self-explanatory

packages/hooks/src/use_coroutine.rs

@@ -129,11 +129,12 @@ mod tests {
     use futures_util::StreamExt;
 
     fn app(cx: Scope, name: String) -> Element {
-        let task = use_coroutine(cx, |mut rx: UnboundedReceiver<i32>| async move {
-            while let Some(msg) = rx.next().await {
-                println!("got message: {msg}");
-            }
-        });
+        let task =
+            use_coroutine(cx, |mut rx: UnboundedReceiver<i32>| async move {
+                while let Some(msg) = rx.next().await {
+                    println!("got message: {msg}");
+                }
+            });
 
         let task2 = use_coroutine(cx, view_task);
 

packages/hooks/src/use_shared_state.rs

@@ -226,10 +226,12 @@ impl<T> UseSharedState<T> {
     pub fn read(&self) -> Ref<'_, T> {
         match self.try_read() {
             Ok(value) => value,
-            Err(message) => panic!(
-                "Reading the shared state failed: {}\n({:?})",
-                message, message
-            ),
+            Err(message) => {
+                panic!(
+                    "Reading the shared state failed: {}\n({:?})",
+                    message, message
+                )
+            }
         }
     }
 
@@ -258,10 +260,12 @@ impl<T> UseSharedState<T> {
     pub fn write(&self) -> RefMut<'_, T> {
         match self.try_write() {
             Ok(value) => value,
-            Err(message) => panic!(
-                "Writing to shared state failed: {}\n({:?})",
-                message, message
-            ),
+            Err(message) => {
+                panic!(
+                    "Writing to shared state failed: {}\n({:?})",
+                    message, message
+                )
+            }
         }
     }
 
@@ -284,10 +288,12 @@ impl<T> UseSharedState<T> {
     pub fn write_silent(&self) -> RefMut<'_, T> {
         match self.try_write_silent() {
             Ok(value) => value,
-            Err(message) => panic!(
-                "Writing to shared state silently failed: {}\n({:?})",
-                message, message
-            ),
+            Err(message) => {
+                panic!(
+                    "Writing to shared state silently failed: {}\n({:?})",
+                    message, message
+                )
+            }
         }
     }
 
@@ -363,12 +369,13 @@ impl<T> PartialEq for UseSharedState<T> {
 /// ```
 pub fn use_shared_state_provider<T: 'static>(cx: &ScopeState, f: impl FnOnce() -> T) {
     cx.use_hook(|| {
-        let state: ProvidedState<T> = Rc::new(RefCell::new(ProvidedStateInner {
-            value: f(),
-            notify_any: cx.schedule_update_any(),
-            consumers: HashSet::new(),
-            gen: 0,
-        }));
+        let state: ProvidedState<T> =
+            Rc::new(RefCell::new(ProvidedStateInner {
+                value: f(),
+                notify_any: cx.schedule_update_any(),
+                consumers: HashSet::new(),
+                gen: 0,
+            }));
 
         cx.provide_context(state);
     });

packages/hooks/src/use_state.rs

@@ -35,36 +35,37 @@ pub fn use_state<T: 'static>(
     cx: &ScopeState,
     initial_state_fn: impl FnOnce() -> T,
 ) -> &UseState<T> {
-    let hook = cx.use_hook(move || {
-        let current_val = Rc::new(initial_state_fn());
-        let update_callback = cx.schedule_update();
-        let slot = Rc::new(RefCell::new(current_val.clone()));
-        let setter = Rc::new({
-            to_owned![update_callback, slot];
-            move |new| {
-                {
-                    let mut slot = slot.borrow_mut();
+    let hook =
+        cx.use_hook(move || {
+            let current_val = Rc::new(initial_state_fn());
+            let update_callback = cx.schedule_update();
+            let slot = Rc::new(RefCell::new(current_val.clone()));
+            let setter = Rc::new({
+                to_owned![update_callback, slot];
+                move |new| {
+                    {
+                        let mut slot = slot.borrow_mut();
 
-                    // if there's only one reference (weak or otherwise), we can just swap the values
-                    // Typically happens when the state is set multiple times - we don't want to create a new Rc for each new value
-                    if let Some(val) = Rc::get_mut(&mut slot) {
-                        *val = new;
-                    } else {
-                        *slot = Rc::new(new);
+                        // if there's only one reference (weak or otherwise), we can just swap the values
+                        // Typically happens when the state is set multiple times - we don't want to create a new Rc for each new value
+                        if let Some(val) = Rc::get_mut(&mut slot) {
+                            *val = new;
+                        } else {
+                            *slot = Rc::new(new);
+                        }
                     }
+                    update_callback();
                 }
-                update_callback();
+            });
+
+            UseState {
+                current_val,
+                update_callback,
+                setter,
+                slot,
             }
         });
 
-        UseState {
-            current_val,
-            update_callback,
-            setter,
-            slot,
-        }
-    });
-
     hook.current_val = hook.slot.borrow().clone();
 
     hook