fix: readme and examples syntax

Author: jkelleyrtp

README.md

@@ -23,30 +23,24 @@
   </a>
   <!-- CI -->
   <a href="https://github.com/jkelleyrtp/dioxus/actions">
-    <img src="https://github.com/jkelleyrtp/dioxus/workflows/CI/badge.svg"
+    <img src="https://github.com/dioxuslabs/dioxus/actions/workflows/main.yml/badge.svg"
       alt="CI status" />
   </a>
 </div>
 
 <div align="center">
   <h3>
-    <a href="https://docs.rs/dioxus">
-      API Docs
-    </a>
+    <a href="https://dioxuslabs.com/guide"> Guide </a>
     <span> | </span>
-    <a href="https://docs.rs/dioxus">
-      Website
-    </a>
+    <a href="https://dioxuslabs.com"> Website </a>
     <span> | </span>
-    <a href="https://docs.rs/dioxus">
-      Examples
-    </a>
+    <a href="https://github.com/DioxusLabs/awesome-dioxus"> Examples </a>
   </h3>
 </div>
 
 <br/>
 
-Dioxus is a portable, performant, and ergonomic framework for building cross-platform user experiences in Rust.
+Dioxus is a portable, performant, and ergonomic framework for building cross-platform user interfaces in Rust.
 
 ```rust
 fn app(cx: Scope) -> Element {
@@ -67,21 +61,21 @@ If you know React, then you already know Dioxus.
 ### Unique features:
 - Desktop apps running natively (no Electron!) in less than 10 lines of code.
 - Incredibly ergonomic and powerful state management.
-- Incredible inline documentation - hover and guides for all HTML elements, listeners, and events.
+- Comprehensive inline documentation - hover and guides for all HTML elements, listeners, and events.
 - Extremely memory efficient - 0 global allocations for steady-state components.
-- Multithreaded asynchronous coroutine scheduler for first-class async support.
-- And more! Read the full release post here.
+- Multi-channel asynchronous scheduler for first-class async support.
+- And more! Read the [full release post here](https://dioxuslabs.com/).
 
 ## Get Started with...
 
 <table style="width:100%" align="center">
     <tr >
-        <th><a href="https://dioxuslabs.com/book/">Web</a></th>
-        <th><a href="https://dioxuslabs.com/book/">Desktop</a></th>
-        <th><a href="https://dioxuslabs.com/book/">Mobile</a></th>
-        <th><a href="https://dioxuslabs.com/book/">State</a></th>
-        <th><a href="https://dioxuslabs.com/book/">Docs</a></th>
-        <th><a href="https://dioxuslabs.com/book/">Tools</a></th>
+        <th><a href="https://dioxuslabs.com/guide/">Web</a></th>
+        <th><a href="https://dioxuslabs.com/guide/">Desktop</a></th>
+        <th><a href="https://dioxuslabs.com/guide/">Mobile</a></th>
+        <th><a href="https://dioxuslabs.com/guide/">State</a></th>
+        <th><a href="https://dioxuslabs.com/guide/">Docs</a></th>
+        <th><a href="https://dioxuslabs.com/guide/">Tools</a></th>
     <tr>
 </table>
 
@@ -182,7 +176,7 @@ Dioxus is heavily inspired by React, but we want your transition to feel like an
 
 This project is licensed under the [MIT license].
 
-[MIT license]: https://github.com/tokio-rs/tokio/blob/master/LICENSE
+[MIT license]: https://github.com/dioxuslabs/dioxus/blob/master/LICENSE
 
 ### Contribution
 

docs/guide/src/concepts/06-subscription-api.md

@@ -3,7 +3,7 @@
 Yew subscriptions are used to schedule update for components into the future. The `Context` object can create subscriptions:
 
 ```rust
