rework: rename get() to value_rc(), fix for new internals, add docs

- Renamed get() to value_rc() on both UseStateHandle and
  UseReducerHandle to avoid shadowing Deref targets that define
  their own get() (e.g. Cell, RefCell, Option).
- Updated UseReducerHandle::value_rc() and into_inner() to work
  with the new current_state: Rc<RefCell<Rc<T>>> internals.
- Reverted the no-longer-needed disambiguation in suspense/hooks.rs.
- Added explicit transmute type annotations to satisfy clippy.
- Updated timer_functional example to showcase into_inner().
- Added docs for value_rc() and into_inner() in en, ja, zh-Hans,
  zh-Hant.

Author: Madoshakalaka

examples/timer_functional/src/main.rs

@@ -122,8 +122,10 @@ fn App() -> Html {
         timeout_handle: None,
     });
 
+    let (state_value, dispatcher) = state.into_inner();
+
     let mut key = 0;
-    let messages: Html = state
+    let messages: Html = state_value
         .messages
         .iter()
         .map(|message| {
@@ -132,39 +134,33 @@ fn App() -> Html {
         })
         .collect();
 
-    let has_job = state.interval_handle.is_some() || state.timeout_handle.is_some();
+    let has_job = state_value.interval_handle.is_some() || state_value.timeout_handle.is_some();
 
     let on_add_timeout = {
-        let state = state.clone();
-
+        let dispatcher = dispatcher.clone();
         Callback::from(move |_: MouseEvent| {
-            let timeout_state = state.clone();
-            let message_state = state.clone();
+            let done_dispatcher = dispatcher.clone();
             let t = Timeout::new(3000, move || {
-                message_state.dispatch(TimerAction::TimeoutDone);
+                done_dispatcher.dispatch(TimerAction::TimeoutDone);
             });
-
-            timeout_state.dispatch(TimerAction::SetTimeout(t));
+            dispatcher.dispatch(TimerAction::SetTimeout(t));
         })
     };
 
     let on_add_interval = {
-        let state = state.clone();
-
+        let dispatcher = dispatcher.clone();
         Callback::from(move |_: MouseEvent| {
-            let interval_state = state.clone();
-            let message_state = state.clone();
+            let tick_dispatcher = dispatcher.clone();
             let i = Interval::new(1000, move || {
-                message_state.dispatch(TimerAction::Add("Tick.."));
+                tick_dispatcher.dispatch(TimerAction::Add("Tick.."));
             });
-
-            interval_state.dispatch(TimerAction::SetInterval(i));
+            dispatcher.dispatch(TimerAction::SetInterval(i));
         })
     };
 
     let on_cancel = {
         Callback::from(move |_: MouseEvent| {
-            state.dispatch(TimerAction::Cancel);
+            dispatcher.dispatch(TimerAction::Cancel);
         })
     };
 

packages/yew/src/functional/hooks/use_state.rs

@@ -124,7 +124,7 @@ impl<T> UseStateHandle<T> {
     pub fn value_rc(&self) -> Rc<T> {
         // SAFETY: `UseStateReducer<T>` is `repr(transparent)` over `T`, so
         // `Rc<UseStateReducer<T>>` and `Rc<T>` have identical layouts.
-        unsafe { transmute(self.inner.value_rc()) }
+        unsafe { transmute::<Rc<UseStateReducer<T>>, Rc<T>>(self.inner.value_rc()) }
     }
 
     /// Replaces the value
@@ -144,7 +144,10 @@ impl<T> UseStateHandle<T> {
     pub fn into_inner(self) -> (Rc<T>, UseStateSetter<T>) {
         let (data, inner) = self.inner.into_inner();
         // SAFETY: same repr(transparent) guarantee as `value_rc`.
-        (unsafe { transmute(data) }, UseStateSetter { inner })
+        (
+            unsafe { transmute::<Rc<UseStateReducer<T>>, Rc<T>>(data) },
+            UseStateSetter { inner },
+        )
     }
 }
 

packages/yew/src/suspense/hooks.rs

@@ -108,14 +108,14 @@ where
 
         use_memo_base(
             move |deps| {
-                let self_id = (*latest_id).get().wrapping_add(1);
+                let self_id = latest_id.get().wrapping_add(1);
                 // As long as less than 2**32 futures are in flight wrapping_add is fine
                 (*latest_id).set(self_id);
                 let deps = Rc::new(deps);
                 let task = f(deps.clone());
                 let suspension = Suspension::from_future(async move {
                     let result = task.await;
-                    if (*latest_id).get() == self_id {
+                    if latest_id.get() == self_id {
                         output.set(Some(result));
                     }
                 });

website/docs/concepts/function-components/state.mdx

@@ -17,6 +17,41 @@ This table can be used as a guide when deciding what state-storing type fits bes
 | [use_mut_ref]            | `T`                        | -                            | component instance  |
 | a static global variable | `T`                        | -                            | global, used by all |
 
+## Accessing handle internals
+
+Both `UseStateHandle` and `UseReducerHandle` provide methods to access their internal parts directly.
+
+### `value_rc()`
+
+Returns the current value wrapped in an `Rc<T>`. Unlike dereferencing the handle (which gives a `&T`
+tied to the handle's lifetime), `value_rc()` gives you an owned `Rc<T>` that can be moved into
+closures or stored independently.
+
+```rust
+let counter = use_state(|| 0);
+let rc_value: Rc<i32> = counter.value_rc();
+```
+
+### `into_inner()`
+
+Consumes the handle and returns its two parts: the current value as `Rc<T>` and the
+setter/dispatcher. This is useful when you want to separate reading from writing without cloning
+the full handle.
+
+For `UseReducerHandle`, the return type is `(Rc<T>, UseReducerDispatcher<T>)`:
+
+```rust
+let state = use_reducer(CounterState::default);
+let (value, dispatcher) = state.into_inner();
+```
+
+For `UseStateHandle`, the return type is `(Rc<T>, UseStateSetter<T>)`:
+
+```rust
+let state = use_state(|| 0);
+let (value, setter) = state.into_inner();
+```
+
 [use_state]: https://yew-rs-api.web.app/next/yew/functional/fn.use_state.html
 [use_state_eq]: https://yew-rs-api.web.app/next/yew/functional/fn.use_state_eq.html
 [use_reducer]: https://yew-rs-api.web.app/next/yew/functional/fn.use_reducer.html

website/i18n/ja/docusaurus-plugin-content-docs/current/concepts/function-components/state.mdx

@@ -17,6 +17,39 @@ title: '状態'
 | [use_mut_ref]      | `T`                        | -                                          | コンポーネントインスタンス内 |
 | グローバル静的定数 | `T`                        | -                                          | グローバル、どこでも使用可能 |
 
+## ハンドルの内部へのアクセス
+
+`UseStateHandle` と `UseReducerHandle` の両方に、内部パーツに直接アクセスするためのメソッドが用意されています。
+
+### `value_rc()`
+
+現在の値を `Rc<T>` で返します。ハンドルの参照外し（ハンドルのライフタイムに束縛された `&T` を返す）とは
+異なり、`value_rc()` はクロージャに移動させたり、独立して保持できる所有された `Rc<T>` を返します。
+
+```rust
+let counter = use_state(|| 0);
+let rc_value: Rc<i32> = counter.value_rc();
+```
+
+### `into_inner()`
+
+ハンドルを消費し、現在の値（`Rc<T>`）とセッター/ディスパッチャーの2つの部分を返します。
+ハンドル全体をクローンせずに、読み取りと書き込みを分離したい場合に便利です。
+
+`UseReducerHandle` の場合、返り値の型は `(Rc<T>, UseReducerDispatcher<T>)` です：
+
+```rust
+let state = use_reducer(CounterState::default);
+let (value, dispatcher) = state.into_inner();
+```
+
+`UseStateHandle` の場合、返り値の型は `(Rc<T>, UseStateSetter<T>)` です：
+
+```rust
+let state = use_state(|| 0);
+let (value, setter) = state.into_inner();
+```
+
 [use_state]: https://yew-rs-api.web.app/next/yew/functional/fn.use_state.html
 [use_state_eq]: https://yew-rs-api.web.app/next/yew/functional/fn.use_state_eq.html
 [use_reducer]: https://yew-rs-api.web.app/next/yew/functional/fn.use_reducer.html

website/i18n/zh-Hans/docusaurus-plugin-content-docs/current/concepts/function-components/state.mdx

@@ -17,6 +17,39 @@ title: '状态'
 | [use_mut_ref]    | `T`                        | -                                | 组件内部实例             |
 | 全局静态常量     | `T`                        | -                                | 全局，任何位置都可以使用 |
 
+## 访问句柄内部
+
+`UseStateHandle` 和 `UseReducerHandle` 都提供了直接访问其内部组成部分的方法。
+
+### `value_rc()`
+
+以 `Rc<T>` 的形式返回当前值。与对句柄解引用（返回绑定到句柄生命周期的 `&T`）不同，
+`value_rc()` 返回一个拥有所有权的 `Rc<T>`，可以移动到闭包中或独立存储���
+
+```rust
+let counter = use_state(|| 0);
+let rc_value: Rc<i32> = counter.value_rc();
+```
+
+### `into_inner()`
+
+消耗句柄并返回其两个组成部分：当前值（`Rc<T>`）和 setter/dispatcher。
+当你想要在不克隆整个句柄的情况下将读取与写入分离时，这非常有用。
+
+对于 `UseReducerHandle`，返回类型为 `(Rc<T>, UseReducerDispatcher<T>)`：
+
+```rust
+let state = use_reducer(CounterState::default);
+let (value, dispatcher) = state.into_inner();
+```
+
+对于 `UseStateHandle`，返回类型为 `(Rc<T>, UseStateSetter<T>)`���
+
+```rust
+let state = use_state(|| 0);
+let (value, setter) = state.into_inner();
+```
+
 [use_state]: https://yew-rs-api.web.app/next/yew/functional/fn.use_state.html
 [use_state_eq]: https://yew-rs-api.web.app/next/yew/functional/fn.use_state_eq.html
 [use_reducer]: https://yew-rs-api.web.app/next/yew/functional/fn.use_reducer.html

website/i18n/zh-Hant/docusaurus-plugin-content-docs/current/concepts/function-components/state.mdx

@@ -17,6 +17,39 @@ title: '狀態'
 | [use_mut_ref]    | `T`                        | -                                | 組件內部實例             |
 | 全域靜態常數     | `T`                        | -                                | 全域，任何位置都可以使用 |
 
+## 存取句柄內部
+
+`UseStateHandle` 和 `UseReducerHandle` 都提供了直接存取其內部組成部分的方法。
+
+### `value_rc()`
+
+以 `Rc<T>` 的形式回傳當前值。與對句柄解參考（回傳繫結到句柄生命週期的 `&T`）不同，
+`value_rc()` 回傳一個擁有所有權的 `Rc<T>`，可以移動到閉包中或獨立儲存。
+
+```rust
+let counter = use_state(|| 0);
+let rc_value: Rc<i32> = counter.value_rc();
+```
+
+### `into_inner()`
+
+消耗句柄並回傳其兩個組成部分：當前值（`Rc<T>`）和 setter/dispatcher。
+當你想要在不克隆整個句柄的情況下將讀取與寫入分離時，這非常有用。
+
+對於 `UseReducerHandle`，回傳類型為 `(Rc<T>, UseReducerDispatcher<T>)`：
+
+```rust
+let state = use_reducer(CounterState::default);
+let (value, dispatcher) = state.into_inner();
+```
+
+對於 `UseStateHandle`，回傳類型為 `(Rc<T>, UseStateSetter<T>)`：
+
+```rust
+let state = use_state(|| 0);
+let (value, setter) = state.into_inner();
+```
+
 [use_state]: https://yew-rs-api.web.app/next/yew/functional/fn.use_state.html
 [use_state_eq]: https://yew-rs-api.web.app/next/yew/functional/fn.use_state_eq.html
 [use_reducer]: https://yew-rs-api.web.app/next/yew/functional/fn.use_reducer.html