change: move signal method implementations into traits in signal prelude (leptos-rs#490)

Author: jquesada2016

examples/hackernews_axum/src/error_template.rs

@@ -1,26 +1,30 @@
-use leptos::{view, Errors, For, ForProps, IntoView, RwSignal, Scope, View};
+use leptos::{
+    signal_prelude::*, view, Errors, For, ForProps, IntoView, RwSignal, Scope,
+    View,
+};
 
 // A basic function to display errors served by the error boundaries. Feel free to do more complicated things
 // here than just displaying them
 pub fn error_template(cx: Scope, errors: Option<RwSignal<Errors>>) -> View {
     let Some(errors) = errors else {
         panic!("No Errors found and we expected errors!");
     };
+
     view! {cx,
-    <h1>"Errors"</h1>
-    <For
-        // a function that returns the items we're iterating over; a signal is fine
-        each=errors
-        // a unique key for each item as a reference
-        key=|(key, _)| key.clone()
-        // renders each item to a view
-        view= move |cx, (_, error)| {
-        let error_string = error.to_string();
-          view! {
-            cx,
-            <p>"Error: " {error_string}</p>
+      <h1>"Errors"</h1>
+      <For
+          // a function that returns the items we're iterating over; a signal is fine
+          each=errors
+          // a unique key for each item as a reference
+          key=|(key, _)| key.clone()
+          // renders each item to a view
+          view= move |cx, (_, error)| {
+          let error_string = error.to_string();
+            view! {
+              cx,
+              <p>"Error: " {error_string}</p>
+            }
           }
-        }
       />
     }
     .into_view(cx)

examples/todomvc/src/storage.rs

@@ -1,27 +1,33 @@
 use crate::Todo;
-use leptos::Scope;
-use serde::{Deserialize, Serialize};
+use leptos::{
+  signal_prelude::*,
+  Scope,
+};
+use serde::{
+  Deserialize,
+  Serialize,
+};
 use uuid::Uuid;
 
 #[derive(Serialize, Deserialize)]
 pub struct TodoSerialized {
-    pub id: Uuid,
-    pub title: String,
-    pub completed: bool,
+  pub id: Uuid,
+  pub title: String,
+  pub completed: bool,
 }
 
 impl TodoSerialized {
-    pub fn into_todo(self, cx: Scope) -> Todo {
-        Todo::new_with_completed(cx, self.id, self.title, self.completed)
-    }
+  pub fn into_todo(self, cx: Scope) -> Todo {
+    Todo::new_with_completed(cx, self.id, self.title, self.completed)
+  }
 }
 
 impl From<&Todo> for TodoSerialized {
-    fn from(todo: &Todo) -> Self {
-        Self {
-            id: todo.id,
-            title: todo.title.get(),
-            completed: todo.completed.get(),
-        }
+  fn from(todo: &Todo) -> Self {
+    Self {
+      id: todo.id,
+      title: todo.title.get(),
+      completed: todo.completed.get(),
     }
+  }
 }

integrations/actix/src/lib.rs

@@ -282,8 +282,8 @@ pub fn handle_server_fns_with_context(
 /// The provides a [MetaContext] and a [RouterIntegrationContext] to app’s context before
 /// rendering it, and includes any meta tags injected using [leptos_meta].
 ///
-/// The HTML stream is rendered using [render_to_stream], and includes everything described in
-/// the documentation for that function.
+/// The HTML stream is rendered using [render_to_stream](leptos::ssr::render_to_stream), and
+/// includes everything described in the documentation for that function.
 ///
 /// This can then be set up at an appropriate route in your application:
 /// ```
@@ -602,8 +602,8 @@ where
 /// The provides a [MetaContext] and a [RouterIntegrationContext] to app’s context before
 /// rendering it, and includes any meta tags injected using [leptos_meta].
 ///
-/// The HTML stream is rendered using [render_to_stream], and includes everything described in
-/// the documentation for that function.
+/// The HTML stream is rendered using [render_to_stream](leptos::ssr::render_to_stream), and
+/// includes everything described in the documentation for that function.
 ///
 /// This can then be set up at an appropriate route in your application:
 /// ```

integrations/axum/src/lib.rs

@@ -342,8 +342,8 @@ pub type PinnedHtmlStream =
 /// The provides a [MetaContext] and a [RouterIntegrationContext] to app’s context before
 /// rendering it, and includes any meta tags injected using [leptos_meta].
 ///
-/// The HTML stream is rendered using [render_to_stream], and includes everything described in
-/// the documentation for that function.
+/// The HTML stream is rendered using [render_to_stream](leptos::ssr::render_to_stream), and
+/// includes everything described in the documentation for that function.
 ///
 /// This can then be set up at an appropriate route in your application:
 /// ```

leptos/src/error_boundary.rs

@@ -1,7 +1,9 @@
 use crate::Children;
 use leptos_dom::{Errors, IntoView};
 use leptos_macro::{component, view};
-use leptos_reactive::{create_rw_signal, provide_context, RwSignal, Scope};
+use leptos_reactive::{
+    create_rw_signal, provide_context, signal_prelude::*, RwSignal, Scope,
+};
 
 /// When you render a `Result<_, _>` in your view, in the `Err` case it will
 /// render nothing, and search up through the view tree for an `<ErrorBoundary/>`.

leptos/src/show.rs

@@ -1,6 +1,6 @@
 use leptos::component;
 use leptos_dom::{Fragment, IntoView};
-use leptos_reactive::{create_memo, Scope};
+use leptos_reactive::{create_memo, signal_prelude::*, Scope};
 
 /// A component that will show its children when the `when` condition is `true`,
 /// and show the fallback when it is `false`, without rerendering every time

leptos/src/suspense.rs

@@ -83,6 +83,8 @@ where
                         fallback().into_view(cx)
                     }
                 } else {
+                    use leptos_reactive::signal_prelude::*;
+
                     // run the child; we'll probably throw this away, but it will register resource reads
                     let child = orig_child(cx).into_view(cx);
                     let after_original_child = HydrationCtx::id();

leptos/tests/ssr.rs

@@ -147,7 +147,7 @@ fn ssr_with_styles() {
     use leptos::*;
 
     _ = create_scope(create_runtime(), |cx| {
-        let (value, set_value) = create_signal(cx, 0);
+        let (_, set_value) = create_signal(cx, 0);
         let styles = "myclass";
         let rendered = view! {
             cx, class = styles,
@@ -170,7 +170,7 @@ fn ssr_option() {
     use leptos::*;
 
     _ = create_scope(create_runtime(), |cx| {
-        let (value, set_value) = create_signal(cx, 0);
+        let (_, _) = create_signal(cx, 0);
         let rendered = view! {
             cx,
             <option/>

leptos_dom/src/components/errors.rs

@@ -1,6 +1,6 @@
 use crate::{HydrationCtx, IntoView};
 use cfg_if::cfg_if;
-use leptos_reactive::{use_context, RwSignal};
+use leptos_reactive::{signal_prelude::*, use_context, RwSignal};
 use std::{collections::HashMap, error::Error, sync::Arc};
 
 /// A struct to hold all the possible errors that could be provided by child Views

leptos_dom/src/node_ref.rs

@@ -1,5 +1,7 @@
 use crate::{html::ElementDescriptor, HtmlElement};
-use leptos_reactive::{create_effect, create_rw_signal, RwSignal, Scope};
+use leptos_reactive::{
+    create_effect, create_rw_signal, signal_prelude::*, RwSignal, Scope,
+};
 use std::cell::Cell;
 
 /// Contains a shared reference to a DOM node created while using the `view`

leptos_macro/src/lib.rs

@@ -347,7 +347,7 @@ pub fn view(tokens: TokenStream) -> TokenStream {
 }
 
 /// An optimized, cached template for client-side rendering. Follows the same
-/// syntax as the [view](crate::macro) macro. In hydration or server-side rendering mode,
+/// syntax as the [view!] macro. In hydration or server-side rendering mode,
 /// behaves exactly as the `view` macro. In client-side rendering mode, uses a `<template>`
 /// node to efficiently render the element. Should only be used with a single root element.
 #[proc_macro_error::proc_macro_error]

leptos_reactive/src/lib.rs

@@ -69,6 +69,8 @@
 #[cfg_attr(debug_assertions, macro_use)]
 extern crate tracing;
 
+#[macro_use]
+mod signal;
 mod context;
 mod effect;
 mod hydration;
@@ -78,7 +80,6 @@ mod runtime;
 mod scope;
 mod selector;
 mod serialization;
-mod signal;
 mod signal_wrappers_read;
 mod signal_wrappers_write;
 mod slice;
@@ -96,7 +97,7 @@ pub use runtime::{create_runtime, RuntimeId};
 pub use scope::*;
 pub use selector::*;
 pub use serialization::*;
-pub use signal::*;
+pub use signal::{prelude as signal_prelude, *};
 pub use signal_wrappers_read::*;
 pub use signal_wrappers_write::*;
 pub use slice::*;
@@ -105,43 +106,6 @@ pub use spawn_microtask::*;
 pub use stored_value::*;
 pub use suspense::SuspenseContext;
 
-/// Trait implemented for all signal types which you can `get` a value
-/// from, such as [`ReadSignal`],
-/// [`Memo`], etc., which allows getting the inner value without
-/// subscribing to the current scope.
-pub trait UntrackedGettableSignal<T> {
-    /// Gets the signal's value without creating a dependency on the
-    /// current scope.
-    fn get_untracked(&self) -> T
-    where
-        T: Clone;
-
-    /// Runs the provided closure with a reference to the current
-    /// value without creating a dependency on the current scope.
-    fn with_untracked<O>(&self, f: impl FnOnce(&T) -> O) -> O;
-}
-
-/// Trait implemented for all signal types which you can `set` the inner
-/// value, such as [`WriteSignal`] and [`RwSignal`], which allows setting
-/// the inner value without causing effects which depend on the signal
-/// from being run.
-pub trait UntrackedSettableSignal<T> {
-    /// Sets the signal's value without notifying dependents.
-    fn set_untracked(&self, new_value: T);
-
-    /// Runs the provided closure with a mutable reference to the current
-    /// value without notifying dependents.
-    fn update_untracked(&self, f: impl FnOnce(&mut T));
-
-    /// Runs the provided closure with a mutable reference to the current
-    /// value without notifying dependents and returns
-    /// the value the closure returned.
-    fn update_returning_untracked<U>(
-        &self,
-        f: impl FnOnce(&mut T) -> U,
-    ) -> Option<U>;
-}
-
 mod macros {
     macro_rules! debug_warn {
         ($($x:tt)*) => {