Updated docs for beta4

Author: sfisol

crates/vertigo/src/bind.rs

@@ -2,6 +2,7 @@
 use std::future::Future;
 use crate::{get_driver, Context};
 
+/// Allows to create an event handler based on 1 parameter
 pub fn bind<T1: Clone>(param1: &T1) -> Bind1<T1> {
     let param1 = param1.clone();
 
@@ -10,18 +11,21 @@ pub fn bind<T1: Clone>(param1: &T1) -> Bind1<T1> {
     }
 }
 
+/// Event handler factory having 1 parameter in context
 pub struct Bind1<T1> {
     param1: T1,
 }
 
 impl<T1: Clone> Bind1<T1> {
+    /// Extend this creator to a 2-parameter one
     pub fn and<T2: Clone>(self, param2: &T2) -> Bind2<T1, T2> {
         Bind2 {
             param1: self.param1,
             param2: param2.clone(),
         }
     }
 
+    /// Create event handler that doesn't accept a parameter
     pub fn call<R>(self, fun: fn(&Context, &T1) -> R) -> impl Fn() -> R {
         let Self { param1 } = self;
 
@@ -31,6 +35,7 @@ impl<T1: Clone> Bind1<T1> {
         }
     }
 
+    /// Create event handler that accepts a parameter
     pub fn call_param<T2, R>(self, fun: fn(&Context, &T1, T2) -> R) -> impl Fn(T2) -> R {
         let Self { param1 } = self;
 
@@ -40,6 +45,7 @@ impl<T1: Clone> Bind1<T1> {
         }
     }
 
+    /// Run async code
     pub fn spawn<
         Fut: Future<Output=Context> + 'static
     >(self, fun: fn(Context, T1) -> Fut) -> impl Fn() {
@@ -56,19 +62,22 @@ impl<T1: Clone> Bind1<T1> {
     }
 }
 
+/// Allows to create an event handler based on 2 parameters
 pub fn bind2<T1: Clone, T2: Clone>(param1: &T1, param2: &T2) -> Bind2<T1, T2> {
     Bind2 {
         param1: param1.clone(),
         param2: param2.clone()
     }
 }
 
+/// Event handler factory having 2 parameters in context
 pub struct Bind2<T1, T2> {
     param1: T1,
     param2: T2,
 }
 
 impl<T1: Clone, T2: Clone> Bind2<T1, T2> {
+    /// Extend this creator to a 3-parameter one
     pub fn and<T3: Clone>(self, param3: &T3) -> Bind3<T1, T2, T3> {
         Bind3 {
             param1: self.param1,
@@ -77,6 +86,7 @@ impl<T1: Clone, T2: Clone> Bind2<T1, T2> {
         }
     }
 
+    /// Create event handler that doesn't accept a parameter
     pub fn call<R>(self, fun: fn(&Context, &T1, &T2) -> R) -> impl Fn() -> R {
         let Self { param1, param2 } = self;
 
@@ -86,6 +96,7 @@ impl<T1: Clone, T2: Clone> Bind2<T1, T2> {
         }
     }
 
+    /// Create event handler that accepts a parameter
     pub fn call_param<T3, R>(self, fun: fn(&Context, &T1, &T2, T3) -> R) -> impl Fn(T3) -> R {
         let Self { param1, param2 } = self;
 
@@ -95,6 +106,7 @@ impl<T1: Clone, T2: Clone> Bind2<T1, T2> {
         }
     }
 
+    /// Run async code
     pub fn spawn<
         Fut: Future<Output=Context> + 'static
     >(self, fun: fn(Context, T1, T2) -> Fut) -> impl Fn() {
@@ -112,6 +124,7 @@ impl<T1: Clone, T2: Clone> Bind2<T1, T2> {
     }
 }
 
+/// Allows to create an event handler based on 3 parameters
 pub fn bind3<T1: Clone, T2: Clone, T3: Clone>(param1: &T1, param2: &T2, param3: &T3) -> Bind3<T1, T2, T3> {
     Bind3 {
         param1: param1.clone(),
@@ -120,13 +133,15 @@ pub fn bind3<T1: Clone, T2: Clone, T3: Clone>(param1: &T1, param2: &T2, param3:
     }
 }
 
+/// Event handler factory having 3 parameters in context
 pub struct Bind3<T1, T2, T3> {
     param1: T1,
     param2: T2,
     param3: T3,
 }
 
 impl<T1: Clone, T2: Clone, T3: Clone> Bind3<T1, T2, T3> {
+    /// Extend this creator to a 4-parameter one
     pub fn and<T4: Clone>(self, param4: &T4) -> Bind4<T1, T2, T3, T4> {
         Bind4 {
             param1: self.param1,
@@ -136,6 +151,7 @@ impl<T1: Clone, T2: Clone, T3: Clone> Bind3<T1, T2, T3> {
         }
     }
 
+    /// Create event handler that doesn't accept a parameter
     pub fn call<R>(self, fun: fn(&Context, &T1, &T2, &T3) -> R) -> impl Fn() -> R {
         let Self { param1, param2, param3 } = self;
 
@@ -145,6 +161,7 @@ impl<T1: Clone, T2: Clone, T3: Clone> Bind3<T1, T2, T3> {
         }
     }
 
+    /// Create event handler that accepts a parameter
     pub fn call_param<T4, R>(self, fun: fn(&Context, &T1, &T2, &T3, T4) -> R) -> impl Fn(T4) -> R {
         let Self { param1, param2, param3 } = self;
 
@@ -154,6 +171,7 @@ impl<T1: Clone, T2: Clone, T3: Clone> Bind3<T1, T2, T3> {
         }
     }
 
+    /// Run async code
     pub fn spawn<
         Fut: Future<Output=Context> + 'static
     >(self, fun: fn(Context, T1, T2, T3) -> Fut) -> impl Fn() {
@@ -172,6 +190,7 @@ impl<T1: Clone, T2: Clone, T3: Clone> Bind3<T1, T2, T3> {
     }
 }
 
+/// Allows to create an event handler based on 4 parameters
 pub fn bind4<T1: Clone, T2: Clone, T3: Clone, T4: Clone>(param1: &T1, param2: &T2, param3: &T3, param4: &T4) -> Bind4<T1, T2, T3, T4> {
     Bind4 {
         param1: param1.clone(),
@@ -181,6 +200,7 @@ pub fn bind4<T1: Clone, T2: Clone, T3: Clone, T4: Clone>(param1: &T1, param2: &T
     }
 }
 
+/// Event handler factory having 4 parameters in context
 pub struct Bind4<T1, T2, T3, T4> {
     param1: T1,
     param2: T2,
@@ -189,6 +209,7 @@ pub struct Bind4<T1, T2, T3, T4> {
 }
 
 impl<T1: Clone, T2: Clone, T3: Clone, T4: Clone> Bind4<T1, T2, T3, T4> {
+    /// Create event handler that doesn't accept a parameter
     pub fn call<R>(self, fun: fn(&Context, &T1, &T2, &T3, &T4) -> R) -> impl Fn() -> R {
         let Self { param1, param2, param3, param4 } = self;
 
@@ -198,6 +219,7 @@ impl<T1: Clone, T2: Clone, T3: Clone, T4: Clone> Bind4<T1, T2, T3, T4> {
         }
     }
 
+    /// Create event handler that accepts a parameter
     pub fn call_param<T5, R>(self, fun: fn(&Context, &T1, &T2, &T3, &T4, T5) -> R) -> impl Fn(T5) -> R {
         let Self { param1, param2, param3, param4 } = self;
 
@@ -207,6 +229,7 @@ impl<T1: Clone, T2: Clone, T3: Clone, T4: Clone> Bind4<T1, T2, T3, T4> {
         }
     }
 
+    /// Run async code
     pub fn spawn<
         Fut: Future<Output=Context> + 'static,
     >(self, fun: fn(Context, T1, T2, T3, T4) -> Fut) -> impl Fn() {

crates/vertigo/src/dom/dom_comment.rs

@@ -1,6 +1,7 @@
 use crate::{Driver, struct_mut::VecMut, get_driver, Client};
 use super::dom_id::DomId;
 
+/// A Real DOM representative - comment kind
 pub struct DomComment {
     driver: Driver,
     pub id_dom: DomId,

crates/vertigo/src/dom/dom_element.rs

@@ -75,6 +75,7 @@ impl PartialEq for DomElementRef {
     }
 }
 
+/// A Real DOM representative - element kind
 pub struct DomElement {
     driver: Driver,
     id_dom: DomId,

crates/vertigo/src/dom/dom_node.rs

@@ -5,6 +5,7 @@ use crate::{dom::{
 
 use super::{dom_id::DomId, dom_comment::DomComment};
 
+/// A Real DOM representative
 pub enum DomNode {
     Node { node: DomElement },
     Text { node: DomText },
@@ -53,7 +54,7 @@ impl<T: Into<String>> From<T> for DomNode {
     }
 }
 
-
+/// DomNode not connected yet to any parent
 pub enum DomNodeFragment {
     Node { node: DomElement },
     Text { node: DomText },

crates/vertigo/src/dom/dom_text.rs

@@ -32,6 +32,7 @@ impl<T: Clone + 'static> ToComputed<T> for &Value<T> {
 }
 
 
+/// A Real DOM representative - text kind
 pub struct DomText {
     driver: Driver,
     id_dom: DomId,

crates/vertigo/src/dom_list.rs

@@ -64,7 +64,7 @@ pub fn render_list<
                 let get_key = get_key.clone();
                 let render = render.clone();
                 let parent = parent.clone();
-        
+
                 move |current| {
                     let current_list = std::mem::take(current);
 
@@ -76,7 +76,7 @@ pub fn render_list<
                         get_key.clone(),
                         render,
                     );
-                    
+
 
                     let list_refs = get_refs(&new_order);
                     *current = new_order;

crates/vertigo/src/lib.rs

@@ -2,14 +2,14 @@
 //!
 //! It mainly consists of three parts:
 //!
-//! * **Virtual DOM** - Lightweight representation of JavaScript DOM that can be used to optimally update real DOM
-//! * **Reactive dependencies** - A graph of values and clients that can automatically compute what to refresh after one value change
-//! * **HTML/CSS macros** - Allows to construct Virtual DOM nodes using HTML and CSS
+//! * **Reactive dependencies** - A graph of values and clients (micro-subscriptions) that can automatically compute what to refresh after one value change
+//! * **Real DOM** - No intermediate Virtual DOM mechanism is necessary
+//! * **HTML/CSS macros** - Allows to construct Real DOM nodes using HTML and CSS
 //!
 //! ## Example
 //!
 //! ```rust
-//! use vertigo::{Computed, DomElement, Value, dom, css_fn};
+//! use vertigo::{DomElement, Value, dom, css_fn};
 //!
 //! pub struct State {
 //!     pub message: Value<String>,
@@ -33,7 +33,7 @@
 //!     dom! {
 //!         <div css={main_div()}>
 //!             "Message to the world: "
-//!             <text computed={&state.message} />
+//!             { state.message }
 //!         </div>
 //!     }
 //! }
@@ -93,7 +93,7 @@ pub use dom::types::{
 };
 pub use websocket::{WebsocketConnection, WebsocketMessage};
 pub use future_box::{FutureBoxSend, FutureBox};
-pub use bind::{bind, bind2, bind3, bind4};
+pub use bind::{bind, bind2, bind3, bind4, Bind1, Bind2, Bind3, Bind4};
 pub use driver_module::driver::{FetchMethod};
 pub use dom::{
     dom_id::DomId,