Trait Render

pub trait Render: Sized {
    type State: Mountable;

    // Required methods
    fn build(self) -> Self::State;
    fn rebuild(self, state: &mut Self::State);
}

The Render trait allows rendering something as part of the user interface.

Required Associated Types

type State: Mountable

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

For example, for a text node, State might be the actual DOM text node and the previous string, to allow for diffing between updates.

Required Methods

fn build(self) -> Self::State

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

fn rebuild(self, state: &mut Self::State)

Updates the view with new data.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl Render for bool

type State = BoolState

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

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

impl Render for char

type State = CharState

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

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

impl Render for f32

type State = F32State

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

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

impl Render for f64

type State = F64State

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

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

impl Render for i8

type State = I8State

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

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

impl Render for i16

type State = I16State

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

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

impl Render for i32

type State = I32State

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

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

impl Render for i64

type State = I64State

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

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

impl Render for i128

type State = I128State

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

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

impl Render for isize

type State = IsizeState

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

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

impl Render for u8

type State = U8State

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

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

impl Render for u16

type State = U16State

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

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

impl Render for u32

type State = U32State

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

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

impl Render for u64

type State = U64State

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

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

impl Render for u128

type State = U128State

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

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

impl Render for ()

type State = Comment

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

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

impl Render for usize

type State = UsizeState

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

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

impl Render for Rc<str>

type State = RcStrState

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

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

impl Render for String

type State = StringState

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

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

impl Render for Arc<str>

type State = ArcStrState

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

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

impl<'a> Render for &'a str

type State = StrState<'a>

fn build(self) -> <&'a str as Render>::State

