Struct RwSignal 

pub struct RwSignal<T, S = SyncStorage> { /* private fields */ }

An arena-allocated signal that can be read from or written to.

A signal is a piece of data that may change over time, and notifies other code when it has changed. This is the atomic unit of reactivity, which begins all other processes of reactive updates.

This is an arena-allocated signal, which is Copy and is disposed when its reactive Owner cleans up. For a reference-counted signal that lives as long as a reference to it is alive, see ArcRwSignal.

Core Trait Implementations

Reading the Value

• .get() clones the current value of the signal. If you call it within an effect, it will cause that effect to subscribe to the signal, and to re-run whenever the value of the signal changes.
  • .get_untracked() clones the value of the signal without reactively tracking it.
• .read() returns a guard that allows accessing the value of the signal by reference. If you call it within an effect, it will cause that effect to subscribe to the signal, and to re-run whenever the value of the signal changes.
  • .read_untracked() gives access to the current value of the signal without reactively tracking it.
• .with() allows you to reactively access the signal’s value without cloning by applying a callback function.
  • .with_untracked() allows you to access the signal’s value by applying a callback function without reactively tracking it.
• .to_stream() converts the signal to an async stream of values.

Updating the Value

• .set() sets the signal to a new value.
• .update() updates the value of the signal by applying a closure that takes a mutable reference.
• .write() returns a guard through which the signal can be mutated, and which notifies subscribers when it is dropped.

Each of these has a related _untracked() method, which updates the signal without notifying subscribers. Untracked updates are not desirable in most cases, as they cause “tearing” between the signal’s value and its observed value. If you want a non-reactive container, used ArenaItem instead.

Examples

let count = ArcRwSignal::new(0);

// ✅ calling the getter clones and returns the value
//    this can be `count()` on nightly
assert_eq!(count.get(), 0);

// ✅ calling the setter sets the value
//    this can be `set_count(1)` on nightly
count.set(1);
assert_eq!(count.get(), 1);

// ❌ you could call the getter within the setter
// set_count.set(count.get() + 1);

// ✅ however it's more efficient to use .update() and mutate the value in place
count.update(|count: &mut i32| *count += 1);
assert_eq!(count.get(), 2);

// ✅ you can create "derived signals" with a Fn() -> T interface
let double_count = {
  // clone before moving into the closure because we use it below
  let count = count.clone();
  move || count.get() * 2
};
count.set(0);
assert_eq!(double_count(), 0);
count.set(1);
assert_eq!(double_count(), 2);

Implementations

impl<T> RwSignal<T>

where T: Send + Sync + 'static,

pub fn new(value: T) -> RwSignal<T>

Creates a new signal, taking the initial value as its argument.

impl<T, S> RwSignal<T, S>

where T: 'static, S: Storage<ArcRwSignal<T>>,

pub fn new_with_storage(value: T) -> RwSignal<T, S>

Creates a new signal with the given arena storage method.

impl<T> RwSignal<T, LocalStorage>

where T: 'static,

pub fn new_local(value: T) -> RwSignal<T, LocalStorage>

Creates a new signal, taking the initial value as its argument. Unlike RwSignal::new, this pins the value to the current thread. Accessing it from any other thread will panic.

impl<T, S> RwSignal<T, S>

where T: 'static, S: Storage<ArcRwSignal<T>> + Storage<ArcReadSignal<T>>,

pub fn read_only(&self) -> ReadSignal<T, S>

Returns a read-only handle to the signal.

impl<T, S> RwSignal<T, S>

where T: 'static, S: Storage<ArcRwSignal<T>> + Storage<ArcWriteSignal<T>>,

pub fn write_only(&self) -> WriteSignal<T, S>

Returns a write-only handle to the signal.

impl<T, S> RwSignal<T, S>

where T: 'static, S: Storage<ArcRwSignal<T>> + Storage<ArcWriteSignal<T>> + Storage<ArcReadSignal<T>>,

pub fn split(&self) -> (ReadSignal<T, S>, WriteSignal<T, S>)

Splits the signal into its readable and writable halves.

pub fn unite( read: ReadSignal<T, S>, write: WriteSignal<T, S>, ) -> Option<RwSignal<T, S>>