-fn Component(cx: Component<()>) -> DomTree {
+fn Component(cx: Component) -> DomTree {
     let update = cx.schedule();
 
     // Now, when the subscription is called, the component will be re-evaluated

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

@@ -21,9 +21,9 @@ fn test() -> DomTree {
     }
 }
 
-static TestComponent: Component<()> = |cx| html!{<div>"Hello world"</div>};
+static TestComponent: Component = |cx| html!{<div>"Hello world"</div>};
 
-static TestComponent: Component<()> = |cx|{
+static TestComponent: Component = |cx|{
     let g = "BLAH";
     html! {
         <div> "Hello world" </div>

docs/guide/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: Component<()> = |cx|{
+const Provider: Component = |cx|{
     let title = use_signal(&cx, &TITLE);
     rsx!(cx, input { value: title })
 };
@@ -105,7 +105,7 @@ const Provider: Component<()> = |cx|{
 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: Component<()> = |cx|{
+const Receiver: Component = |cx|{
     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: Component<()> = |cx|{
+const List: Component = |cx|{
     let dict = use_signal(&cx, &DICT);
     cx.render(rsx!(
         ul {

docs/guide/src/concepts/conditional_rendering.md

@@ -83,7 +83,7 @@ fn App(cx: Scope)-> Element {
 
 This syntax even enables us to write a one-line component:
 ```rust
-static App: Component<()> = |cx| rsx!(cx, "hello world!");
+static App: Component = |cx| rsx!(cx, "hello world!");
 ```
 
 Alternatively, for match statements, we can just return the builder itself and pass it into a final, single call to `cx.render`:

docs/guide/src/concepts/errorhandling.md

@@ -4,7 +4,7 @@
 Astute observers might have noticed that `Element` is actually a type alias for `Option<VNode>`. You don't need to know what a `VNode` is, but it's important to recognize that we could actually return nothing at all:
 
 ```rust
-fn App((cx, props): Component<()>) -> Element {
+fn App((cx, props): Component) -> Element {
     None
 }
 ```

docs/guide/src/concepts/exporting_components.md

@@ -25,7 +25,7 @@ fn main() {
     dioxus::desktop::launch(App);
 }
 
-fn App((cx, props): Component<()>) -> Element {} 
+fn App((cx, props): Component) -> Element {} 
 
 #[derive(PartialEq, Props)]
 struct PostProps{}
@@ -92,7 +92,7 @@ fn main() {
 
 mod post;
 
-fn App((cx, props): Component<()>) -> Element {
+fn App((cx, props): Component) -> Element {
     cx.render(rsx!{
         post::Post {
             id: Uuid::new_v4(),
@@ -191,7 +191,7 @@ fn main() {
 
 mod post;
 
-fn App((cx, props): Component<()>) -> Element {
+fn App((cx, props): Component) -> Element {
     cx.render(rsx!{
         post::Post {
             id: Uuid::new_v4(),

docs/guide/src/hello_world.md

@@ -135,7 +135,7 @@ fn App(cx: Scope) -> Element {
 Writing `fn App(cx: Scope) -> Element {` might become tedious. Rust will also let you write functions as static closures, but these types of Components cannot have props that borrow data.
 
 ```rust
-static App: Component<()> = |cx| cx.render(rsx!(div { "Hello, world!" }));
+static App: Component = |cx| cx.render(rsx!(div { "Hello, world!" }));
 ```
 
 ### What is this `Context` object?

examples/README.md

@@ -64,18 +64,18 @@ Here's what a few common tasks look like in Dioxus:
 
 Nested components with children and internal state:
 ```rust
-fn App(cx: Context, props: &()) -> Element {
+fn App(cx: Scope<()>) -> Element {
   cx.render(rsx!( Toggle { "Toggle me" } ))
 }
 
 #[derive(PartialEq, Props)]
 struct ToggleProps { children: Element }
 
-fn Toggle(cx: Context, props: &ToggleProps) -> Element {
+fn Toggle(cx: Scope<ToggleProps>) -> Element {
   let mut toggled = use_state(&cx, || false);
   cx.render(rsx!{
     div {
-      {&props.children}
+      {&cx.props.children}
       button { onclick: move |_| toggled.set(true),
         {toggled.and_then(|| "On").or_else(|| "Off")}
       }
@@ -86,7 +86,7 @@ fn Toggle(cx: Context, props: &ToggleProps) -> Element {
 
 Controlled inputs:
 ```rust
-fn App(cx: Context, props: &()) -> Element {
+fn App(cx: Scope<()>) -> Element {
   let value = use_state(&cx, String::new);
   cx.render(rsx!( 
     input {
@@ -100,7 +100,7 @@ fn App(cx: Context, props: &()) -> Element {
 
 Lists and Conditional rendering:
 ```rust
-fn App(cx: Context, props: &()) -> Element {
+fn App(cx: Scope<()>) -> Element {
   let list = (0..10).map(|i| {
     rsx!(li { key: "{i}", "Value: {i}" })
   });
@@ -123,20 +123,20 @@ fn App(cx: Context, props: &()) -> Element {
 
 Tiny components:
 ```rust
-static App: Component<()> = |cx, _| rsx!(cx, div {"hello world!"});
+static App: Component = |cx, _| rsx!(cx, div {"hello world!"});
 ```
 
 Borrowed prop contents:
 ```rust
-fn App(cx: Context, props: &()) -> Element {
+fn App(cx: Scope<()>) -> Element {
   let name = use_state(&cx, || String::from("example"));
   rsx!(cx, Child { title: name.as_str() })
 }
 
 #[derive(Props)]
 struct ChildProps<'a> { title: &'a str }
 
-fn Child(cx: Context, props: &ChildProps) -> Element {
+fn Child(cx: Scope<ChildProps>) -> Element {
   rsx!(cx, "Hello {cx.props.title}")
 }
 ```
@@ -145,12 +145,12 @@ Global State
 ```rust
 struct GlobalState { name: String }
 
-fn App(cx: Context, props: &()) -> Element {
+fn App(cx: Scope<()>) -> Element {
   use_provide_shared_state(cx, || GlobalState { name: String::from("Toby") })
   rsx!(cx, Leaf {})
 }
 
-fn Leaf(cx: Context, props: &()) -> Element {
+fn Leaf(cx: Scope<()>) -> Element {
   let state = use_consume_shared_state::<GlobalState>(cx)?;
   rsx!(cx, "Hello {state.name}")
 }
@@ -166,7 +166,7 @@ enum Route {
   Post(id)
 }
 
-fn App(cx: Context, props: &()) -> Element {
+fn App(cx: Scope<()>) -> Element {
   let route = use_router(cx, Route::parse);
   cx.render(rsx!(div {
     {match route {
@@ -179,7 +179,7 @@ fn App(cx: Context, props: &()) -> Element {
 
 Suspense 
 ```rust
-fn App(cx: Context, props: &()) -> Element {
+fn App(cx: Scope<()>) -> Element {
   let doggo = use_suspense(cx,
     || async { reqwest::get("https://dog.ceo/api/breeds/image/random").await.unwrap().json::<Response>().await.unwrap() },
     |response| cx.render(rsx!( img { src: "{response.message}" }))

examples/async.rs

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