Refactor and remove ActionResult enum

crates/concoct-web/src/html.rs

@@ -1,6 +1,6 @@
 use concoct::{
  hook::{use_context, use_provider, use_ref},
- ActionResult, IntoAction, View,
+ IntoAction, View,
 };
 use std::{borrow::Cow, cell::RefCell, rc::Rc};
 use web_sys::{
@@ -35,7 +35,7 @@ struct Data<T, A> {
  element: Option<Element>,
  callbacks: Vec<(
  Closure<dyn FnMut(Event)>,
- Rc<RefCell<Rc<RefCell<dyn FnMut(&mut T, Event) -> Option<ActionResult<A>>>>>>,
+ Rc<RefCell<Rc<RefCell<dyn FnMut(&mut T, Event) -> Option<A>>>>>,
  )>,
 }
 
@@ -44,7 +44,7 @@ pub struct Html<C, T, A> {
  attrs: Vec<(Cow<'static, str>, Cow<'static, str>)>,
  handlers: Vec<(
  Cow<'static, str>,
- Rc<RefCell<dyn FnMut(&mut T, Event) -> Option<ActionResult<A>>>>,
+ Rc<RefCell<dyn FnMut(&mut T, Event) -> Option<A>>>,
  )>,
  content: C,
 }

crates/concoct/src/hook/mod.rs

@@ -1,3 +1,5 @@
+//! Hooks to access view context.
+
 mod use_context;
 pub use self::use_context::use_context;
 

crates/concoct/src/hook/use_context.rs

@@ -1,6 +1,7 @@
 use crate::Scope;
 use std::{any::TypeId, rc::Rc};
 
+/// Hook to get a context from its type.
 pub fn use_context<T, A, R: 'static>(cx: &Scope<T, A>) -> Rc<R> {
  let contexts = cx.contexts.borrow();
  let rc = contexts.get(&TypeId::of::<R>()).unwrap();

crates/concoct/src/hook/use_provider.rs

@@ -1,8 +1,8 @@
+use super::use_ref;
 use crate::Scope;
 use std::{any::TypeId, rc::Rc};
 
-use super::use_ref;
-
+/// Hook to provide a context.
 pub fn use_provider<T, A, R: 'static>(cx: &Scope<T, A>, make_initial: impl FnOnce() -> R) {
  let value = use_ref(cx, || Rc::new(make_initial()));
 

crates/concoct/src/hook/use_ref.rs

@@ -1,6 +1,10 @@
 use crate::Scope;
 use std::cell::UnsafeCell;
 
+/// Hook to store a stateless value.
+///
+/// This function will only call `make_initial` once,
+/// on the first render, to create the initial value.
 pub fn use_ref<T, A, R: 'static>(cx: &Scope<T, A>, make_initial: impl FnOnce() -> R) -> &mut R {
  let mut node = cx.node.inner.borrow_mut();
  let idx = node.hook_idx;
@@ -12,5 +16,8 @@ pub fn use_ref<T, A, R: 'static>(cx: &Scope<T, A>, make_initial: impl FnOnce() -
  node.hooks.push(UnsafeCell::new(Box::new(make_initial())));
  node.hooks.last().unwrap()
  };
+
+ // Safety: All references to scope are dropped before `hook_idx` is reset.
+ // This ensures unique access to each hook.
  unsafe { &mut *cell.get() }.downcast_mut().unwrap()
 }

crates/concoct/src/lib.rs

@@ -36,25 +36,20 @@ pub mod hook;
 pub mod view;
 pub use self::view::View;
 
