Trait IntoStyle

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

    // Required methods
    fn to_html(self, style: &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);
}

Any type that can be added to the style attribute or set as a style in the CssStyleDeclaration.

This could be a plain string, or a property name-value pair.

Required Associated Types

type AsyncOutput: IntoStyle

The type after all async data have resolved.

type State

The view state retained between building and rebuilding.

type Cloneable: IntoStyle + Clone

An equivalent value that can be cloned.

type CloneableOwned: IntoStyle + Clone + 'static

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

Required Methods

fn to_html(self, style: &mut String)

Renders the style 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 style 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 styling to the state before this style was added.

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 IntoStyle for (Arc<str>, Arc<str>)

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

Reset the renderer to the state before this style was added.

type AsyncOutput = (Arc<str>, Arc<str>)

type State = (CssStyleDeclaration, Arc<str>, Arc<str>)

type Cloneable = (Arc<str>, Arc<str>)

type CloneableOwned = (Arc<str>, Arc<str>)

fn to_html(self, style: &mut String)

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

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

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

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

fn into_cloneable_owned(self) -> <(Arc<str>, Arc<str>) as IntoStyle>::Cloneable

fn dry_resolve(&mut self)

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

impl IntoStyle for String

type AsyncOutput = String

type State = (Element, String)

type Cloneable = Arc<str>

type CloneableOwned = Arc<str>

fn to_html(self, style: &mut String)

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

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

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

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

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

fn dry_resolve(&mut self)

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

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

impl IntoStyle for Arc<str>

type AsyncOutput = Arc<str>

type State = (Element, Arc<str>)

type Cloneable = Arc<str>

type CloneableOwned = Arc<str>

fn to_html(self, style: &mut String)

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

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

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

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

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

fn dry_resolve(&mut self)

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

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

impl<'a> IntoStyle for &'a str

type AsyncOutput = &'a str

