WIP: local state

examples/tutorial/src/main.rs

@@ -1,6 +1,6 @@
 use std::collections::BTreeMap;
 
-use ravel::with;
+use ravel::{with, with_state};
 use ravel_web::{
     any, attr,
     collections::{btree_map, slice},
@@ -112,6 +112,27 @@ fn events() -> View!(Model) {
     )
 }
 
+fn local_state() -> View!(Model) {
+    with_state(
+        || 0,
+        |cx, local_count| {
+            cx.build((
+                el::h2("Local state"),
+                el::p(("Local count: ", display(*local_count.borrow()))),
+                el::p(el::button((
+                    "Increment local count",
+                    on_(event::Click, {
+                        let local_count = local_count.clone();
+                        move |_| {
+                            *local_count.borrow_mut() += 1;
+                        }
+                    }),
+                ))),
+            ))
+        },
+    )
+}
+
 /// All of our views so far have had a static structure. Sometimes, we need to
 /// swap out or hide various components.
 fn dynamic_view(model: &Model) -> View!(Model, '_) {
@@ -198,6 +219,7 @@ fn tutorial(model: &Model) -> View!(Model, '_) {
         basic_html(),
         state(model),
         events(),
+        local_state(),
         dynamic_view(model),
         lists(model),
     )

ravel-web/src/lib.rs

@@ -4,7 +4,7 @@ use std::sync::Arc;
 
 use atomic_waker::AtomicWaker;
 use dom::Position;
-use ravel::{Builder, Cx, CxRep};
+use ravel::{Builder, Cx, CxRep, WithStateState};
 
 mod any;
 pub mod attr;
@@ -50,9 +50,20 @@ pub trait State<Output>: AsAny {
     fn run(&mut self, output: &mut Output);
 }
 
+impl<Output, T: 'static, S> State<Output> for WithStateState<T, S>
+where
+    S: State<Output>,
+{
+    fn run(&mut self, output: &mut Output) {
+        self.inner.run(output)
+    }
+}
+
 /// A marker trait for the [`State`] types of a [`trait@View`].
 pub trait ViewMarker {}
 
+impl<T: 'static, S: ViewMarker> ViewMarker for WithStateState<T, S> {}
+
 macro_rules! tuple_state {
     ($($a:ident),*) => {
         #[allow(non_camel_case_types)]

ravel/src/lib.rs

@@ -7,6 +7,10 @@ use std::{marker::PhantomData, mem::MaybeUninit};
 
 use paste::paste;
 
+mod state;
+
+pub use state::*;
+
 /// A dummy type which typically represents a "backend".
 pub trait CxRep {
     type BuildCx<'a>: Copy;

ravel/src/state.rs

@@ -0,0 +1,47 @@
+use std::{cell::RefCell, marker::PhantomData, rc::Rc};
+
+use crate::{with, Builder, Cx, CxRep, Token};
+
+pub struct WithState<Init, Build, S> {
+    init: Init,
+    build: Build,
+    phantom: PhantomData<S>,
+}
+
+impl<R: CxRep, T, Init, Build, S> Builder<R> for WithState<Init, Build, S>
+where
+    Init: FnOnce() -> T,
+    Build: FnOnce(Cx<S, R>, &Rc<RefCell<T>>) -> Token<S>,
+{
+    type State = WithStateState<T, S>;
+
+    fn build(self, cx: R::BuildCx<'_>) -> Self::State {
+        let value = Rc::new(RefCell::new((self.init)()));
+        let inner = with(|cx| (self.build)(cx, &value)).build(cx);
+        WithStateState { value, inner }
+    }
+
+    fn rebuild(self, cx: R::RebuildCx<'_>, state: &mut Self::State) {
+        with(|cx| (self.build)(cx, &state.value)).rebuild(cx, &mut state.inner)
+    }
+}
+
+pub struct WithStateState<T, S> {
+    value: Rc<RefCell<T>>,
+    pub inner: S,
+}
+
+pub fn with_state<T, Init, Build, S, R: CxRep>(
+    init: Init,
+    build: Build,
+) -> WithState<Init, Build, S>
+where
+    Init: FnOnce() -> T,
+    Build: FnOnce(Cx<S, R>, &Rc<RefCell<T>>) -> Token<S>,
+{
+    WithState {
+        init,
+        build,
+        phantom: PhantomData,
+    }
+}