Trait IntoClass

pub trait IntoClass: Send {
    type AsyncOutput: IntoClass;
    type State;
    type Cloneable: IntoClass + Clone;
    type CloneableOwned: IntoClass + Clone + 'static;

    const TEMPLATE: &'static str = "";
    const MIN_LENGTH: usize = _;

    // Required methods
    fn html_len(&self) -> usize;
    fn to_html(self, class: &mut String);
    fn hydrate<const FROM_SERVER: bool>(self, el: &Element) -> Self::State;
    fn build(self, el: &Element) -> Self::State;
    fn rebuild(self, state: &mut Self::State);
    fn into_cloneable(self) -> Self::Cloneable;
    fn into_cloneable_owned(self) -> Self::CloneableOwned;
    fn dry_resolve(&mut self);
    fn resolve(self) -> impl Future<Output = Self::AsyncOutput> + Send;
    fn reset(state: &mut Self::State);

    // Provided method
    fn to_template(class: &mut String) { ... }
}

A possible value for a CSS class.

Provided Associated Constants

const TEMPLATE: &'static str = ""

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

const MIN_LENGTH: usize = _

The minimum length of the HTML.

Required Associated Types

type AsyncOutput: IntoClass

The type after all async data have resolved.

type State

The view state retained between building and rebuilding.

type Cloneable: IntoClass + Clone

An equivalent value that can be cloned.

type CloneableOwned: IntoClass + Clone + 'static

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

Required Methods

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) -> Self::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) -> Self::State

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

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

Updates the value.

fn into_cloneable(self) -> Self::Cloneable

Converts this to a cloneable type.

fn into_cloneable_owned(self) -> Self::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.

fn resolve(self) -> impl Future<Output = Self::AsyncOutput> + Send

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

fn reset(state: &mut Self::State)

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

Provided Methods

fn to_template(class: &mut String)

Renders the class to HTML for a <template>.

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 IntoClass for &str

type AsyncOutput = &str

type State = (Element, &str)

type Cloneable = &str

type CloneableOwned = Arc<str>

fn html_len(&self) -> usize

fn to_html(self, class: &mut String)

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

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

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

fn into_cloneable(self) -> <&str as IntoClass>::Cloneable

fn into_cloneable_owned(self) -> <&str as IntoClass>::CloneableOwned

fn dry_resolve(&mut self)

async fn resolve(self) -> <&str as IntoClass>::AsyncOutput

fn reset(state: &mut <&str as IntoClass>::State)