fn rebuild(self, state: &mut <&'a str as Render>::State)

impl<'a> Render for Cow<'a, str>

type State = CowStrState<'a>

fn build(self) -> <Cow<'a, str> as Render>::State

fn rebuild(self, state: &mut <Cow<'a, str> as Render>::State)

impl<A> Render for (A,)

where A: Render,

type State = <A as Render>::State

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

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

impl<A, B> Render for (A, B)

where A: Render, B: Render,

type State = (<A as Render>::State, <B as Render>::State)

fn build(self) -> <(A, B) as Render>::State

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

impl<A, B> Render for Either<A, B>

where A: Render, B: Render,

type State = Either<<A as Render>::State, <B as Render>::State>

fn build(self) -> <Either<A, B> as Render>::State

fn rebuild(self, state: &mut <Either<A, B> as Render>::State)

impl<A, B, C> Render for (A, B, C)

where A: Render, B: Render, C: Render,

type State = (<A as Render>::State, <B as Render>::State, <C as Render>::State)

fn build(self) -> <(A, B, C) as Render>::State

fn rebuild(self, state: &mut <(A, B, C) as Render>::State)

impl<A, B, C> Render for EitherOf3<A, B, C>

where A: Render, B: Render, C: Render,

type State = EitherOf3State<A, B, C>

fn build(self) -> <EitherOf3<A, B, C> as Render>::State

fn rebuild(self, state: &mut <EitherOf3<A, B, C> as Render>::State)

impl<A, B, C, D> Render for (A, B, C, D)

where A: Render, B: Render, C: Render, D: Render,

type State = (<A as Render>::State, <B as Render>::State, <C as Render>::State, <D as Render>::State)

fn build(self) -> <(A, B, C, D) as Render>::State

fn rebuild(self, state: &mut <(A, B, C, D) as Render>::State)

impl<A, B, C, D> Render for EitherOf4<A, B, C, D>

where A: Render, B: Render, C: Render, D: Render,

type State = EitherOf4State<A, B, C, D>

fn build(self) -> <EitherOf4<A, B, C, D> as Render>::State

fn rebuild(self, state: &mut <EitherOf4<A, B, C, D> as Render>::State)

impl<A, B, C, D, E> Render for (A, B, C, D, E)

where A: Render, B: Render, C: Render, D: Render, E: Render,

type State = (<A as Render>::State, <B as Render>::State, <C as Render>::State, <D as Render>::State, <E as Render>::State)

fn build(self) -> <(A, B, C, D, E) as Render>::State

fn rebuild(self, state: &mut <(A, B, C, D, E) as Render>::State)

impl<A, B, C, D, E> Render for EitherOf5<A, B, C, D, E>

where A: Render, B: Render, C: Render, D: Render, E: Render,

type State = EitherOf5State<A, B, C, D, E>

fn build(self) -> <EitherOf5<A, B, C, D, E> as Render>::State

fn rebuild(self, state: &mut <EitherOf5<A, B, C, D, E> as Render>::State)

impl<A, B, C, D, E, F> Render for (A, B, C, D, E, F)

where A: Render, B: Render, C: Render, D: Render, E: Render, F: Render,

type State = (<A as Render>::State, <B as Render>::State, <C as Render>::State, <D as Render>::State, <E as Render>::State, <F as Render>::State)

fn build(self) -> <(A, B, C, D, E, F) as Render>::State

fn rebuild(self, state: &mut <(A, B, C, D, E, F) as Render>::State)

impl<A, B, C, D, E, F> Render for EitherOf6<A, B, C, D, E, F>

where A: Render, B: Render, C: Render, D: Render, E: Render, F: Render,

type State = EitherOf6State<A, B, C, D, E, F>

fn build(self) -> <EitherOf6<A, B, C, D, E, F> as Render>::State

fn rebuild(self, state: &mut <EitherOf6<A, B, C, D, E, F> as Render>::State)

impl<A, B, C, D, E, F, G> Render for (A, B, C, D, E, F, G)

where A: Render, B: Render, C: Render, D: Render, E: Render, F: Render, G: Render,

type State = (<A as Render>::State, <B as Render>::State, <C as Render>::State, <D as Render>::State, <E as Render>::State, <F as Render>::State, <G as Render>::State)

fn build(self) -> <(A, B, C, D, E, F, G) as Render>::State

fn rebuild(self, state: &mut <(A, B, C, D, E, F, G) as Render>::State)

impl<A, B, C, D, E, F, G> Render for EitherOf7<A, B, C, D, E, F, G>

where A: Render, B: Render, C: Render, D: Render, E: Render, F: Render, G: Render,

type State = EitherOf7State<A, B, C, D, E, F, G>

fn build(self) -> <EitherOf7<A, B, C, D, E, F, G> as Render>::State

fn rebuild(self, state: &mut <EitherOf7<A, B, C, D, E, F, G> as Render>::State)

impl<A, B, C, D, E, F, G, H> Render for (A, B, C, D, E, F, G, H)

where A: Render, B: Render, C: Render, D: Render, E: Render, F: Render, G: Render, H: Render,

type State = (<A as Render>::State, <B as Render>::State, <C as Render>::State, <D as Render>::State, <E as Render>::State, <F as Render>::State, <G as Render>::State, <H as Render>::State)

fn build(self) -> <(A, B, C, D, E, F, G, H) as Render>::State

fn rebuild(self, state: &mut <(A, B, C, D, E, F, G, H) as Render>::State)

impl<A, B, C, D, E, F, G, H> Render for EitherOf8<A, B, C, D, E, F, G, H>

where A: Render, B: Render, C: Render, D: Render, E: Render, F: Render, G: Render, H: Render,

type State = EitherOf8State<A, B, C, D, E, F, G, H>

fn build(self) -> <EitherOf8<A, B, C, D, E, F, G, H> as Render>::State

fn rebuild( self, state: &mut <EitherOf8<A, B, C, D, E, F, G, H> as Render>::State, )

impl<A, B, C, D, E, F, G, H, I> Render for (A, B, C, D, E, F, G, H, I)

where A: Render, B: Render, C: Render, D: Render, E: Render, F: Render, G: Render, H: Render, I: Render,

type State = (<A as Render>::State, <B as Render>::State, <C as Render>::State, <D as Render>::State, <E as Render>::State, <F as Render>::State, <G as Render>::State, <H as Render>::State, <I as Render>::State)

fn build(self) -> <(A, B, C, D, E, F, G, H, I) as Render>::State

fn rebuild(self, state: &mut <(A, B, C, D, E, F, G, H, I) as Render>::State)

impl<A, B, C, D, E, F, G, H, I> Render for EitherOf9<A, B, C, D, E, F, G, H, I>

where A: Render, B: Render, C: Render, D: Render, E: Render, F: Render, G: Render, H: Render, I: Render,

type State = EitherOf9State<A, B, C, D, E, F, G, H, I>

fn build(self) -> <EitherOf9<A, B, C, D, E, F, G, H, I> as Render>::State

fn rebuild( self, state: &mut <EitherOf9<A, B, C, D, E, F, G, H, I> as Render>::State, )

impl<A, B, C, D, E, F, G, H, I, J> Render for (A, B, C, D, E, F, G, H, I, J)

where A: Render, B: Render, C: Render, D: Render, E: Render, F: Render, G: Render, H: Render, I: Render, J: Render,

type State = (<A as Render>::State, <B as Render>::State, <C as Render>::State, <D as Render>::State, <E as Render>::State, <F as Render>::State, <G as Render>::State, <H as Render>::State, <I as Render>::State, <J as Render>::State)

fn build(self) -> <(A, B, C, D, E, F, G, H, I, J) as Render>::State

fn rebuild(self, state: &mut <(A, B, C, D, E, F, G, H, I, J) as Render>::State)

impl<A, B, C, D, E, F, G, H, I, J> Render for EitherOf10<A, B, C, D, E, F, G, H, I, J>

where A: Render, B: Render, C: Render, D: Render, E: Render, F: Render, G: Render, H: Render, I: Render, J: Render,

type State = EitherOf10State<A, B, C, D, E, F, G, H, I, J>

fn build(self) -> <EitherOf10<A, B, C, D, E, F, G, H, I, J> as Render>::State

fn rebuild( self, state: &mut <EitherOf10<A, B, C, D, E, F, G, H, I, J> as Render>::State, )

impl<A, B, C, D, E, F, G, H, I, J, K> Render for (A, B, C, D, E, F, G, H, I, J, K)

where A: Render, B: Render, C: Render, D: Render, E: Render, F: Render, G: Render, H: Render, I: Render, J: Render, K: Render,

type State = (<A as Render>::State, <B as Render>::State, <C as Render>::State, <D as Render>::State, <E as Render>::State, <F as Render>::State, <G as Render>::State, <H as Render>::State, <I as Render>::State, <J as Render>::State, <K as Render>::State)

fn build(self) -> <(A, B, C, D, E, F, G, H, I, J, K) as Render>::State

fn rebuild( self, state: &mut <(A, B, C, D, E, F, G, H, I, J, K) as Render>::State, )

impl<A, B, C, D, E, F, G, H, I, J, K> Render for EitherOf11<A, B, C, D, E, F, G, H, I, J, K>

where A: Render, B: Render, C: Render, D: Render, E: Render, F: Render, G: Render, H: Render, I: Render, J: Render, K: Render,

type State = EitherOf11State<A, B, C, D, E, F, G, H, I, J, K>

fn build(self) -> <EitherOf11<A, B, C, D, E, F, G, H, I, J, K> as Render>::State

fn rebuild( self, state: &mut <EitherOf11<A, B, C, D, E, F, G, H, I, J, K> as Render>::State, )

impl<A, B, C, D, E, F, G, H, I, J, K, L> Render for (A, B, C, D, E, F, G, H, I, J, K, L)

where A: Render, B: Render, C: Render, D: Render, E: Render, F: Render, G: Render, H: Render, I: Render, J: Render, K: Render, L: Render,

type State = (<A as Render>::State, <B as Render>::State, <C as Render>::State, <D as Render>::State, <E as Render>::State, <F as Render>::State, <G as Render>::State, <H as Render>::State, <I as Render>::State, <J as Render>::State, <K as Render>::State, <L as Render>::State)

fn build(self) -> <(A, B, C, D, E, F, G, H, I, J, K, L) as Render>::State

fn rebuild( self, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L) as Render>::State, )

impl<A, B, C, D, E, F, G, H, I, J, K, L> Render for EitherOf12<A, B, C, D, E, F, G, H, I, J, K, L>

where A: Render, B: Render, C: Render, D: Render, E: Render, F: Render, G: Render, H: Render, I: Render, J: Render, K: Render, L: Render,

type State = EitherOf12State<A, B, C, D, E, F, G, H, I, J, K, L>

fn build( self, ) -> <EitherOf12<A, B, C, D, E, F, G, H, I, J, K, L> as Render>::State

fn rebuild( self, state: &mut <EitherOf12<A, B, C, D, E, F, G, H, I, J, K, L> as Render>::State, )

impl<A, B, C, D, E, F, G, H, I, J, K, L, M> Render for (A, B, C, D, E, F, G, H, I, J, K, L, M)

where A: Render, B: Render, C: Render, D: Render, E: Render, F: Render, G: Render, H: Render, I: Render, J: Render, K: Render, L: Render, M: Render,

type State = (<A as Render>::State, <B as Render>::State, <C as Render>::State, <D as Render>::State, <E as Render>::State, <F as Render>::State, <G as Render>::State, <H as Render>::State, <I as Render>::State, <J as Render>::State, <K as Render>::State, <L as Render>::State, <M as Render>::State)

fn build(self) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M) as Render>::State

