Struct AnyView 

pub struct AnyView { /* private fields */ }

A type-erased view. This can be used if control flow requires that multiple different types of view must be received, and it is either impossible or too cumbersome to use the EitherOf___ enums.

It can also be used to create recursive components, which otherwise cannot return themselves due to the static typing of the view tree.

Generally speaking, using AnyView restricts the amount of information available to the compiler and should be limited to situations in which it is necessary to preserve the maximum amount of type information possible.

Trait Implementations

impl AddAnyAttr for AnyView

type Output<SomeNewAttr: Attribute> = AnyView

The new type once the attribute has been added.

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

where NewAttr: Attribute, <AnyView as AddAnyAttr>::Output<NewAttr>: RenderHtml,

Adds an attribute to the view.

impl From<AnyView> for Fragment

fn from(view: AnyView) -> Fragment

Converts to this type from the input type.

impl From<Fragment> for AnyView

fn from(value: Fragment) -> AnyView

Converts to this type from the input type.

impl FromIterator<AnyView> for Fragment

fn from_iter<T>(iter: T) -> Fragment

where T: IntoIterator<Item = AnyView>,

Creates a value from an iterator.

impl Render for AnyView

type State = AnyViewState

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

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

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

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

Updates the view with new data.

impl RenderHtml for AnyView

const MIN_LENGTH: usize = 0

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

type AsyncOutput = AnyView

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

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) -> <AnyView 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, )

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, )

where AnyView: Sized,

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

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

Makes a set of DOM nodes rendered from HTML interactive.

fn html_len(&self) -> usize

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

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_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.