Struct Unsuspend 

pub struct Unsuspend<T>(/* private fields */);

A wrapper that prevents Suspense from waiting for any resource reads that happen inside Unsuspend.

Implementations

impl<T> Unsuspend<T>

pub fn new(fun: impl FnOnce() -> T + Send + 'static) -> Unsuspend<T>

Wraps the given function, such that it is not called until all resources are ready.

Trait Implementations

impl<T> AddAnyAttr for Unsuspend<T>

where T: AddAnyAttr + 'static,

type Output<SomeNewAttr: Attribute> = Unsuspend<<T as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::CloneableOwned>>

The new type once the attribute has been added.

fn add_any_attr<NewAttr>( self, attr: NewAttr, ) -> <Unsuspend<T> as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute, <Unsuspend<T> as AddAnyAttr>::Output<NewAttr>: RenderHtml,

Adds an attribute to the view.

impl<T> Render for Unsuspend<T>

where T: Render,

type State = <T as Render>::State

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

fn build(self) -> <Unsuspend<T> as Render>::State

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

fn rebuild(self, state: &mut <Unsuspend<T> as Render>::State)

Updates the view with new data.

impl<T> RenderHtml for Unsuspend<T>

where T: RenderHtml + 'static,

const MIN_LENGTH: usize = T::MIN_LENGTH

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

type AsyncOutput = Unsuspend<T>

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

type Owned = Unsuspend<T>

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) -> <Unsuspend<T> as RenderHtml>::AsyncOutput

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

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 Unsuspend<T>: Sized,

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

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

Makes a set of DOM nodes rendered from HTML interactive.

fn into_owned(self) -> <Unsuspend<T> 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 html_len(&self) -> usize

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

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.