type State = (Element, &'a str)

type Cloneable = &'a str

type CloneableOwned = Arc<str>

fn to_html(self, style: &mut String)

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

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

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

fn into_cloneable(self) -> <&'a str as IntoStyle>::Cloneable

fn into_cloneable_owned(self) -> <&'a str as IntoStyle>::CloneableOwned

fn dry_resolve(&mut self)

async fn resolve(self) -> <&'a str as IntoStyle>::AsyncOutput

fn reset(state: &mut <&'a str as IntoStyle>::State)

impl<'a> IntoStyle for (&'a str, &'a str)

fn reset(state: &mut <(&'a str, &'a str) as IntoStyle>::State)

Reset the renderer to the state before this style was added.

type AsyncOutput = (&'a str, &'a str)

type State = (CssStyleDeclaration, &'a str, &'a str)

type Cloneable = (&'a str, &'a str)

type CloneableOwned = (Arc<str>, Arc<str>)

fn to_html(self, style: &mut String)

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

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

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

fn into_cloneable(self) -> <(&'a str, &'a str) as IntoStyle>::Cloneable

fn into_cloneable_owned( self, ) -> <(&'a str, &'a str) as IntoStyle>::CloneableOwned

fn dry_resolve(&mut self)

async fn resolve(self) -> <(&'a str, &'a str) as IntoStyle>::AsyncOutput

impl<'a> IntoStyle for (&'a str, String)

type AsyncOutput = (&'a str, String)

type State = (CssStyleDeclaration, &'a str, String)

type Cloneable = (Arc<str>, Arc<str>)

type CloneableOwned = (Arc<str>, Arc<str>)

fn to_html(self, style: &mut String)

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

fn build(self, el: &Element) -> <(&'a str, String) as IntoStyle>::State

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

fn into_cloneable(self) -> <(&'a str, String) as IntoStyle>::Cloneable

fn into_cloneable_owned( self, ) -> <(&'a str, String) as IntoStyle>::CloneableOwned

fn dry_resolve(&mut self)

async fn resolve(self) -> <(&'a str, String) as IntoStyle>::AsyncOutput

fn reset(state: &mut <(&'a str, String) as IntoStyle>::State)

impl<F, S> IntoStyle for (&'static str, F)

where F: ReactiveFunction<Output = S>, S: Into<Cow<'static, str>> + 'static,

type AsyncOutput = (&'static str, F)

type State = RenderEffectWithCssStyleName<(CssStyleDeclaration, Cow<'static, str>)>

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

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

fn to_html(self, style: &mut String)

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

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

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

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

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

fn dry_resolve(&mut self)

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

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

impl<S> IntoStyle for (&'static str, ArcMemo<S>)

where ArcMemo<S>: Get<Value = S>, S: Into<Cow<'static, str>> + Send + Sync + Clone + 'static,

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

type State = RenderEffectWithCssStyleName<(CssStyleDeclaration, Cow<'static, str>)>

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

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

fn to_html(self, style: &mut String)

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

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

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

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

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

fn dry_resolve(&mut self)

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

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

impl<S> IntoStyle for (&'static str, ArcReadSignal<S>)

where ArcReadSignal<S>: Get<Value = S>, S: Into<Cow<'static, str>> + Send + Sync + Clone + 'static,

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

type State = RenderEffectWithCssStyleName<(CssStyleDeclaration, Cow<'static, str>)>

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

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

fn to_html(self, style: &mut String)

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

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

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

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

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

fn dry_resolve(&mut self)

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

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

impl<S> IntoStyle for (&'static str, ArcRwSignal<S>)

where ArcRwSignal<S>: Get<Value = S>, S: Into<Cow<'static, str>> + Send + Sync + Clone + 'static,

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

type State = RenderEffectWithCssStyleName<(CssStyleDeclaration, Cow<'static, str>)>

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

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

fn to_html(self, style: &mut String)

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

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

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

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

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

fn dry_resolve(&mut self)

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

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

impl<S> IntoStyle for (&'static str, ArcSignal<S>)

where ArcSignal<S>: Get<Value = S>, S: Into<Cow<'static, str>> + Send + Sync + Clone + 'static,

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

type State = RenderEffectWithCssStyleName<(CssStyleDeclaration, Cow<'static, str>)>

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

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

fn to_html(self, style: &mut String)

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

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

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

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

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

fn dry_resolve(&mut self)

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

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

impl<S, St> IntoStyle for (&'static str, MaybeSignal<S, St>)

where MaybeSignal<S, St>: Get<Value = S>, St: Send + Sync + 'static + Storage<S> + Storage<Option<S>>, S: Into<Cow<'static, str>> + Send + Sync + Clone + 'static,

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

type State = RenderEffectWithCssStyleName<(CssStyleDeclaration, Cow<'static, str>)>

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

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

fn to_html(self, style: &mut String)

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

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

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

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

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

fn dry_resolve(&mut self)

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

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

impl<S, St> IntoStyle for (&'static str, Memo<S, St>)

where Memo<S, St>: Get<Value = S>, St: Send + Sync + 'static + Storage<S> + Storage<Option<S>>, S: Into<Cow<'static, str>> + Send + Sync + Clone + 'static,

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

type State = RenderEffectWithCssStyleName<(CssStyleDeclaration, Cow<'static, str>)>

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

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

fn to_html(self, style: &mut String)

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

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

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

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

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

fn dry_resolve(&mut self)

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

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

impl<S, St> IntoStyle for (&'static str, ReadSignal<S, St>)

where ReadSignal<S, St>: Get<Value = S>, St: Send + Sync + 'static + Storage<S> + Storage<Option<S>>, S: Into<Cow<'static, str>> + Send + Sync + Clone + 'static,

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

type State = RenderEffectWithCssStyleName<(CssStyleDeclaration, Cow<'static, str>)>

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

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

fn to_html(self, style: &mut String)

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

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

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

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

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

fn dry_resolve(&mut self)

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

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

impl<S, St> IntoStyle for (&'static str, RwSignal<S, St>)

where RwSignal<S, St>: Get<Value = S>, St: Send + Sync + 'static + Storage<S> + Storage<Option<S>>, S: Into<Cow<'static, str>> + Send + Sync + Clone + 'static,

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

type State = RenderEffectWithCssStyleName<(CssStyleDeclaration, Cow<'static, str>)>

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

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

fn to_html(self, style: &mut String)

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

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

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

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

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

fn dry_resolve(&mut self)

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

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

impl<S, St> IntoStyle for (&'static str, Signal<S, St>)

where Signal<S, St>: Get<Value = S>, St: Send + Sync + 'static + Storage<S> + Storage<Option<S>>, S: Into<Cow<'static, str>> + Send + Sync + Clone + 'static,

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

type State = RenderEffectWithCssStyleName<(CssStyleDeclaration, Cow<'static, str>)>

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

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

fn to_html(self, style: &mut String)

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

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

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

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

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

fn dry_resolve(&mut self)

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

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

impl<T> IntoStyle for Option<T>

where T: IntoStyle,

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

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

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

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

fn to_html(self, style: &mut String)

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

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

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

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

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

fn dry_resolve(&mut self)

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

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

Implementors

impl IntoStyle 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> IntoStyle for ArcMemo<C>

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

type AsyncOutput = ArcMemo<C>

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

type Cloneable = ArcMemo<C>

type CloneableOwned = ArcMemo<C>

impl<C> IntoStyle for ArcReadSignal<C>

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

type AsyncOutput = ArcReadSignal<C>

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

type Cloneable = ArcReadSignal<C>

type CloneableOwned = ArcReadSignal<C>

impl<C> IntoStyle for ArcRwSignal<C>

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

type AsyncOutput = ArcRwSignal<C>

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

type Cloneable = ArcRwSignal<C>

type CloneableOwned = ArcRwSignal<C>

impl<C> IntoStyle for ArcSignal<C>

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

type AsyncOutput = ArcSignal<C>

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

type Cloneable = ArcSignal<C>

type CloneableOwned = ArcSignal<C>

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

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

type AsyncOutput = MaybeSignal<C, S>

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

type Cloneable = MaybeSignal<C, S>

type CloneableOwned = MaybeSignal<C, S>

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

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

type AsyncOutput = Memo<C, S>

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

type Cloneable = Memo<C, S>

type CloneableOwned = Memo<C, S>

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

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

type AsyncOutput = ReadSignal<C, S>

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

type Cloneable = ReadSignal<C, S>

type CloneableOwned = ReadSignal<C, S>

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

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

type AsyncOutput = RwSignal<C, S>

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

type Cloneable = RwSignal<C, S>

type CloneableOwned = RwSignal<C, S>

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

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

type AsyncOutput = Signal<C, S>

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

type Cloneable = Signal<C, S>

type CloneableOwned = Signal<C, S>

impl<F, C> IntoStyle for F

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

type AsyncOutput = <C as IntoStyle>::AsyncOutput

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

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

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