fn rebuild( self, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M) as Render>::State, )

impl<A, B, C, D, E, F, G, H, I, J, K, L, M> Render for EitherOf13<A, B, C, D, E, F, G, H, I, J, K, L, M>

where A: Render, B: Render, C: Render, D: Render, E: Render, F: Render, G: Render, H: Render, I: Render, J: Render, K: Render, L: Render, M: Render,

type State = EitherOf13State<A, B, C, D, E, F, G, H, I, J, K, L, M>

fn build( self, ) -> <EitherOf13<A, B, C, D, E, F, G, H, I, J, K, L, M> as Render>::State

fn rebuild( self, state: &mut <EitherOf13<A, B, C, D, E, F, G, H, I, J, K, L, M> as Render>::State, )

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N> Render for (A, B, C, D, E, F, G, H, I, J, K, L, M, N)

where A: Render, B: Render, C: Render, D: Render, E: Render, F: Render, G: Render, H: Render, I: Render, J: Render, K: Render, L: Render, M: Render, N: Render,

type State = (<A as Render>::State, <B as Render>::State, <C as Render>::State, <D as Render>::State, <E as Render>::State, <F as Render>::State, <G as Render>::State, <H as Render>::State, <I as Render>::State, <J as Render>::State, <K as Render>::State, <L as Render>::State, <M as Render>::State, <N as Render>::State)