Reunites the two halves of a signal. Returns None if the two signals provided were not created from the same signal.

Trait Implementations

impl<V, S> AddAnyAttr for RwSignal<V, S>

where V: RenderHtml + Clone + Send + Sync + 'static, <V as Render>::State: 'static, RwSignal<V, S>: Get<Value = V>, S: Storage<V> + Storage<Option<V>> + Send + Sync + 'static,

type Output<SomeNewAttr: Attribute> = RwSignal<V, S>

The new type once the attribute has been added.

fn add_any_attr<NewAttr>( self, _attr: NewAttr, ) -> <RwSignal<V, S> as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute,

Adds an attribute to the view.

impl<V, S> AttributeValue for RwSignal<V, S>

where V: AttributeValue + Send + Sync + Clone + 'static, <V as AttributeValue>::State: 'static, RwSignal<V, S>: Get<Value = V>, S: Storage<V> + Storage<Option<V>> + Send + Sync + 'static,

type AsyncOutput = RwSignal<V, S>

The type once all async data have loaded.

type State = RenderEffect<<V as AttributeValue>::State>

The state that should be retained between building and rebuilding.

type Cloneable = RwSignal<V, S>

A version of the value that can be cloned. This can be the same type, or a reference-counted type. Generally speaking, this does not need to refer to the same data, but should behave in the same way. So for example, making an event handler cloneable should probably make it reference-counted (so that a FnMut() continues mutating the same closure), but making a String cloneable does not necessarily need to make it an Arc<str>, as two different clones of a String will still have the same value.

type CloneableOwned = RwSignal<V, S>

A cloneable type that is also 'static. This is used for spreading across types when the spreadable attribute needs to be owned. In some cases (&'a str to Arc<str>, etc.) the owned cloneable type has worse performance than the cloneable type, so they are separate.

fn html_len(&self) -> usize

An approximation of the actual length of this attribute in HTML.

fn to_html(self, key: &str, buf: &mut String)

Renders the attribute value to HTML.

fn to_template(_key: &str, _buf: &mut String)

Renders the attribute value to HTML for a <template>.

fn hydrate<const FROM_SERVER: bool>( self, key: &str, el: &Element, ) -> <RwSignal<V, S> as AttributeValue>::State

Adds interactivity as necessary, given DOM nodes that were created from HTML that has either been rendered on the server, or cloned for a <template>.

fn build( self, el: &Element, key: &str, ) -> <RwSignal<V, S> as AttributeValue>::State

Adds this attribute to the element during client-side rendering.

fn rebuild( self, key: &str, state: &mut <RwSignal<V, S> as AttributeValue>::State, )

Applies a new value for the attribute.

fn into_cloneable(self) -> <RwSignal<V, S> as AttributeValue>::Cloneable

Converts this attribute into an equivalent that can be cloned.

fn into_cloneable_owned( self, ) -> <RwSignal<V, S> as AttributeValue>::CloneableOwned

Converts this attributes into an equivalent that can be cloned and is 'static.

fn dry_resolve(&mut self)

“Runs” the attribute without other side effects. For primitive types, this is a no-op. For reactive types, this can be used to gather data about reactivity or about asynchronous data that needs to be loaded.

async fn resolve(self) -> <RwSignal<V, S> as AttributeValue>::AsyncOutput

“Resolves” this into a form that is not waiting for any asynchronous data.

impl<T, S> Clone for RwSignal<T, S>

fn clone(&self) -> RwSignal<T, S>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T, S> Debug for RwSignal<T, S>

where S: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<T, S> Default for RwSignal<T, S>

where T: Default + 'static, S: Storage<ArcRwSignal<T>>,

fn default() -> RwSignal<T, S>

Returns the “default value” for a type.

impl<T, S> DefinedAt for RwSignal<T, S>

fn defined_at(&self) -> Option<&'static Location<'static>>

Returns the location at which the signal was defined. This is usually simply None in release mode.

impl<'de, T, S> Deserialize<'de> for RwSignal<T, S>

where T: Send + Sync + Deserialize<'de> + 'static, S: Storage<ArcRwSignal<T>>,

