feat: massage lifetimes

Author: jkelleyrtp

README.md

@@ -49,7 +49,7 @@
 Dioxus is a portable, performant, and ergonomic framework for building cross-platform user experiences in Rust.
 
 ```rust
-static App: FC<()> = |cx, props| {
+static App: FC<()> = |(cx, props)| {
     let mut count = use_state(cx, || 0);
 
     cx.render(rsx!(
@@ -96,28 +96,6 @@ If you know React, then you already know Dioxus.
 
 See the awesome-dioxus page for a curated list of content in the Dioxus Ecosystem.
 
-<!-- 
-currently commented out until we have more content on the website
-## Explore
-- [**Fine-grained reactivity**: Skip the diff overhead with signals ](docs/guides/00-index.md)
-- [**HTML Templates**: Drop in existing HTML5 templates with html! macro](docs/guides/00-index.md)
-- [**RSX Templates**: Clean component design with rsx! macro](docs/guides/00-index.md)
-- [**Running the examples**: Explore the vast collection of samples, tutorials, and demos](docs/guides/00-index.md)
-- [**Building applications**: Use the Dioxus CLI to build and bundle apps for various platforms](docs/guides/01-ssr.md)
-- [**Liveview**: Build custom liveview components that simplify datafetching on all platforms](docs/guides/01-ssr.md)
-- [**State management**: Easily add powerful state management that comes integrated with Dioxus Core](docs/guides/01-ssr.md)
-- [**Concurrency**: Drop in async where it fits and suspend components until new data is ready](docs/guides/01-ssr.md)
-- [**1st party hooks**: Cross-platform router hook](docs/guides/01-ssr.md)
-- [**Community hooks**: 3D renderers](docs/guides/01-ssr.md)
-## Blog Posts
-- [Why we need a stronger typed web]()
-- [Isomorphic webapps in 10 minutes]()
-- [Rust is high level too]()
-- [Eliminating crashes with Rust webapps]()
-- [Tailwind for Dioxus]()
-- [The monoglot startup]() 
--->
-
 ## Why?
 
 TypeScript is a great addition to JavaScript, but comes with a lot of tweaking flags, a slight performance hit, and an uneven ecosystem where some of the most important packages are not properly typed. TypeScript provides a lot of great benefits to JS projects, but comes with its own "tax" that can slow down dev teams. Rust can be seen as a step up from TypeScript, supporting:
@@ -130,7 +108,7 @@ TypeScript is a great addition to JavaScript, but comes with a lot of tweaking f
 - integrated documentation
 - inline built-in unit/integration testing
 - best-in-class error handling
-- simple and fast build system (compared to webpack!)
+- simple and fast build system (compared to WebPack!)
 - powerful standard library (no need for lodash or underscore)
 - include_str! for integrating html/css/svg templates directly
 - various macros (`html!`, `rsx!`) for fast template iteration

docs/src/README.md

@@ -6,7 +6,7 @@
 
 ```rust, ignore
 // An example Dioxus app - closely resembles React