fn build(self) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N) as Render>::State

fn rebuild( self, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N) as Render>::State, )

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N> Render for EitherOf14<A, B, C, D, E, F, G, H, I, J, K, L, M, N>

where A: Render, B: Render, C: Render, D: Render, E: Render, F: Render, G: Render, H: Render, I: Render, J: Render, K: Render, L: Render, M: Render, N: Render,

type State = EitherOf14State<A, B, C, D, E, F, G, H, I, J, K, L, M, N>

fn build( self, ) -> <EitherOf14<A, B, C, D, E, F, G, H, I, J, K, L, M, N> as Render>::State

fn rebuild( self, state: &mut <EitherOf14<A, B, C, D, E, F, G, H, I, J, K, L, M, N> as Render>::State, )

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> Render for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)

where A: Render, B: Render, C: Render, D: Render, E: Render, F: Render, G: Render, H: Render, I: Render, J: Render, K: Render, L: Render, M: Render, N: Render, O: Render,

type State = (<A as Render>::State, <B as Render>::State, <C as Render>::State, <D as Render>::State, <E as Render>::State, <F as Render>::State, <G as Render>::State, <H as Render>::State, <I as Render>::State, <J as Render>::State, <K as Render>::State, <L as Render>::State, <M as Render>::State, <N as Render>::State, <O as Render>::State)

fn build( self, ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) as Render>::State

fn rebuild( self, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) as Render>::State, )

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> Render for EitherOf15<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>

where A: Render, B: Render, C: Render, D: Render, E: Render, F: Render, G: Render, H: Render, I: Render, J: Render, K: Render, L: Render, M: Render, N: Render, O: Render,

type State = EitherOf15State<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>

fn build( self, ) -> <EitherOf15<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> as Render>::State

fn rebuild( self, state: &mut <EitherOf15<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> as Render>::State, )

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Render for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)

where A: Render, B: Render, C: Render, D: Render, E: Render, F: Render, G: Render, H: Render, I: Render, J: Render, K: Render, L: Render, M: Render, N: Render, O: Render, P: Render,

type State = (<A as Render>::State, <B as Render>::State, <C as Render>::State, <D as Render>::State, <E as Render>::State, <F as Render>::State, <G as Render>::State, <H as Render>::State, <I as Render>::State, <J as Render>::State, <K as Render>::State, <L as Render>::State, <M as Render>::State, <N as Render>::State, <O as Render>::State, <P as Render>::State)

