wip: redesign csr

Author: EqualMa

packages/frender-common/src/reactive_value.rs

@@ -53,21 +53,20 @@ pub trait ReusableRendererOfKind<VK: ?Sized + ReactiveValueKind> {
     fn reuse(self, provide_value: impl ProvideValueOfKind<VK>) -> Self::Output;
 }
 
+/// `for<R: FnOnce(VK::Value<'_>) -> Out, Out> RenderInitPinned<R, S, Output = R::RenderOutput>`
+pub trait ReactiveValueRenderInitPinned<VK: ?Sized + ReactiveValueKind, S: ?Sized>: Sized {
+    type RenderInitPinned<R: FnOnce(VK::Value<'_>) -> Out, Out>: RenderInitPinned<R, S, Output = Out>
+        + From<Self>;
+}
+
 pub trait ReactiveValue<VK: ?Sized + ReactiveValueKind> {
     type PinnedState: ReactiveValueState<ReactiveValueKind = VK>;
-    type PinnedRenderInit<R: FnOnce(VK::Value<'_>) -> Out, Out>: RenderInitPinned<
-        R,
-        Self::PinnedState,
-        Output = Out,
-    >;
+    type PinnedRenderInit: ReactiveValueRenderInitPinned<VK, Self::PinnedState>;
 
     /// Requires [`Unpin`] so that [`ReactiveValueState`] can be reused without defining another trait taking `&mut self`.
     type UnpinnedState: Unpin + ReactiveValueState<ReactiveValueKind = VK>;
 
-    /// `state` is `Default::default()` at a pinned place.
-    fn pinned_render_init<R: FnOnce(VK::Value<'_>) -> Out, Out>(
-        self,
-    ) -> (Self::PinnedState, Self::PinnedRenderInit<R, Out>);
+    fn pinned_render_init(self) -> (Self::PinnedState, Self::PinnedRenderInit);
 
     /// `old_state` has been [unmounted](ReactiveStrStateUnmount::reactive_value_state_unmount) but not necessarily set to `Default::default()`.
     fn pinned_render_init_by_reusing<Out>(
@@ -233,8 +232,12 @@ pub fn unpinned_render_init_with_pinned<
 where
     V::PinnedState: Unpin,
 {
-    let (mut state, render_init) = V::pinned_render_init::<R, Out>(this);
+    let (mut state, render_init) = V::pinned_render_init(this);
 
-    let out = render_init.render_init_pinned(renderer, ::core::pin::Pin::new(&mut state));
+    let out = <<V::PinnedRenderInit as ReactiveValueRenderInitPinned<VK, _>>::RenderInitPinned<
+        R,
+        Out,
+    >>::from(render_init)
+    .render_init_pinned(renderer, ::core::pin::Pin::new(&mut state));
     (state, out)
 }

packages/frender-common/src/reactive_value/csr_str.rs

@@ -1,12 +1,13 @@
-use std::{marker::PhantomData, pin::Pin, task::Poll};
+use std::{pin::Pin, task::Poll};
 
 use crate::{
     csr::StateUnmount, reactive_value::ProvideValueOfKind, strings::CsrStr, IntoStaticStrCache,
     TempStr, ToAsRefStr,
 };
 
 use super::{
-    ReactiveValue, ReactiveValueKind, ReactiveValueState, RenderInitPinned, ReusableRendererOfKind,
+    ReactiveValue, ReactiveValueKind, ReactiveValueRenderInitPinned, ReactiveValueState,
+    RenderInitPinned, ReusableRendererOfKind,
 };
 
 impl ReactiveValueKind for str {
@@ -48,20 +49,21 @@ impl<Cache: ToAsRefStr, R: FnOnce(TempStr<&str>) -> Out, Out> RenderInitPinned<R
     }
 }
 
+impl<Cache: ToAsRefStr> ReactiveValueRenderInitPinned<str, State<Cache>> for RenderInit {
+    type RenderInitPinned<R: FnOnce(<str as ReactiveValueKind>::Value<'_>) -> Out, Out> = Self;
+}
+
 /// [`CsrStr`] are non reactive
 impl<T: CsrStr> ReactiveValue<str> for T {
     type PinnedState = State<T::StaticStrCache>;
     type UnpinnedState = State<T::StaticStrCache>;
-    type PinnedRenderInit<R: FnOnce(<str as ReactiveValueKind>::Value<'_>) -> Out, Out> =
-        RenderInit;
+    type PinnedRenderInit = RenderInit;
 
     crate::impl_reactive_value_with_mixed_unpinned!(
         type ReactiveValueKind = str;
     );
 
-    fn pinned_render_init<R: FnOnce(<str as ReactiveValueKind>::Value<'_>) -> Out, Out>(
-        self,
-    ) -> (Self::PinnedState, Self::PinnedRenderInit<R, Out>) {
+    fn pinned_render_init(self) -> (Self::PinnedState, Self::PinnedRenderInit) {
         (
             State(self.into_into_static_str_cache().into_static_str_cache()),
             RenderInit,

packages/frender-common/src/reactive_value/simple_non_reactive.rs

@@ -1,10 +1,13 @@
-use std::{marker::PhantomData, task::Poll};
+use std::task::Poll;
 
 use frender_macro_rules::impl_many;
 
 use crate::{csr::StateUnmount, reactive_value::ProvideValueOfKind};
 
-use super::{ReactiveValue, ReactiveValueKind, ReactiveValueState, RenderInitPinned};
+use super::{
+    ReactiveValue, ReactiveValueKind, ReactiveValueRenderInitPinned, ReactiveValueState,
+    RenderInitPinned,
+};
 
 trait KnownSimpleNonReactive: 'static + Copy + PartialEq {}
 
@@ -56,8 +59,8 @@ impl<T: KnownSimpleNonReactive> ReactiveValueState for State<T> {
 
 pub struct RenderInit;
 
-impl<T: KnownSimpleNonReactive, R: FnOnce(<T as ReactiveValueKind>::Value<'_>) -> Out, Out>
-    RenderInitPinned<R, State<T>> for RenderInit
+impl<T: KnownSimpleNonReactive, R: FnOnce(T) -> Out, Out> RenderInitPinned<R, State<T>>
+    for RenderInit
 {
     type Output = Out;
 
@@ -66,18 +69,20 @@ impl<T: KnownSimpleNonReactive, R: FnOnce(<T as ReactiveValueKind>::Value<'_>) -
     }
 }
 
+impl<T: KnownSimpleNonReactive> ReactiveValueRenderInitPinned<T, State<T>> for RenderInit {
+    type RenderInitPinned<R: FnOnce(<T as ReactiveValueKind>::Value<'_>) -> Out, Out> = Self;
+}
+
 impl<T: KnownSimpleNonReactive> ReactiveValue<T> for T {
     type PinnedState = State<T>;
-    type PinnedRenderInit<R: FnOnce(<T as ReactiveValueKind>::Value<'_>) -> Out, Out> = RenderInit;
+    type PinnedRenderInit = RenderInit;
     type UnpinnedState = State<T>;
 
     crate::impl_reactive_value_with_mixed_unpinned!(
         type ReactiveValueKind = T;
     );
 
-    fn pinned_render_init<R: FnOnce(<T as ReactiveValueKind>::Value<'_>) -> Out, Out>(
-        self,
-    ) -> (Self::PinnedState, Self::PinnedRenderInit<R, Out>) {
+    fn pinned_render_init(self) -> (Self::PinnedState, Self::PinnedRenderInit) {
         (State(self), RenderInit)
     }
 

packages/frender-dom/src/string_element/reactive_value.rs

@@ -1,7 +1,8 @@
 use std::task::Poll;
 
 use frender_common::reactive_value::{
-    ProvideValueOfKind, ReactiveValue, ReactiveValueKind, ReactiveValueState, RenderInitPinned,
+    ProvideValueOfKind, ReactiveValue, ReactiveValueKind, ReactiveValueRenderInitPinned,
+    ReactiveValueState, RenderInitPinned,
 };
 use frender_csr::StateUnmount;
 
@@ -39,22 +40,21 @@ impl<R: FnOnce(&StringElement) -> Out, Out> RenderInitPinned<R, State> for Rende
     }
 }
 
+impl ReactiveValueRenderInitPinned<StringElement, State> for RenderInit {
+    type RenderInitPinned<R: FnOnce(<StringElement as ReactiveValueKind>::Value<'_>) -> Out, Out> =
+        Self;
+}
+
 impl ReactiveValue<StringElement> for StringElement {
     type UnpinnedState = State;
     type PinnedState = State;
-    type PinnedRenderInit<R: FnOnce(<StringElement as ReactiveValueKind>::Value<'_>) -> Out, Out> =
-        RenderInit;
+    type PinnedRenderInit = RenderInit;
 
     frender_common::impl_reactive_value_with_mixed_unpinned!(
         type ReactiveValueKind = StringElement;
     );
 
-    fn pinned_render_init<
-        R: FnOnce(<StringElement as ReactiveValueKind>::Value<'_>) -> Out,
-        Out,
-    >(
-        self,
-    ) -> (Self::PinnedState, Self::PinnedRenderInit<R, Out>) {
+    fn pinned_render_init(self) -> (Self::PinnedState, Self::PinnedRenderInit) {
         (State(self), RenderInit)
     }
 

packages/frender-html/src/element.rs

@@ -128,17 +128,17 @@ pub trait CsrElement {
 #[macro_export]
 macro_rules! proxy_csr_element {
     (|$this:pat_param| $expr:expr) => {
-        fn pinned_render_init<TCsrElementRenderer: ?::core::marker::Sized + $crate::RenderHtml>(
+        fn pinned_render_init<Ctx: ?::core::marker::Sized + $crate::HtmlRenderContext>(
             //
             self,
-            renderer: &mut TCsrElementRenderer,
+            render_context: &mut Ctx,
         ) -> (
             //
-            $crate::__private::PinnedStateOfKind<TCsrElementRenderer, Self::RenderStateKind>,
-            Self::PinnedRenderInit<TCsrElementRenderer>,
+            $crate::__private::PinnedStateOfKind<Ctx::Renderer, Self::RenderStateKind>,
+            Self::PinnedRenderInit<Ctx::Renderer>,
         ) {
             let $this = self;
-            $expr.pinned_render_init(renderer)
+            $expr.pinned_render_init(render_context)
         }
 
         fn pinned_render_init_by_reusing<Ctx: ?Sized + $crate::HtmlRenderContext>(

packages/frender-html/src/elements/array.rs

@@ -1,10 +1,9 @@
 use std::{pin::Pin, task::Poll};
 
 use frender_common::utils::pin_project_iter_mut_array;
-use frender_dom::render::RenderWithContext;
 
 use crate::{
-    element::{self, CsrElementRenderInitPinned, PinnedRenderInitKind, PinnedRenderStateKind, PinnedRenderStateKindPollRender, UnpinnedRenderStateKind, UnpinnedRenderStateKindPollRender},
+    element::{self, PinnedRenderStateKind, PinnedRenderStateKindPollRender, UnpinnedRenderStateKind, UnpinnedRenderStateKindPollRender},
     CsrElement, HtmlRenderContext, RenderHtml,
 };
 
@@ -39,22 +38,6 @@ impl<K: PinnedRenderStateKind, const N: usize> PinnedRenderStateKind for Kind<K,
     type PinnedUiHandle<R: RenderHtml + ?Sized> = [K::PinnedUiHandle<R>; N];
     type PinnedState<R: RenderHtml + ?Sized> = [K::PinnedState<R>; N];
 }
-impl<K: PinnedRenderInitKind, const N: usize> PinnedRenderInitKind for Kind<K, N> {
-    type PinnedRenderStateKind = Kind<K::PinnedRenderStateKind, N>;
-    type PinnedRenderInit<R: RenderHtml + ?Sized> = [K::PinnedRenderInit<R>; N];
-}
-
-impl<T: CsrElementRenderInitPinned<R>, const N: usize, R: ?Sized + RenderWithContext> CsrElementRenderInitPinned<R> for [T; N] {
-    type UiHandle = [T::UiHandle; N];
-    type State = [T::State; N];
-
-    fn render_init_pinned(self, render_context: &mut R::RenderContext<'_>, state: Pin<&mut Self::State>) -> Self::UiHandle {
-        let mut state = pin_project_iter_mut_array(state);
-        // This relies on a documented feature of <[_; N]>::map():
-        // > ..., with function f applied to each element in order
-        self.map(|this| this.render_init_pinned(render_context, state.next().unwrap()))
-    }
-}
 
 impl<K: PinnedRenderStateKindPollRender, const N: usize> PinnedRenderStateKindPollRender for Kind<K, N> {
     fn pinned_poll_render<R: RenderHtml + ?Sized>(
@@ -77,23 +60,23 @@ impl<K: PinnedRenderStateKindPollRender, const N: usize> PinnedRenderStateKindPo
 
 impl<E: CsrElement, const N: usize> CsrElement for [E; N] {
     type RenderStateKind = Kind<E::RenderStateKind, N>;
-    type RenderInitKind = Kind<E::RenderInitKind, N>;
+    type PinnedRenderInit<R: ?Sized + RenderHtml> = [E::PinnedRenderInit<R>; N];
 
-    fn pinned_render_init<Renderer: ?Sized + RenderHtml>(
+    fn pinned_render_init<Ctx: ?Sized + HtmlRenderContext>(
         //
         self,
-        renderer: &mut Renderer,
+        render_context: &mut Ctx,
     ) -> (
         //
-        element::PinnedStateOfKind<Renderer, Self::RenderStateKind>,
-        element::PinnedRenderInitOfKind<Renderer, Self::RenderInitKind>,
+        element::PinnedStateOfKind<Ctx::Renderer, Self::RenderStateKind>,
+        Self::PinnedRenderInit<Ctx::Renderer>,
     ) {
         use arrayvec::ArrayVec;
 
         let (states, render_inits) = self
             .into_iter()
             //
-            .map(|el| el.pinned_render_init(renderer))
+            .map(|el| el.pinned_render_init(render_context))
             .unzip::<_, _, ArrayVec<_, N>, ArrayVec<_, N>>();
 
         let (

packages/frender-html/src/elements/boxed.rs

@@ -2,7 +2,7 @@ use crate::CsrElement;
 
 impl<E: CsrElement> CsrElement for Box<E> {
     type RenderStateKind = E::RenderStateKind;
-    type RenderInitKind = E::RenderInitKind;
+    type PinnedRenderInit<R: ?Sized + crate::RenderHtml> = E::PinnedRenderInit<R>;
 
     crate::proxy_csr_element!(|this| *this);
 }