-static App: FC<()> = |cx, props| {
+static App: FC<()> = |(cx, props)| {
     let mut count = use_state(cx, || 0);
 
     cx.render(rsx!(

docs/src/concepts/10-concurrent-mode.md

@@ -50,8 +50,8 @@ async fn ExampleLoader(cx: Context<()>) -> Vnode {
     This API stores the result on the Context object, so the loaded data is taken as reference.
     */
     let name: &Result<SomeStructure> = use_fetch_data("http://example.com/json", ())
-                                        .place_holder(|cx, props|rsx!{<div> "loading..." </div>})
-                                        .delayed_place_holder(1000, |cx, props|rsx!{ <div> "still loading..." </div>})
+                                        .place_holder(|(cx, props)|rsx!{<div> "loading..." </div>})
+                                        .delayed_place_holder(1000, |(cx, props)|rsx!{ <div> "still loading..." </div>})
                                         .await;
 
     match name {

docs/src/concepts/11-arena-memo.md

@@ -21,17 +21,17 @@ fn test() -> DomTree {
     }
 }
 
-static TestComponent: FC<()> = |cx, props|html!{<div>"Hello world"</div>};
+static TestComponent: FC<()> = |(cx, props)|html!{<div>"Hello world"</div>};
 
-static TestComponent: FC<()> = |cx, props|{
+static TestComponent: FC<()> = |(cx, props)|{
     let g = "BLAH";
     html! {
         <div> "Hello world" </div>
     }
 };
 
 #[functional_component]
-static TestComponent: FC<{ name: String }> = |cx, props|html! { <div> "Hello {name}" </div> };
+static TestComponent: FC<{ name: String }> = |(cx, props)|html! { <div> "Hello {name}" </div> };
 ```
 
 ## Why this behavior?

docs/src/concepts/12-signals.md

@@ -96,7 +96,7 @@ Sometimes you want a signal to propagate across your app, either through far-awa
 
 ```rust
 const TITLE: Atom<String> = || "".to_string();
-const Provider: FC<()> = |cx, props|{
+const Provider: FC<()> = |(cx, props)|{
     let title = use_signal(&cx, &TITLE);
     rsx!(cx, input { value: title })
 };
@@ -105,7 +105,7 @@ const Provider: FC<()> = |cx, props|{
 If we use the `TITLE` atom in another component, we can cause updates to flow between components without calling render or diffing either component trees:
 
 ```rust
-const Receiver: FC<()> = |cx, props|{
+const Receiver: FC<()> = |(cx, props)|{
     let title = use_signal(&cx, &TITLE);
     log::info!("This will only be called once!");
     rsx!(cx,
@@ -132,7 +132,7 @@ Dioxus automatically understands how to use your signals when mixed with iterato
 
 ```rust
 const DICT: AtomFamily<String, String> = |_| {};
-const List: FC<()> = |cx, props|{
+const List: FC<()> = |(cx, props)|{
     let dict = use_signal(&cx, &DICT);
     cx.render(rsx!(
         ul {

docs/src/hello_world.md

@@ -85,7 +85,7 @@ fn main() {
     dioxus::desktop::start(App, |c| c);
 }
 
-static App: FC<()> = |cx, props| {
+static App: FC<()> = |(cx, props)| {
     cx.render(rsx! (
         div { "Hello, world!" }
     ))
@@ -111,7 +111,7 @@ fn main() {
 Finally, our app. Every component in Dioxus is a function that takes in `Context` and `Props` and returns an `Option<VNode>`.
 
 ```rust
-static App: FC<()> = |cx, props| {
+static App: FC<()> = |(cx, props)| {
     cx.render(rsx! {
         div { "Hello, world!" }
     })
@@ -149,7 +149,7 @@ If we wanted to golf a bit, we can shrink our hello-world even smaller:
 
 ```rust
 fn main() {
-    static App: FC<()> = |cx, props| rsx!(cx, div {"hello world!"});
+    static App: FC<()> = |(cx, props)| rsx!(cx, div {"hello world!"});
     dioxus::web::start(App, |c| c);
 }
 ```

examples/async.rs

@@ -11,7 +11,7 @@ async fn main() {
     dioxus::desktop::launch(App, |c| c);
 }
 
-pub static App: FC<()> = |cx, _| {
+pub static App: FC<()> = |(cx, _)| {
     let count = use_state(cx, || 0);
     let mut direction = use_state(cx, || 1);
 

examples/borrowed.rs

@@ -20,8 +20,8 @@ fn main() {
     dioxus::desktop::launch(App, |c| c);
 }
 
-fn App<'a>(cx: Context<'a>, props: &()) -> DomTree<'a> {
-    let text: &'a mut Vec<String> = cx.use_hook(|_| vec![String::from("abc=def")], |f| f, |_| {});
+fn App((cx, props): Component<()>) -> DomTree {
+    let text: &mut Vec<String> = cx.use_hook(|_| vec![String::from("abc=def")], |f| f, |_| {});
 
     let first = text.get_mut(0).unwrap();
 
@@ -43,7 +43,7 @@ impl<'a> Drop for C1Props<'a> {
     fn drop(&mut self) {}
 }
 
-fn Child1<'a>(cx: Context<'a>, props: &'a C1Props) -> DomTree<'a> {
+fn Child1<'a>((cx, props): Component<'a, C1Props>) -> DomTree<'a> {
     let (left, right) = props.text.split_once("=").unwrap();
 
     cx.render(rsx! {
@@ -58,13 +58,8 @@ fn Child1<'a>(cx: Context<'a>, props: &'a C1Props) -> DomTree<'a> {
 struct C2Props<'a> {
     text: &'a str,
 }
-impl<'a> Drop for C2Props<'a> {
-    fn drop(&mut self) {
-        todo!()
-    }
-}
 
-fn Child2<'a>(cx: Context<'a>, props: &'a C2Props) -> DomTree<'a> {
+fn Child2<'a>((cx, props): Component<'a, C2Props>) -> DomTree<'a> {
     cx.render(rsx! {
         Child3 {
             text: props.text
@@ -77,7 +72,7 @@ struct C3Props<'a> {
     text: &'a str,
 }
 
-fn Child3<'a>(cx: Context<'a>, props: &C3Props) -> DomTree<'a> {
+fn Child3<'a>((cx, props): Component<'a, C3Props>) -> DomTree<'a> {
     cx.render(rsx! {
         div { "{props.text}"}
     })

examples/calculator.rs

@@ -10,7 +10,7 @@ fn main() {
     dioxus::desktop::launch(APP, |cfg| cfg);
 }
 
-const APP: FC<()> = |cx, _| {
+const APP: FC<()> = |(cx, _)| {
     let cur_val = use_state(cx, || 0.0_f64);
     let operator = use_state(cx, || None as Option<&'static str>);
     let display_value = use_state(cx, || String::from(""));
@@ -116,7 +116,7 @@ struct CalculatorKeyProps<'a> {
     onclick: &'a dyn Fn(MouseEvent),
 }
 
-fn CalculatorKey<'a>(cx: Context<'a>, props: &'a CalculatorKeyProps) -> DomTree<'a> {
+fn CalculatorKey<'a>((cx, props): Component<'a, CalculatorKeyProps>) -> DomTree<'a> {
     rsx!(cx, button {
         class: "calculator-key {props.name}"
         onclick: {props.onclick}

examples/coroutine.rs

@@ -27,7 +27,7 @@ fn main() {
 
 use dioxus::prelude::*;
 
-static App: FC<()> = |cx, props| {
+static App: FC<()> = |(cx, props)| {
     let p1 = use_state(cx, || 0);
     let p2 = use_state(cx, || 0);
 
@@ -59,7 +59,7 @@ struct HorseyProps {
     pos: i32,
 }
 
-static Horsey: FC<HorseyProps> = |cx, props| {
+static Horsey: FC<HorseyProps> = |(cx, props)| {
     cx.render(rsx! {
     div {
         button { "pause" }