fn build( self, ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) as Render>::State

fn rebuild( self, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) as Render>::State, )

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Render for EitherOf16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>

where A: Render, B: Render, C: Render, D: Render, E: Render, F: Render, G: Render, H: Render, I: Render, J: Render, K: Render, L: Render, M: Render, N: Render, O: Render, P: Render,

type State = EitherOf16State<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>

fn build( self, ) -> <EitherOf16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> as Render>::State

fn rebuild( self, state: &mut <EitherOf16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> as Render>::State, )

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> Render for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)

where A: Render, B: Render, C: Render, D: Render, E: Render, F: Render, G: Render, H: Render, I: Render, J: Render, K: Render, L: Render, M: Render, N: Render, O: Render, P: Render, Q: Render,

type State = (<A as Render>::State, <B as Render>::State, <C as Render>::State, <D as Render>::State, <E as Render>::State, <F as Render>::State, <G as Render>::State, <H as Render>::State, <I as Render>::State, <J as Render>::State, <K as Render>::State, <L as Render>::State, <M as Render>::State, <N as Render>::State, <O as Render>::State, <P as Render>::State, <Q as Render>::State)

fn build( self, ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) as Render>::State

fn rebuild( self, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) as Render>::State, )

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R> Render for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)

where A: Render, B: Render, C: Render, D: Render, E: Render, F: Render, G: Render, H: Render, I: Render, J: Render, K: Render, L: Render, M: Render, N: Render, O: Render, P: Render, Q: Render, R: Render,

type State = (<A as Render>::State, <B as Render>::State, <C as Render>::State, <D as Render>::State, <E as Render>::State, <F as Render>::State, <G as Render>::State, <H as Render>::State, <I as Render>::State, <J as Render>::State, <K as Render>::State, <L as Render>::State, <M as Render>::State, <N as Render>::State, <O as Render>::State, <P as Render>::State, <Q as Render>::State, <R as Render>::State)

fn build( self, ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) as Render>::State

fn rebuild( self, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) as Render>::State, )

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S> Render for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)

where A: Render, B: Render, C: Render, D: Render, E: Render, F: Render, G: Render, H: Render, I: Render, J: Render, K: Render, L: Render, M: Render, N: Render, O: Render, P: Render, Q: Render, R: Render, S: Render,

type State = (<A as Render>::State, <B as Render>::State, <C as Render>::State, <D as Render>::State, <E as Render>::State, <F as Render>::State, <G as Render>::State, <H as Render>::State, <I as Render>::State, <J as Render>::State, <K as Render>::State, <L as Render>::State, <M as Render>::State, <N as Render>::State, <O as Render>::State, <P as Render>::State, <Q as Render>::State, <R as Render>::State, <S as Render>::State)

fn build( self, ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) as Render>::State

fn rebuild( self, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) as Render>::State, )

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> Render for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

where A: Render, B: Render, C: Render, D: Render, E: Render, F: Render, G: Render, H: Render, I: Render, J: Render, K: Render, L: Render, M: Render, N: Render, O: Render, P: Render, Q: Render, R: Render, S: Render, T: Render,

type State = (<A as Render>::State, <B as Render>::State, <C as Render>::State, <D as Render>::State, <E as Render>::State, <F as Render>::State, <G as Render>::State, <H as Render>::State, <I as Render>::State, <J as Render>::State, <K as Render>::State, <L as Render>::State, <M as Render>::State, <N as Render>::State, <O as Render>::State, <P as Render>::State, <Q as Render>::State, <R as Render>::State, <S as Render>::State, <T as Render>::State)

fn build( self, ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) as Render>::State

fn rebuild( self, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) as Render>::State, )

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U> Render for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)

where A: Render, B: Render, C: Render, D: Render, E: Render, F: Render, G: Render, H: Render, I: Render, J: Render, K: Render, L: Render, M: Render, N: Render, O: Render, P: Render, Q: Render, R: Render, S: Render, T: Render, U: Render,