-pub enum ActionResult<A> {
- Action(A),
- Rebuild,
-}
-
 pub struct Handle<T, A = ()> {
- update: Rc<dyn Fn(Rc<dyn Fn(&mut T) -> Option<ActionResult<A>>>)>,
+ update: Rc<dyn Fn(Rc<dyn Fn(&mut T) -> Option<A>>)>,
 }
 
 impl<T, A> Handle<T, A> {
- pub fn update(&self, f: Rc<dyn Fn(&mut T) -> Option<ActionResult<A>>>) {
+ pub fn update(&self, f: Rc<dyn Fn(&mut T) -> Option<A>>) {
  (self.update)(f)
  }
 }
 
 pub struct Scope<T, A = ()> {
  key: DefaultKey,
  node: Node,
- update: Rc<dyn Fn(Rc<dyn Fn(&mut T) -> Option<ActionResult<A>>>)>,
+ update: Rc<dyn Fn(Rc<dyn Fn(&mut T) -> Option<A>>)>,
  is_empty: Cell<bool>,
  nodes: Rc<RefCell<SlotMap<DefaultKey, Node>>>,
  contexts: RefCell<FxHashMap<TypeId, Rc<dyn Any>>>,
@@ -81,10 +76,11 @@ struct Node {
 }
 
 struct Channel<T> {
- updates: Vec<Rc<dyn Fn(&mut T) -> Option<ActionResult<()>>>>,
+ updates: Vec<Rc<dyn Fn(&mut T) -> Option<()>>>,
  waker: Option<Waker>,
 }
 
+/// Virtual DOM for a view.
 pub struct VirtualDom<T, V> {
  content: V,
  nodes: Rc<RefCell<SlotMap<DefaultKey, Node>>>,
@@ -93,6 +89,7 @@ pub struct VirtualDom<T, V> {
 }
 
 impl<T, V> VirtualDom<T, V> {
+ /// Create a new virtual dom from its content.
  pub fn new(content: V) -> Self {
  Self {
  content,
@@ -105,6 +102,7 @@ impl<T, V> VirtualDom<T, V> {
  }
  }
 
+ /// Build the initial content.
  pub fn build(&mut self)
  where
  T: 'static,
@@ -132,6 +130,10 @@ impl<T, V> VirtualDom<T, V> {
  build_inner(&mut self.content, &cx)
  }
 
+ /// Rebuild the content from the last build
+ ///
+ /// ## Panics
+ /// This function will panic if no initial build has been performed.
  pub async fn rebuild(&mut self)
  where
  T: 'static,
@@ -254,35 +256,38 @@ where
  }
 }
 
+/// Marker trait for an action.
 pub trait Action {}
 
+/// Convert an output to an optional action.
 pub trait IntoAction<A>: sealed::Sealed {
- fn into_action(self) -> Option<ActionResult<A>>;
+ fn into_action(self) -> Option<A>;
 }
+
 mod sealed {
  pub trait Sealed {}
 }
 
 impl sealed::Sealed for () {}
 
 impl<A> IntoAction<A> for () {
- fn into_action(self) -> Option<ActionResult<A>> {
+ fn into_action(self) -> Option<A> {
  None
  }
 }
 
 impl<A: Action> sealed::Sealed for A {}
 
 impl<A: Action> IntoAction<A> for A {
- fn into_action(self) -> Option<ActionResult<A>> {
- Some(ActionResult::Action(self))
+ fn into_action(self) -> Option<A> {
+ Some(self)
  }
 }
 
-impl<A: Action> sealed::Sealed for Option<ActionResult<A>> {}
+impl<A: Action> sealed::Sealed for Option<A> {}
 
-impl<A: Action> IntoAction<A> for Option<ActionResult<A>> {
- fn into_action(self) -> Option<ActionResult<A>> {
+impl<A: Action> IntoAction<A> for Option<A> {
+ fn into_action(self) -> Option<A> {
  self
  }
 }

crates/concoct/src/view/adapt.rs

@@ -1,4 +1,4 @@
-use crate::{build_inner, rebuild_inner, ActionResult, Scope, View};
+use crate::{build_inner, rebuild_inner, Scope, View};
 use std::{cell::RefCell, marker::PhantomData, rc::Rc};
 
 /// Adapt a view's state to a different one.
@@ -8,8 +8,7 @@ where
  A1: 'static,
  T2: 'static,
  A2: 'static,
- F: FnMut(&mut T1, Rc<dyn Fn(&mut T2) -> Option<ActionResult<A2>>>) -> Option<ActionResult<A1>>
- + 'static,
+ F: FnMut(&mut T1, Rc<dyn Fn(&mut T2) -> Option<A2>>) -> Option<A1> + 'static,
  V: View<T2, A2>,
 {
  Adapt {
@@ -32,14 +31,13 @@ where
  A1: 'static,
  T2: 'static,
  A2: 'static,
- F: FnMut(&mut T1, Rc<dyn Fn(&mut T2) -> Option<ActionResult<A2>>>) -> Option<ActionResult<A1>>
- + 'static,
+ F: FnMut(&mut T1, Rc<dyn Fn(&mut T2) -> Option<A2>>) -> Option<A1> + 'static,
  V: View<T2, A2>,
 {
  fn body(&mut self, cx: &crate::Scope<T1, A1>) -> impl View<T1, A1> {
  let parent_update = cx.update.clone();
  let mapper = self.f.clone();
- let update = Rc::new(move |f: Rc<dyn Fn(&mut T2) -> Option<ActionResult<A2>>>| {
+ let update = Rc::new(move |f: Rc<dyn Fn(&mut T2) -> Option<A2>>| {
  let mapper = mapper.clone();
  parent_update(Rc::new(move |state| mapper.borrow_mut()(state, f.clone())))
  });

crates/concoct/src/view/mod.rs

@@ -1,3 +1,5 @@
+//! Viewable components.
+
 use crate::{build_inner, hook::use_context, rebuild_inner, Scope, TextViewContext};
 use std::{cell::Cell, rc::Rc};