impl IntoClass for (&'static str, bool)

type AsyncOutput = (&'static str, bool)

type State = (DomTokenList, bool, &'static str)

type Cloneable = (&'static str, bool)

type CloneableOwned = (&'static str, bool)

fn html_len(&self) -> usize

fn to_html(self, class: &mut String)

fn hydrate<const FROM_SERVER: bool>( self, el: &Element, ) -> <(&'static str, bool) as IntoClass>::State

fn build(self, el: &Element) -> <(&'static str, bool) as IntoClass>::State

fn rebuild(self, state: &mut <(&'static str, bool) as IntoClass>::State)

fn into_cloneable(self) -> <(&'static str, bool) as IntoClass>::Cloneable

fn into_cloneable_owned(self) -> <(&'static str, bool) as IntoClass>::Cloneable

fn dry_resolve(&mut self)

async fn resolve(self) -> <(&'static str, bool) as IntoClass>::AsyncOutput

fn reset(state: &mut <(&'static str, bool) as IntoClass>::State)

impl IntoClass for (&'static str, ArcMemo<bool>)

where ArcMemo<bool>: Get<Value = bool>,

type AsyncOutput = (&'static str, ArcMemo<bool>)

type State = RenderEffectWithClassName<(DomTokenList, bool)>

type Cloneable = (&'static str, ArcMemo<bool>)

type CloneableOwned = (&'static str, ArcMemo<bool>)

fn html_len(&self) -> usize

fn to_html(self, class: &mut String)

fn hydrate<const FROM_SERVER: bool>( self, el: &Element, ) -> <(&'static str, ArcMemo<bool>) as IntoClass>::State

fn build( self, el: &Element, ) -> <(&'static str, ArcMemo<bool>) as IntoClass>::State

fn rebuild( self, state: &mut <(&'static str, ArcMemo<bool>) as IntoClass>::State, )

fn into_cloneable( self, ) -> <(&'static str, ArcMemo<bool>) as IntoClass>::Cloneable

fn into_cloneable_owned( self, ) -> <(&'static str, ArcMemo<bool>) as IntoClass>::CloneableOwned

fn dry_resolve(&mut self)

async fn resolve( self, ) -> <(&'static str, ArcMemo<bool>) as IntoClass>::AsyncOutput

fn reset(state: &mut <(&'static str, ArcMemo<bool>) as IntoClass>::State)

impl IntoClass for (&'static str, ArcReadSignal<bool>)

where ArcReadSignal<bool>: Get<Value = bool>,

type AsyncOutput = (&'static str, ArcReadSignal<bool>)

type State = RenderEffectWithClassName<(DomTokenList, bool)>

type Cloneable = (&'static str, ArcReadSignal<bool>)

type CloneableOwned = (&'static str, ArcReadSignal<bool>)

fn html_len(&self) -> usize

fn to_html(self, class: &mut String)

fn hydrate<const FROM_SERVER: bool>( self, el: &Element, ) -> <(&'static str, ArcReadSignal<bool>) as IntoClass>::State

fn build( self, el: &Element, ) -> <(&'static str, ArcReadSignal<bool>) as IntoClass>::State

fn rebuild( self, state: &mut <(&'static str, ArcReadSignal<bool>) as IntoClass>::State, )

fn into_cloneable( self, ) -> <(&'static str, ArcReadSignal<bool>) as IntoClass>::Cloneable

fn into_cloneable_owned( self, ) -> <(&'static str, ArcReadSignal<bool>) as IntoClass>::CloneableOwned

fn dry_resolve(&mut self)

async fn resolve( self, ) -> <(&'static str, ArcReadSignal<bool>) as IntoClass>::AsyncOutput

fn reset(state: &mut <(&'static str, ArcReadSignal<bool>) as IntoClass>::State)

impl IntoClass for (&'static str, ArcRwSignal<bool>)

where ArcRwSignal<bool>: Get<Value = bool>,

type AsyncOutput = (&'static str, ArcRwSignal<bool>)

type State = RenderEffectWithClassName<(DomTokenList, bool)>

type Cloneable = (&'static str, ArcRwSignal<bool>)

type CloneableOwned = (&'static str, ArcRwSignal<bool>)

fn html_len(&self) -> usize

fn to_html(self, class: &mut String)

fn hydrate<const FROM_SERVER: bool>( self, el: &Element, ) -> <(&'static str, ArcRwSignal<bool>) as IntoClass>::State

fn build( self, el: &Element, ) -> <(&'static str, ArcRwSignal<bool>) as IntoClass>::State

fn rebuild( self, state: &mut <(&'static str, ArcRwSignal<bool>) as IntoClass>::State, )

fn into_cloneable( self, ) -> <(&'static str, ArcRwSignal<bool>) as IntoClass>::Cloneable

fn into_cloneable_owned( self, ) -> <(&'static str, ArcRwSignal<bool>) as IntoClass>::CloneableOwned

fn dry_resolve(&mut self)

async fn resolve( self, ) -> <(&'static str, ArcRwSignal<bool>) as IntoClass>::AsyncOutput

fn reset(state: &mut <(&'static str, ArcRwSignal<bool>) as IntoClass>::State)

impl IntoClass for (&'static str, ArcSignal<bool>)

where ArcSignal<bool>: Get<Value = bool>,

type AsyncOutput = (&'static str, ArcSignal<bool>)

type State = RenderEffectWithClassName<(DomTokenList, bool)>

type Cloneable = (&'static str, ArcSignal<bool>)

type CloneableOwned = (&'static str, ArcSignal<bool>)

fn html_len(&self) -> usize

fn to_html(self, class: &mut String)

fn hydrate<const FROM_SERVER: bool>( self, el: &Element, ) -> <(&'static str, ArcSignal<bool>) as IntoClass>::State

fn build( self, el: &Element, ) -> <(&'static str, ArcSignal<bool>) as IntoClass>::State

fn rebuild( self, state: &mut <(&'static str, ArcSignal<bool>) as IntoClass>::State, )

fn into_cloneable( self, ) -> <(&'static str, ArcSignal<bool>) as IntoClass>::Cloneable

fn into_cloneable_owned( self, ) -> <(&'static str, ArcSignal<bool>) as IntoClass>::CloneableOwned

fn dry_resolve(&mut self)

async fn resolve( self, ) -> <(&'static str, ArcSignal<bool>) as IntoClass>::AsyncOutput

fn reset(state: &mut <(&'static str, ArcSignal<bool>) as IntoClass>::State)

impl IntoClass for String

type AsyncOutput = String

type State = (Element, String)

type Cloneable = Arc<str>

type CloneableOwned = Arc<str>

fn html_len(&self) -> usize

fn to_html(self, class: &mut String)

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

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

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

fn into_cloneable(self) -> <String as IntoClass>::Cloneable

fn into_cloneable_owned(self) -> <String as IntoClass>::CloneableOwned

fn dry_resolve(&mut self)

async fn resolve(self) -> <String as IntoClass>::AsyncOutput

fn reset(state: &mut <String as IntoClass>::State)

impl IntoClass for Arc<str>

type AsyncOutput = Arc<str>

type State = (Element, Arc<str>)

type Cloneable = Arc<str>

type CloneableOwned = Arc<str>

fn html_len(&self) -> usize

fn to_html(self, class: &mut String)

fn hydrate<const FROM_SERVER: bool>( self, el: &Element, ) -> <Arc<str> as IntoClass>::State

fn build(self, el: &Element) -> <Arc<str> as IntoClass>::State

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

fn into_cloneable(self) -> <Arc<str> as IntoClass>::Cloneable

fn into_cloneable_owned(self) -> <Arc<str> as IntoClass>::CloneableOwned

fn dry_resolve(&mut self)

async fn resolve(self) -> <Arc<str> as IntoClass>::AsyncOutput

fn reset(state: &mut <Arc<str> as IntoClass>::State)

impl<F, T> IntoClass for (&'static str, F)

where F: ReactiveFunction<Output = T>, T: Borrow<bool> + Send + 'static,

type AsyncOutput = (&'static str, bool)

type State = RenderEffectWithClassName<(DomTokenList, bool)>

type Cloneable = (&'static str, Arc<Mutex<dyn FnMut() -> T + Send>>)

type CloneableOwned = (&'static str, Arc<Mutex<dyn FnMut() -> T + Send>>)

fn html_len(&self) -> usize

fn to_html(self, class: &mut String)

fn hydrate<const FROM_SERVER: bool>( self, el: &Element, ) -> <(&'static str, F) as IntoClass>::State

fn build(self, el: &Element) -> <(&'static str, F) as IntoClass>::State

fn rebuild(self, state: &mut <(&'static str, F) as IntoClass>::State)

fn into_cloneable(self) -> <(&'static str, F) as IntoClass>::Cloneable

fn into_cloneable_owned( self, ) -> <(&'static str, F) as IntoClass>::CloneableOwned

fn dry_resolve(&mut self)

async fn resolve(self) -> <(&'static str, F) as IntoClass>::AsyncOutput

fn reset(state: &mut <(&'static str, F) as IntoClass>::State)

impl<S> IntoClass for (&'static str, MaybeSignal<bool, S>)

where MaybeSignal<bool, S>: Get<Value = bool>, S: Send + 'static + Storage<bool>,

type AsyncOutput = (&'static str, MaybeSignal<bool, S>)

type State = RenderEffectWithClassName<(DomTokenList, bool)>

type Cloneable = (&'static str, MaybeSignal<bool, S>)

type CloneableOwned = (&'static str, MaybeSignal<bool, S>)

fn html_len(&self) -> usize

fn to_html(self, class: &mut String)

fn hydrate<const FROM_SERVER: bool>( self, el: &Element, ) -> <(&'static str, MaybeSignal<bool, S>) as IntoClass>::State

fn build( self, el: &Element, ) -> <(&'static str, MaybeSignal<bool, S>) as IntoClass>::State

fn rebuild( self, state: &mut <(&'static str, MaybeSignal<bool, S>) as IntoClass>::State, )

fn into_cloneable( self, ) -> <(&'static str, MaybeSignal<bool, S>) as IntoClass>::Cloneable

fn into_cloneable_owned( self, ) -> <(&'static str, MaybeSignal<bool, S>) as IntoClass>::CloneableOwned

fn dry_resolve(&mut self)

async fn resolve( self, ) -> <(&'static str, MaybeSignal<bool, S>) as IntoClass>::AsyncOutput

fn reset(state: &mut <(&'static str, MaybeSignal<bool, S>) as IntoClass>::State)

impl<S> IntoClass for (&'static str, Memo<bool, S>)

where Memo<bool, S>: Get<Value = bool>, S: Send + 'static + Storage<bool>,

type AsyncOutput = (&'static str, Memo<bool, S>)

type State = RenderEffectWithClassName<(DomTokenList, bool)>

type Cloneable = (&'static str, Memo<bool, S>)

type CloneableOwned = (&'static str, Memo<bool, S>)

fn html_len(&self) -> usize

fn to_html(self, class: &mut String)

fn hydrate<const FROM_SERVER: bool>( self, el: &Element, ) -> <(&'static str, Memo<bool, S>) as IntoClass>::State

fn build( self, el: &Element, ) -> <(&'static str, Memo<bool, S>) as IntoClass>::State

fn rebuild( self, state: &mut <(&'static str, Memo<bool, S>) as IntoClass>::State, )

fn into_cloneable( self, ) -> <(&'static str, Memo<bool, S>) as IntoClass>::Cloneable

fn into_cloneable_owned( self, ) -> <(&'static str, Memo<bool, S>) as IntoClass>::CloneableOwned

fn dry_resolve(&mut self)

async fn resolve( self, ) -> <(&'static str, Memo<bool, S>) as IntoClass>::AsyncOutput

fn reset(state: &mut <(&'static str, Memo<bool, S>) as IntoClass>::State)

impl<S> IntoClass for (&'static str, ReadSignal<bool, S>)

where ReadSignal<bool, S>: Get<Value = bool>, S: Send + 'static + Storage<bool>,

type AsyncOutput = (&'static str, ReadSignal<bool, S>)

type State = RenderEffectWithClassName<(DomTokenList, bool)>

type Cloneable = (&'static str, ReadSignal<bool, S>)

type CloneableOwned = (&'static str, ReadSignal<bool, S>)

fn html_len(&self) -> usize

fn to_html(self, class: &mut String)

fn hydrate<const FROM_SERVER: bool>( self, el: &Element, ) -> <(&'static str, ReadSignal<bool, S>) as IntoClass>::State

fn build( self, el: &Element, ) -> <(&'static str, ReadSignal<bool, S>) as IntoClass>::State

fn rebuild( self, state: &mut <(&'static str, ReadSignal<bool, S>) as IntoClass>::State, )

fn into_cloneable( self, ) -> <(&'static str, ReadSignal<bool, S>) as IntoClass>::Cloneable

fn into_cloneable_owned( self, ) -> <(&'static str, ReadSignal<bool, S>) as IntoClass>::CloneableOwned

fn dry_resolve(&mut self)

async fn resolve( self, ) -> <(&'static str, ReadSignal<bool, S>) as IntoClass>::AsyncOutput

fn reset(state: &mut <(&'static str, ReadSignal<bool, S>) as IntoClass>::State)

impl<S> IntoClass for (&'static str, RwSignal<bool, S>)

where RwSignal<bool, S>: Get<Value = bool>, S: Send + 'static + Storage<bool>,

type AsyncOutput = (&'static str, RwSignal<bool, S>)

type State = RenderEffectWithClassName<(DomTokenList, bool)>

type Cloneable = (&'static str, RwSignal<bool, S>)

type CloneableOwned = (&'static str, RwSignal<bool, S>)

fn html_len(&self) -> usize

fn to_html(self, class: &mut String)

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

fn build( self, el: &Element, ) -> <(&'static str, RwSignal<bool, S>) as IntoClass>::State

fn rebuild( self, state: &mut <(&'static str, RwSignal<bool, S>) as IntoClass>::State, )

fn into_cloneable( self, ) -> <(&'static str, RwSignal<bool, S>) as IntoClass>::Cloneable

fn into_cloneable_owned( self, ) -> <(&'static str, RwSignal<bool, S>) as IntoClass>::CloneableOwned

fn dry_resolve(&mut self)

async fn resolve( self, ) -> <(&'static str, RwSignal<bool, S>) as IntoClass>::AsyncOutput

fn reset(state: &mut <(&'static str, RwSignal<bool, S>) as IntoClass>::State)

impl<S> IntoClass for (&'static str, Signal<bool, S>)

where Signal<bool, S>: Get<Value = bool>, S: Send + 'static + Storage<bool>,

type AsyncOutput = (&'static str, Signal<bool, S>)

type State = RenderEffectWithClassName<(DomTokenList, bool)>

type Cloneable = (&'static str, Signal<bool, S>)

type CloneableOwned = (&'static str, Signal<bool, S>)

fn html_len(&self) -> usize

fn to_html(self, class: &mut String)

fn hydrate<const FROM_SERVER: bool>( self, el: &Element, ) -> <(&'static str, Signal<bool, S>) as IntoClass>::State

fn build( self, el: &Element, ) -> <(&'static str, Signal<bool, S>) as IntoClass>::State

fn rebuild( self, state: &mut <(&'static str, Signal<bool, S>) as IntoClass>::State, )

fn into_cloneable( self, ) -> <(&'static str, Signal<bool, S>) as IntoClass>::Cloneable

fn into_cloneable_owned( self, ) -> <(&'static str, Signal<bool, S>) as IntoClass>::CloneableOwned

fn dry_resolve(&mut self)

async fn resolve( self, ) -> <(&'static str, Signal<bool, S>) as IntoClass>::AsyncOutput

fn reset(state: &mut <(&'static str, Signal<bool, S>) as IntoClass>::State)

impl<T> IntoClass for Option<T>

where T: IntoClass,

type AsyncOutput = Option<<T as IntoClass>::AsyncOutput>

type State = (Element, Option<<T as IntoClass>::State>)

type Cloneable = Option<<T as IntoClass>::Cloneable>

type CloneableOwned = Option<<T as IntoClass>::CloneableOwned>

fn html_len(&self) -> usize

fn to_html(self, class: &mut String)

fn hydrate<const FROM_SERVER: bool>( self, el: &Element, ) -> <Option<T> as IntoClass>::State

fn build(self, el: &Element) -> <Option<T> as IntoClass>::State

fn rebuild(self, state: &mut <Option<T> as IntoClass>::State)

fn into_cloneable(self) -> <Option<T> as IntoClass>::Cloneable

fn into_cloneable_owned(self) -> <Option<T> as IntoClass>::CloneableOwned

fn dry_resolve(&mut self)

async fn resolve(self) -> <Option<T> as IntoClass>::AsyncOutput

fn reset(state: &mut <Option<T> as IntoClass>::State)

Implementors

impl IntoClass for Oco<'static, str>

type AsyncOutput = Oco<'static, str>

type State = (Element, Oco<'static, str>)

type Cloneable = Oco<'static, str>

type CloneableOwned = Oco<'static, str>

impl<C> IntoClass for ArcMemo<C>

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

type AsyncOutput = ArcMemo<C>

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

type Cloneable = ArcMemo<C>

type CloneableOwned = ArcMemo<C>

impl<C> IntoClass for ArcReadSignal<C>

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

type AsyncOutput = ArcReadSignal<C>

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

type Cloneable = ArcReadSignal<C>

type CloneableOwned = ArcReadSignal<C>

impl<C> IntoClass for ArcRwSignal<C>

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

type AsyncOutput = ArcRwSignal<C>

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

type Cloneable = ArcRwSignal<C>

type CloneableOwned = ArcRwSignal<C>

impl<C> IntoClass for ArcSignal<C>

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

type AsyncOutput = ArcSignal<C>

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

type Cloneable = ArcSignal<C>

type CloneableOwned = ArcSignal<C>

impl<C, S> IntoClass for MaybeSignal<C, S>

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

type AsyncOutput = MaybeSignal<C, S>

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

type Cloneable = MaybeSignal<C, S>

type CloneableOwned = MaybeSignal<C, S>

impl<C, S> IntoClass for Memo<C, S>

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

type AsyncOutput = Memo<C, S>

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

type Cloneable = Memo<C, S>

type CloneableOwned = Memo<C, S>

impl<C, S> IntoClass for ReadSignal<C, S>

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

type AsyncOutput = ReadSignal<C, S>

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

type Cloneable = ReadSignal<C, S>

type CloneableOwned = ReadSignal<C, S>

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

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

type AsyncOutput = RwSignal<C, S>

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

type Cloneable = RwSignal<C, S>

type CloneableOwned = RwSignal<C, S>

impl<C, S> IntoClass for Signal<C, S>

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

type AsyncOutput = Signal<C, S>

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

type Cloneable = Signal<C, S>

type CloneableOwned = Signal<C, S>

impl<F, C> IntoClass for F

where F: ReactiveFunction<Output = C>, C: IntoClass + 'static, <C as IntoClass>::State: 'static,

type AsyncOutput = <C as IntoClass>::AsyncOutput

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

type Cloneable = Arc<Mutex<dyn FnMut() -> C + Send>>

type CloneableOwned = Arc<Mutex<dyn FnMut() -> C + Send>>