type State = (<A as Render>::State, <B as Render>::State, <C as Render>::State, <D as Render>::State, <E as Render>::State, <F as Render>::State, <G as Render>::State, <H as Render>::State, <I as Render>::State, <J as Render>::State, <K as Render>::State, <L as Render>::State, <M as Render>::State, <N as Render>::State, <O as Render>::State, <P as Render>::State, <Q as Render>::State, <R as Render>::State, <S as Render>::State, <T as Render>::State, <U as Render>::State)

fn build( self, ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) as Render>::State

fn rebuild( self, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) as Render>::State, )

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V> Render for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)

where A: Render, B: Render, C: Render, D: Render, E: Render, F: Render, G: Render, H: Render, I: Render, J: Render, K: Render, L: Render, M: Render, N: Render, O: Render, P: Render, Q: Render, R: Render, S: Render, T: Render, U: Render, V: Render,

type State = (<A as Render>::State, <B as Render>::State, <C as Render>::State, <D as Render>::State, <E as Render>::State, <F as Render>::State, <G as Render>::State, <H as Render>::State, <I as Render>::State, <J as Render>::State, <K as Render>::State, <L as Render>::State, <M as Render>::State, <N as Render>::State, <O as Render>::State, <P as Render>::State, <Q as Render>::State, <R as Render>::State, <S as Render>::State, <T as Render>::State, <U as Render>::State, <V as Render>::State)

fn build( self, ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) as Render>::State

fn rebuild( self, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) as Render>::State, )

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W> Render for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)

where A: Render, B: Render, C: Render, D: Render, E: Render, F: Render, G: Render, H: Render, I: Render, J: Render, K: Render, L: Render, M: Render, N: Render, O: Render, P: Render, Q: Render, R: Render, S: Render, T: Render, U: Render, V: Render, W: Render,

type State = (<A as Render>::State, <B as Render>::State, <C as Render>::State, <D as Render>::State, <E as Render>::State, <F as Render>::State, <G as Render>::State, <H as Render>::State, <I as Render>::State, <J as Render>::State, <K as Render>::State, <L as Render>::State, <M as Render>::State, <N as Render>::State, <O as Render>::State, <P as Render>::State, <Q as Render>::State, <R as Render>::State, <S as Render>::State, <T as Render>::State, <U as Render>::State, <V as Render>::State, <W as Render>::State)

fn build( self, ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W) as Render>::State

fn rebuild( self, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W) as Render>::State, )

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X> Render for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)

where A: Render, B: Render, C: Render, D: Render, E: Render, F: Render, G: Render, H: Render, I: Render, J: Render, K: Render, L: Render, M: Render, N: Render, O: Render, P: Render, Q: Render, R: Render, S: Render, T: Render, U: Render, V: Render, W: Render, X: Render,

type State = (<A as Render>::State, <B as Render>::State, <C as Render>::State, <D as Render>::State, <E as Render>::State, <F as Render>::State, <G as Render>::State, <H as Render>::State, <I as Render>::State, <J as Render>::State, <K as Render>::State, <L as Render>::State, <M as Render>::State, <N as Render>::State, <O as Render>::State, <P as Render>::State, <Q as Render>::State, <R as Render>::State, <S as Render>::State, <T as Render>::State, <U as Render>::State, <V as Render>::State, <W as Render>::State, <X as Render>::State)

fn build( self, ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X) as Render>::State

fn rebuild( self, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X) as Render>::State, )

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y> Render for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)

where A: Render, B: Render, C: Render, D: Render, E: Render, F: Render, G: Render, H: Render, I: Render, J: Render, K: Render, L: Render, M: Render, N: Render, O: Render, P: Render, Q: Render, R: Render, S: Render, T: Render, U: Render, V: Render, W: Render, X: Render, Y: Render,

type State = (<A as Render>::State, <B as Render>::State, <C as Render>::State, <D as Render>::State, <E as Render>::State, <F as Render>::State, <G as Render>::State, <H as Render>::State, <I as Render>::State, <J as Render>::State, <K as Render>::State, <L as Render>::State, <M as Render>::State, <N as Render>::State, <O as Render>::State, <P as Render>::State, <Q as Render>::State, <R as Render>::State, <S as Render>::State, <T as Render>::State, <U as Render>::State, <V as Render>::State, <W as Render>::State, <X as Render>::State, <Y as Render>::State)

fn build( self, ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y) as Render>::State

fn rebuild( self, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y) as Render>::State, )

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> Render for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)

