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 IpAddr

type State = IpAddrState

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

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

impl Render for SocketAddr

type State = SocketAddrState

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

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

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 Render for Ipv4Addr

type State = Ipv4AddrState

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

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

impl Render for Ipv6Addr

type State = Ipv6AddrState

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

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

impl Render for SocketAddrV4

type State = SocketAddrV4State

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

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

impl Render for SocketAddrV6

type State = SocketAddrV6State

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

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

impl Render for NonZero<i8>

type State = NonZeroI8State

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

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

impl Render for NonZero<i16>

type State = NonZeroI16State

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

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

impl Render for NonZero<i32>

type State = NonZeroI32State

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

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

impl Render for NonZero<i64>

type State = NonZeroI64State

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

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

impl Render for NonZero<i128>

type State = NonZeroI128State

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

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

impl Render for NonZero<isize>

type State = NonZeroIsizeState

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

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

impl Render for NonZero<u8>

type State = NonZeroU8State

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

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

impl Render for NonZero<u16>

type State = NonZeroU16State

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

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

impl Render for NonZero<u32>

type State = NonZeroU32State

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

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

impl Render for NonZero<u64>

type State = NonZeroU64State

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

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

impl Render for NonZero<u128>

type State = NonZeroU128State

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

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

impl Render for NonZero<usize>

type State = NonZeroUsizeState

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

fn rebuild(self, state: &mut <NonZero<usize> 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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<T> Render for Option<T>

where T: Render,

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

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

fn rebuild(self, state: &mut <Option<T> 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, E> Render for Result<T, E>

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

type State = ResultState<T>

fn build(self) -> <Result<T, E> as Render>::State

fn rebuild(self, state: &mut <Result<T, E> 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)

Implementors

impl Render for Oco<'static, str>

type State = OcoStrState

impl Render for Doctype

type State = ()

impl Render for InertElement

type State = Element

impl Render for AnyView

type State = AnyViewState

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

where A: Render, B: Render,

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

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<A, B, C> Render for EitherOf3<A, B, C>

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

type State = EitherOf3State<A, B, C>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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 Unsuspend<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 Suspend<T>

where T: Render + 'static,

type State = SuspendState<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 + '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<T: Render> Render for View<T>

type State = <T as Render>::State

impl<V> Render for ArcMemo<V>

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

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

impl<V> Render for ArcReadSignal<V>

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

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

impl<V> Render for ArcRwSignal<V>

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

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

impl<V> Render for ArcSignal<V>

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

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

impl<V> Render for ViewTemplate<V>

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

type State = <V as Render>::State

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type State = RenderEffectState<<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 = ()