fn deserialize<D>( deserializer: D, ) -> Result<RwSignal<T, S>, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T, S> Dispose for RwSignal<T, S>

fn dispose(self)

Disposes of the signal. This:

impl<'a, T> From<&'a ArcRwSignal<T>> for RwSignal<T>

where T: Send + Sync + 'static,

fn from(value: &'a ArcRwSignal<T>) -> RwSignal<T>

Converts to this type from the input type.

impl<T> From<ArcRwSignal<T>> for RwSignal<T>

where T: Send + Sync + 'static,

fn from(value: ArcRwSignal<T>) -> RwSignal<T>

Converts to this type from the input type.

impl<T> From<RwSignal<Option<T>>> for MaybeProp<T>

where T: Send + Sync,

fn from(value: RwSignal<Option<T>>) -> MaybeProp<T>

Converts to this type from the input type.

impl<T> From<RwSignal<Option<T>, LocalStorage>> for MaybeProp<T, LocalStorage>

where T: Send + Sync,

fn from(value: RwSignal<Option<T>, LocalStorage>) -> MaybeProp<T, LocalStorage>

Converts to this type from the input type.

impl<T> From<RwSignal<T>> for MaybeProp<T>

where T: Send + Sync + Clone,

fn from(value: RwSignal<T>) -> MaybeProp<T>

Converts to this type from the input type.

impl<T> From<RwSignal<T>> for MaybeSignal<T>

where T: Send + Sync,

fn from(value: RwSignal<T>) -> MaybeSignal<T>

Converts to this type from the input type.

impl<T> From<RwSignal<T>> for Signal<T>

where T: Send + Sync + 'static,

fn from(value: RwSignal<T>) -> Signal<T>

Converts to this type from the input type.

impl<T> From<RwSignal<T, LocalStorage>> for MaybeProp<T, LocalStorage>

where T: Send + Sync + Clone,

fn from(value: RwSignal<T, LocalStorage>) -> MaybeProp<T, LocalStorage>

Converts to this type from the input type.

impl<T> From<RwSignal<T, LocalStorage>> for MaybeSignal<T, LocalStorage>

fn from(value: RwSignal<T, LocalStorage>) -> MaybeSignal<T, LocalStorage>

Converts to this type from the input type.

impl<T> From<RwSignal<T, LocalStorage>> for Signal<T, LocalStorage>

where T: 'static,

fn from(value: RwSignal<T, LocalStorage>) -> Signal<T, LocalStorage>

Converts to this type from the input type.

impl<T, S> From<RwSignal<T, S>> for ArcRwSignal<T>

where T: 'static, S: Storage<ArcRwSignal<T>>,

fn from(value: RwSignal<T, S>) -> ArcRwSignal<T>

Converts to this type from the input type.

impl<T, S> From<RwSignal<T, S>> for ArcSignal<T, S>

where S: Storage<ArcRwSignal<T>> + Storage<ArcReadSignal<T>> + Storage<T>,

fn from(value: RwSignal<T, S>) -> ArcSignal<T, S>

Converts to this type from the input type.

impl<T, S> From<RwSignal<T, S>> for SignalSetter<T, S>

where T: Send + Sync + 'static, S: Storage<ArcRwSignal<T>> + Storage<ArcWriteSignal<T>>,

fn from(value: RwSignal<T, S>) -> SignalSetter<T, S>

Converts to this type from the input type.

impl<V, S> From<RwSignal<V, S>> for TextProp

where V: Into<Oco<'static, str>> + Clone + Send + Sync + 'static, RwSignal<V, S>: Get<Value = V>, S: Storage<V> + Storage<Option<V>> + Send + Sync + 'static,

fn from(s: RwSignal<V, S>) -> TextProp

Converts to this type from the input type.

impl<T> FromLocal<ArcRwSignal<T>> for RwSignal<T, LocalStorage>

where T: 'static,

fn from_local(value: ArcRwSignal<T>) -> RwSignal<T, LocalStorage>

Converts between the types.

impl<T, S> Hash for RwSignal<T, S>

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<V, S> InnerHtmlValue for RwSignal<V, S>

where V: InnerHtmlValue + Clone + Send + Sync + 'static, <V as InnerHtmlValue>::State: 'static, RwSignal<V, S>: Get<Value = V>, S: Storage<V> + Storage<Option<V>> + Send + Sync + 'static,

type AsyncOutput = RwSignal<V, S>

The type after all async data have resolved.

type State = RenderEffect<<V as InnerHtmlValue>::State>

The view state retained between building and rebuilding.

type Cloneable = RwSignal<V, S>

An equivalent value that can be cloned.

type CloneableOwned = RwSignal<V, S>

An equivalent value that can be cloned and is 'static.

fn html_len(&self) -> usize

The estimated length of the HTML.

fn to_html(self, buf: &mut String)

Renders the class to HTML.

fn to_template(_buf: &mut String)

Renders the class to HTML for a <template>.

fn hydrate<const FROM_SERVER: bool>( self, el: &Element, ) -> <RwSignal<V, S> as InnerHtmlValue>::State

Adds interactivity as necessary, given DOM nodes that were created from HTML that has either been rendered on the server, or cloned for a <template>.

fn build(self, el: &Element) -> <RwSignal<V, S> as InnerHtmlValue>::State

Adds this class to the element during client-side rendering.

fn rebuild(self, state: &mut <RwSignal<V, S> as InnerHtmlValue>::State)

Updates the value.

fn into_cloneable(self) -> <RwSignal<V, S> as InnerHtmlValue>::Cloneable

Converts this to a cloneable type.

fn into_cloneable_owned( self, ) -> <RwSignal<V, S> as InnerHtmlValue>::CloneableOwned

Converts this to a cloneable, owned type.

fn dry_resolve(&mut self)

“Runs” the attribute without other side effects. For primitive types, this is a no-op. For reactive types, this can be used to gather data about reactivity or about asynchronous data that needs to be loaded.

async fn resolve(self) -> <RwSignal<V, S> as InnerHtmlValue>::AsyncOutput

“Resolves” this into a type that is not waiting for any asynchronous data.

impl<V, S> IntoClass for RwSignal<V, S>

where V: IntoClass + Clone + Send + Sync + 'static, <V as IntoClass>::State: 'static, RwSignal<V, S>: Get<Value = V>, S: Storage<V> + Storage<Option<V>> + Send + Sync + 'static,

type AsyncOutput = RwSignal<V, S>

The type after all async data have resolved.

type State = RenderEffect<<V as IntoClass>::State>

The view state retained between building and rebuilding.

type Cloneable = RwSignal<V, S>

An equivalent value that can be cloned.

type CloneableOwned = RwSignal<V, S>

An equivalent value that can be cloned and is 'static.

fn html_len(&self) -> usize

The estimated length of the HTML.

fn to_html(self, class: &mut String)

Renders the class to HTML.

fn hydrate<const FROM_SERVER: bool>( self, el: &Element, ) -> <RwSignal<V, S> as IntoClass>::State

Adds interactivity as necessary, given DOM nodes that were created from HTML that has either been rendered on the server, or cloned for a <template>.

fn build(self, el: &Element) -> <RwSignal<V, S> as IntoClass>::State

Adds this class to the element during client-side rendering.

fn rebuild(self, state: &mut <RwSignal<V, S> as IntoClass>::State)

Updates the value.

fn into_cloneable(self) -> <RwSignal<V, S> as IntoClass>::Cloneable

Converts this to a cloneable type.

fn into_cloneable_owned(self) -> <RwSignal<V, S> as IntoClass>::CloneableOwned

Converts this to a cloneable, owned type.

fn dry_resolve(&mut self)

“Runs” the attribute without other side effects. For primitive types, this is a no-op. For reactive types, this can be used to gather data about reactivity or about asynchronous data that needs to be loaded.

async fn resolve(self) -> <RwSignal<V, S> as IntoClass>::AsyncOutput

“Resolves” this into a type that is not waiting for any asynchronous data.

fn reset(state: &mut <RwSignal<V, S> as IntoClass>::State)

Reset the class list to the state before this class was added.

const TEMPLATE: &'static str = ""

The HTML that should be included in a <template>.

const MIN_LENGTH: usize = _

The minimum length of the HTML.

fn to_template(class: &mut String)

Renders the class to HTML for a <template>.

impl<T, S> IntoInner for RwSignal<T, S>

where S: Storage<ArcRwSignal<T>>,

type Value = T

The type of the value contained in the signal.

fn into_inner(self) -> Option<<RwSignal<T, S> as IntoInner>::Value>

Returns the inner value if this is the only reference to the signal. Otherwise, returns None and drops this reference.

impl<V, S> IntoProperty for RwSignal<V, S>

where V: IntoProperty + Clone + Send + Sync + 'static, <V as IntoProperty>::State: 'static, RwSignal<V, S>: Get<Value = V>, S: Storage<V> + Storage<Option<V>> + Send + Sync + 'static,

type State = RenderEffect<<V as IntoProperty>::State>

The view state retained between building and rebuilding.

type Cloneable = RwSignal<V, S>

An equivalent value that can be cloned.

type CloneableOwned = RwSignal<V, S>

An equivalent value that can be cloned and is 'static.

fn hydrate<const FROM_SERVER: bool>( self, el: &Element, key: &str, ) -> <RwSignal<V, S> as IntoProperty>::State

Adds the property on an element created from HTML.

fn build( self, el: &Element, key: &str, ) -> <RwSignal<V, S> as IntoProperty>::State

Adds the property during client-side rendering.

fn rebuild(self, state: &mut <RwSignal<V, S> as IntoProperty>::State, key: &str)

Updates the property with a new value.

fn into_cloneable(self) -> <RwSignal<V, S> as IntoProperty>::Cloneable

Converts this to a cloneable type.

fn into_cloneable_owned( self, ) -> <RwSignal<V, S> as IntoProperty>::CloneableOwned

Converts this to a cloneable, owned type.

impl<T> IntoSplitSignal for RwSignal<T>

where T: Send + Sync + 'static, ReadSignal<T>: Get<Value = T>,

type Value = T

The actual contained value of the signal

type Read = ReadSignal<T>

The read part of the signal

type Write = WriteSignal<T>

The write part of the signal

fn into_split_signal(self) -> (ReadSignal<T>, WriteSignal<T>)

Splits a combined signal into its read and write parts.

impl<V, S> IntoStyle for RwSignal<V, S>

where V: IntoStyle + Clone + Send + Sync + 'static, <V as IntoStyle>::State: 'static, RwSignal<V, S>: Get<Value = V>, S: Storage<V> + Storage<Option<V>> + Send + Sync + 'static,

type AsyncOutput = RwSignal<V, S>

The type after all async data have resolved.

type State = RenderEffect<<V as IntoStyle>::State>

The view state retained between building and rebuilding.

type Cloneable = RwSignal<V, S>

An equivalent value that can be cloned.

type CloneableOwned = RwSignal<V, S>

An equivalent value that can be cloned and is 'static.

fn to_html(self, style: &mut String)

Renders the style to HTML.

fn hydrate<const FROM_SERVER: bool>( self, el: &Element, ) -> <RwSignal<V, S> as IntoStyle>::State

Adds interactivity as necessary, given DOM nodes that were created from HTML that has either been rendered on the server, or cloned for a <template>.

fn build(self, el: &Element) -> <RwSignal<V, S> as IntoStyle>::State

Adds this style to the element during client-side rendering.

fn rebuild(self, state: &mut <RwSignal<V, S> as IntoStyle>::State)

Updates the value.

fn into_cloneable(self) -> <RwSignal<V, S> as IntoStyle>::Cloneable

Converts this to a cloneable type.

fn into_cloneable_owned(self) -> <RwSignal<V, S> as IntoStyle>::CloneableOwned

Converts this to a cloneable, owned type.

fn dry_resolve(&mut self)

“Runs” the attribute without other side effects. For primitive types, this is a no-op. For reactive types, this can be used to gather data about reactivity or about asynchronous data that needs to be loaded.

async fn resolve(self) -> <RwSignal<V, S> as IntoStyle>::AsyncOutput

“Resolves” this into a type that is not waiting for any asynchronous data.

fn reset(state: &mut <RwSignal<V, S> as IntoStyle>::State)

Reset the styling to the state before this style was added.

impl<V, S> IntoStyleValue for RwSignal<V, S>

where V: IntoStyleValue + Send + Sync + Clone + 'static, RwSignal<V, S>: Get<Value = V>, S: Storage<V> + Storage<Option<V>> + Send + Sync + 'static,

type AsyncOutput = RwSignal<V, S>

The type after all async data have resolved.

type State = (Arc<str>, RenderEffect<<V as IntoStyleValue>::State>)

The view state retained between building and rebuilding.

type Cloneable = RwSignal<V, S>

An equivalent value that can be cloned.

type CloneableOwned = RwSignal<V, S>

An equivalent value that can be cloned and is 'static.

fn to_html(self, name: &str, style: &mut String)

Renders the style to HTML.

fn build( self, style: &CssStyleDeclaration, name: &str, ) -> <RwSignal<V, S> as IntoStyleValue>::State

Adds this style to the element during client-side rendering.

fn rebuild( self, style: &CssStyleDeclaration, name: &str, state: &mut <RwSignal<V, S> as IntoStyleValue>::State, )

Updates the value.

fn hydrate( self, style: &CssStyleDeclaration, name: &str, ) -> <RwSignal<V, S> as IntoStyleValue>::State

Adds interactivity as necessary, given DOM nodes that were created from HTML that has either been rendered on the server, or cloned for a <template>.

fn into_cloneable(self) -> <RwSignal<V, S> as IntoStyleValue>::Cloneable

Converts this to a cloneable type.

fn into_cloneable_owned( self, ) -> <RwSignal<V, S> as IntoStyleValue>::CloneableOwned

Converts this to a cloneable, owned type.

fn dry_resolve(&mut self)

“Runs” the attribute without other side effects. For primitive types, this is a no-op. For reactive types, this can be used to gather data about reactivity or about asynchronous data that needs to be loaded.

async fn resolve(self) -> <RwSignal<V, S> as IntoStyleValue>::AsyncOutput

“Resolves” this into a type that is not waiting for any asynchronous data.

impl<T, S> IsDisposed for RwSignal<T, S>

where T: 'static,

fn is_disposed(&self) -> bool

If true, the signal cannot be accessed without a panic.

impl<T, S> Notify for RwSignal<T, S>

where S: Storage<ArcRwSignal<T>>,

fn notify(&self)

Notifies subscribers of a change in this signal.

impl<T, S> PartialEq for RwSignal<T, S>

fn eq(&self, other: &RwSignal<T, S>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T, S> ReadUntracked for RwSignal<T, S>

where T: 'static, S: Storage<ArcRwSignal<T>>,

type Value = ReadGuard<T, Plain<T>>

The guard type that will be returned, which can be dereferenced to the value.

fn try_read_untracked(&self) -> Option<<RwSignal<T, S> as ReadUntracked>::Value>

Returns the guard, or None if the signal has already been disposed.

fn read_untracked(&self) -> Self::Value

Returns the guard.

fn custom_try_read(&self) -> Option<Option<Self::Value>>

This is a backdoor to allow overriding the Read::try_read implementation despite it being auto implemented.

impl<V, S> Render for RwSignal<V, S>

where V: Render + Clone + Send + Sync + 'static, <V as Render>::State: 'static, RwSignal<V, S>: Get<Value = V>, S: Storage<V> + Storage<Option<V>> + Send + Sync + 'static,

type State = RenderEffectState<<V as Render>::State>

The “view state” for this type, which can be retained between updates.

fn build(self) -> <RwSignal<V, S> as Render>::State

Creates the view for the first time, without hydrating from existing HTML.

fn rebuild(self, state: &mut <RwSignal<V, S> as Render>::State)

Updates the view with new data.

impl<V, S> RenderHtml for RwSignal<V, S>

where V: RenderHtml + Clone + Send + Sync + 'static, <V as Render>::State: 'static, RwSignal<V, S>: Get<Value = V>, S: Storage<V> + Storage<Option<V>> + Send + Sync + 'static,

const MIN_LENGTH: usize = 0

The minimum length of HTML created when this view is rendered.

type AsyncOutput = RwSignal<V, S>

The type of the view after waiting for all asynchronous data to load.

type Owned = RwSignal<V, S>

An equivalent value that is 'static.

fn dry_resolve(&mut self)

“Runs” the view without other side effects. For primitive types, this is a no-op. For reactive types, this can be used to gather data about reactivity or about asynchronous data that needs to be loaded.

async fn resolve(self) -> <RwSignal<V, S> as RenderHtml>::AsyncOutput

Waits for any asynchronous sections of the view to load and returns the output.

fn html_len(&self) -> usize

An estimated length for this view, when rendered to HTML.

fn to_html_with_buf( self, buf: &mut String, position: &mut Position, escape: bool, mark_branches: bool, extra_attrs: Vec<AnyAttribute>, )

Renders a view to HTML, writing it into the given buffer.

fn to_html_async_with_buf<const OUT_OF_ORDER: bool>( self, buf: &mut StreamBuilder, position: &mut Position, escape: bool, mark_branches: bool, extra_attrs: Vec<AnyAttribute>, )

where RwSignal<V, S>: Sized,

Renders a view into a buffer of (synchronous or asynchronous) HTML chunks.

fn hydrate<const FROM_SERVER: bool>( self, cursor: &Cursor, position: &PositionState, ) -> <RwSignal<V, S> as Render>::State

Makes a set of DOM nodes rendered from HTML interactive.

fn into_owned(self) -> <RwSignal<V, S> as RenderHtml>::Owned

Convert into the equivalent value that is 'static.

const EXISTS: bool = true

Whether this should actually exist in the DOM, if it is the child of an element.

fn to_html(self) -> String

where Self: Sized,

Renders a view to an HTML string.

fn to_html_branching(self) -> String

where Self: Sized,

Renders a view to HTML with branch markers. This can be used to support libraries that diff HTML pages against one another, by marking sections of the view that branch to different types with marker comments.

fn to_html_stream_in_order(self) -> StreamBuilder

where Self: Sized,

Renders a view to an in-order stream of HTML.

fn to_html_stream_in_order_branching(self) -> StreamBuilder

where Self: Sized,

Renders a view to an in-order stream of HTML with branch markers. This can be used to support libraries that diff HTML pages against one another, by marking sections of the view that branch to different types with marker comments.

fn to_html_stream_out_of_order(self) -> StreamBuilder

where Self: Sized,

Renders a view to an out-of-order stream of HTML.

fn to_html_stream_out_of_order_branching(self) -> StreamBuilder

where Self: Sized,

Renders a view to an out-of-order stream of HTML with branch markers. This can be used to support libraries that diff HTML pages against one another, by marking sections of the view that branch to different types with marker comments.

fn hydrate_async( self, cursor: &Cursor, position: &PositionState, ) -> impl Future<Output = Self::State>

Asynchronously makes a set of DOM nodes rendered from HTML interactive.

fn hydrate_from<const FROM_SERVER: bool>(self, el: &Element) -> Self::State

where Self: Sized,

Hydrates using RenderHtml::hydrate, beginning at the given element.

fn hydrate_from_position<const FROM_SERVER: bool>( self, el: &Element, position: Position, ) -> Self::State

where Self: Sized,

Hydrates using RenderHtml::hydrate, beginning at the given element and position.

impl<T, St> Serialize for RwSignal<T, St>

where T: Serialize + 'static, St: Storage<ArcRwSignal<T>>,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T, S> Write for RwSignal<T, S>

where T: 'static, S: Storage<ArcRwSignal<T>>,

type Value = T

The type of the signal’s value.

fn try_write(&self) -> Option<impl UntrackableGuard>

Returns the guard, or None if the signal has already been disposed.

fn try_write_untracked( &self, ) -> Option<UntrackedWriteGuard<<RwSignal<T, S> as Write>::Value>>

or None if the signal has already been disposed.

fn write(&self) -> impl UntrackableGuard

Returns the guard.

fn write_untracked(&self) -> impl DerefMut

Returns a guard that will not notify subscribers when dropped.

impl<T, S> Copy for RwSignal<T, S>

impl<T, S> Eq for RwSignal<T, S>