where A: Render, B: Render, C: Render, D: Render, E: Render, F: Render, G: Render, H: Render, I: Render, J: Render, K: Render, L: Render, M: Render, N: Render, O: Render, P: Render, Q: Render, R: Render, S: Render, T: Render, U: Render, V: Render, W: Render, X: Render, Y: Render, Z: Render,

type State = (<A as Render>::State, <B as Render>::State, <C as Render>::State, <D as Render>::State, <E as Render>::State, <F as Render>::State, <G as Render>::State, <H as Render>::State, <I as Render>::State, <J as Render>::State, <K as Render>::State, <L as Render>::State, <M as Render>::State, <N as Render>::State, <O as Render>::State, <P as Render>::State, <Q as Render>::State, <R as Render>::State, <S as Render>::State, <T as Render>::State, <U as Render>::State, <V as Render>::State, <W as Render>::State, <X as Render>::State, <Y as Render>::State, <Z as Render>::State)

fn build( self, ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) as Render>::State

fn rebuild( self, state: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) as Render>::State, )

impl<Inner, Prev> Render for AtIndex<Inner, Prev>

where <Prev as Index<usize>>::Output: Render + Clone + Send + Sync + 'static, <<Prev as Index<usize>>::Output as Render>::State: 'static, AtIndex<Inner, Prev>: Get<Value = <Prev as Index<usize>>::Output>, Prev: Send + Sync + IndexMut<usize> + 'static, Inner: Send + Sync + Clone + 'static,

type State = RenderEffectState<<<Prev as Index<usize>>::Output as Render>::State>

fn build(self) -> <AtIndex<Inner, Prev> as Render>::State

fn rebuild(self, state: &mut <AtIndex<Inner, Prev> as Render>::State)

impl<Inner, Prev, K, V> Render for AtKeyed<Inner, Prev, K, V>

where V: Render + Clone + Send + Sync + 'static, <V as Render>::State: 'static, AtKeyed<Inner, Prev, K, V>: Get<Value = V>, Prev: Send + Sync + 'static, Inner: Send + Sync + Clone + 'static, K: Send + Sync + Debug + Clone + 'static, &'a V: for<'a> IntoIterator,

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

fn build(self) -> <AtKeyed<Inner, Prev, K, V> as Render>::State

fn rebuild(self, state: &mut <AtKeyed<Inner, Prev, K, V> as Render>::State)

impl<Inner, Prev, K, V> Render for KeyedSubfield<Inner, Prev, K, V>

where V: Render + Clone + Send + Sync + 'static, <V as Render>::State: 'static, KeyedSubfield<Inner, Prev, K, V>: Get<Value = V>, Prev: Send + Sync + 'static, Inner: Send + Sync + Clone + 'static, K: Send + Sync + Debug + Clone + 'static, &'a V: for<'a> IntoIterator,

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

fn build(self) -> <KeyedSubfield<Inner, Prev, K, V> as Render>::State

fn rebuild( self, state: &mut <KeyedSubfield<Inner, Prev, K, V> as Render>::State, )

impl<Inner, Prev, V> Render for Subfield<Inner, Prev, V>

where V: Render + Clone + Send + Sync + 'static, <V as Render>::State: 'static, Subfield<Inner, Prev, V>: Get<Value = V>, Prev: Send + Sync + 'static, Inner: Send + Sync + Clone + 'static,

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

fn build(self) -> <Subfield<Inner, Prev, V> as Render>::State

fn rebuild(self, state: &mut <Subfield<Inner, Prev, V> as Render>::State)

impl<S> Render for DerefedField<S>

where <<S as StoreField>::Value as Deref>::Target: Render + Clone + Send + Sync + 'static, <<<S as StoreField>::Value as Deref>::Target as Render>::State: 'static, S: Clone + StoreField + Send + Sync + 'static, <S as StoreField>::Value: Deref + DerefMut,

type State = RenderEffectState<<<<S as StoreField>::Value as Deref>::Target as Render>::State>

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

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

impl<T> Render for Vec<T>

where T: Render,

type State = VecState<<T as Render>::State>

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

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

impl<T, const N: usize> Render for [T; N]

where T: Render,

type State = ArrayState<<T as Render>::State, N>

fn build(self) -> <[T; N] as Render>::State

fn rebuild(self, state: &mut <[T; N] as Render>::State)

impl<V> Render for ArcField<V>

where V: Render + Clone + Send + Sync + 'static, <V as Render>::State: 'static, ArcField<V>: Get<Value = V>,

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

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

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

impl<V> Render for ArcStore<V>

where V: Render + Clone + Send + Sync + 'static, <V as Render>::State: 'static, ArcStore<V>: Get<Value = V>,

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

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

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

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

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

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

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

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

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

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

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

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

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

Implementors

impl Render for Oco<'static, str>

type State = OcoStrState

impl Render for IpAddr

type State = IpAddrState

impl Render for SocketAddr

type State = SocketAddrState

impl Render for Ipv4Addr

type State = Ipv4AddrState

impl Render for Ipv6Addr

type State = Ipv6AddrState

impl Render for SocketAddrV4

type State = SocketAddrV4State

impl Render for SocketAddrV6

type State = SocketAddrV6State

impl Render for NonZero<i8>

type State = NonZeroI8State

impl Render for NonZero<i16>

type State = NonZeroI16State

impl Render for NonZero<i32>

type State = NonZeroI32State

impl Render for NonZero<i64>

type State = NonZeroI64State

impl Render for NonZero<i128>

type State = NonZeroI128State

impl Render for NonZero<isize>

type State = NonZeroIsizeState

impl Render for NonZero<u8>

type State = NonZeroU8State

impl Render for NonZero<u16>

type State = NonZeroU16State

impl Render for NonZero<u32>

type State = NonZeroU32State

impl Render for NonZero<u64>

type State = NonZeroU64State

impl Render for NonZero<u128>

type State = NonZeroU128State

impl Render for NonZero<usize>

type State = NonZeroUsizeState

impl Render for AnyView

type State = AnyViewState

impl Render for AnyViewWithAttrs

type State = AnyViewWithAttrsState

impl Render for Doctype

type State = ()

impl Render for InertElement

type State = InertElementState

impl Render for InertElement

type State = InertElementState

impl<A, B> Render for EitherKeepAlive<A, B>

where A: Render, B: Render,

type State = EitherKeepAliveState<<A as Render>::State, <B as Render>::State>

impl<E, At, Ch> Render for HtmlElement<E, At, Ch>

where E: ElementType, At: Attribute, Ch: Render,

type State = ElementState<<At as Attribute>::State, <Ch as Render>::State>

impl<F, V> Render for F

where F: ReactiveFunction<Output = V>, V: Render, <V as Render>::State: 'static,

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

impl<T> Render for Option<T>

where T: Render,

type State = Either<<T as Render>::State, <() as Render>::State>

impl<T> Render for Suspend<T>

where T: Render + 'static,

type State = SuspendState<T>

impl<T> Render for Unsuspend<T>

where T: Render,

type State = <T as Render>::State

impl<T> Render for View<T>

where T: Render,

type State = <T as Render>::State

impl<T> Render for OwnedView<T>

where T: Render,

type State = OwnedViewState<<T as Render>::State>

impl<T> Render for StaticVec<T>

where T: Render,

type State = StaticVecState<<T as Render>::State>

impl<T, E> Render for Result<T, E>

where T: Render, E: Into<Error> + 'static,

type State = ResultState<T>

impl<T, I, K, KF, VF, VFS, V> Render for Keyed<T, I, K, KF, VF, VFS, V>

where I: IntoIterator<Item = T>, K: Eq + Hash + SerializableKey + 'static, KF: Fn(&T) -> K, V: Render, VF: Fn(usize, T) -> (VFS, V), VFS: Fn(usize),

type State = KeyedState<K, VFS, V>

impl<T, Ser> Render for Resource<T, Ser>

where T: Render + Send + Sync + Clone, Ser: Send + 'static,

type State = RenderEffectState<SuspendState<T>>

impl<V> Render for ViewTemplate<V>

where V: Render + RenderHtml + ToTemplate + 'static, <V as Render>::State: Mountable,

type State = <V as Render>::State

impl<View> Render for Island<View>

where View: Render,

type State = <View as Render>::State

impl<View> Render for IslandChildren<View>

where View: Render,

type State = ()

impl<const V: &'static str> Render for Static<V>

where Text: Mountable,

type State = Option<Text>