Skip to main content

MaybeSignal

flams_router_vscode::components

Enum MaybeSignal 

pub enum MaybeSignal<T, S = SyncStorage>
where
    T: 'static,
    S: Storage<T>,
{
    Static(T),
    Dynamic(Signal<T, S>),
}
👎Deprecated since 0.7.0-rc3:

MaybeSignal<T> is deprecated in favour of Signal<T> which is Copy, now has a more efficient From<T> implementation and other benefits in 0.7.

Expand description

A wrapper for a value that is either T or Signal<T>.

This allows you to create APIs that take either a reactive or a non-reactive value of the same type. This is especially useful for component properties.

let (count, set_count) = signal(2);
let double_count = MaybeSignal::derive(move || count.get() * 2);
let memoized_double_count = Memo::new(move |_| count.get() * 2);
let static_value = 5;

// this function takes either a reactive or non-reactive value
fn above_3(arg: &MaybeSignal<i32>) -> bool {
    // ✅ calling the signal clones and returns the value
    //    it is a shorthand for arg.get()
    arg.get() > 3
}

assert_eq!(above_3(&static_value.into()), true);
assert_eq!(above_3(&count.into()), false);
assert_eq!(above_3(&double_count), true);
assert_eq!(above_3(&memoized_double_count.into()), true);

Variants§

§

Static(T)

👎Deprecated since 0.7.0-rc3:

MaybeSignal<T> is deprecated in favour of Signal<T> which is Copy, now has a more efficient From<T> implementation and other benefits in 0.7.

An unchanging value of type T.

§

Dynamic(Signal<T, S>)

👎Deprecated since 0.7.0-rc3:

MaybeSignal<T> is deprecated in favour of Signal<T> which is Copy, now has a more efficient From<T> implementation and other benefits in 0.7.

A reactive signal that contains a value of type T.

Implementations§

§

impl<T> MaybeSignal<T>
where T: Send + Sync,

pub fn derive( derived_signal: impl Fn() -> T + Send + Sync + 'static, ) -> MaybeSignal<T>

Wraps a derived signal, i.e., any computation that accesses one or more reactive signals.

§

impl<T> MaybeSignal<T, LocalStorage>

pub fn derive_local( derived_signal: impl Fn() -> T + 'static, ) -> MaybeSignal<T, LocalStorage>

Wraps a derived signal, i.e., any computation that accesses one or more reactive signals.

Trait Implementations§

§

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

§

type Output<SomeNewAttr: Attribute> = MaybeSignal<V, S>

The new type once the attribute has been added.
§

fn add_any_attr<NewAttr>( self, _attr: NewAttr, ) -> <MaybeSignal<V, S> as AddAnyAttr>::Output<NewAttr>
where NewAttr: Attribute,

Adds an attribute to the view.
§

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

§

type AsyncOutput = MaybeSignal<V, S>

The type once all async data have loaded.
§

type State = RenderEffect<<V as AttributeValue>::State>

The state that should be retained between building and rebuilding.
§

type Cloneable = MaybeSignal<V, S>

A version of the value that can be cloned. This can be the same type, or a reference-counted type. Generally speaking, this does not need to refer to the same data, but should behave in the same way. So for example, making an event handler cloneable should probably make it reference-counted (so that a FnMut() continues mutating the same closure), but making a String cloneable does not necessarily need to make it an Arc<str>, as two different clones of a String will still have the same value.
§

type CloneableOwned = MaybeSignal<V, S>

A cloneable type that is also 'static. This is used for spreading across types when the spreadable attribute needs to be owned. In some cases (&'a str to Arc<str>, etc.) the owned cloneable type has worse performance than the cloneable type, so they are separate.
§

fn html_len(&self) -> usize

An approximation of the actual length of this attribute in HTML.
§

fn to_html(self, key: &str, buf: &mut String)

Renders the attribute value to HTML.
§

fn to_template(_key: &str, _buf: &mut String)

Renders the attribute value to HTML for a <template>.
§

fn hydrate<const FROM_SERVER: bool>( self, key: &str, el: &Element, ) -> <MaybeSignal<V, S> as AttributeValue>::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, key: &str, ) -> <MaybeSignal<V, S> as AttributeValue>::State

Adds this attribute to the element during client-side rendering.
§

fn rebuild( self, key: &str, state: &mut <MaybeSignal<V, S> as AttributeValue>::State, )

Applies a new value for the attribute.
§

fn into_cloneable(self) -> <MaybeSignal<V, S> as AttributeValue>::Cloneable

Converts this attribute into an equivalent that can be cloned.
§

fn into_cloneable_owned( self, ) -> <MaybeSignal<V, S> as AttributeValue>::CloneableOwned

Converts this attributes into an equivalent that can be cloned and is 'static.
§

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

async fn resolve(self) -> <MaybeSignal<V, S> as AttributeValue>::AsyncOutput

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

impl<T, S> Clone for MaybeSignal<T, S>
where T: Clone, S: Storage<T>,

§

fn clone(&self) -> MaybeSignal<T, S>

Returns a duplicate of the value. Read more
1.0.0 (const: unstable) · Source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
§

impl<T, S> Debug for MaybeSignal<T, S>
where T: Debug + 'static, S: Debug + Storage<T>,

§

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter. Read more
§

impl<T, S> Default for MaybeSignal<T, S>
where T: Default, S: Storage<T>,

§

fn default() -> MaybeSignal<T, S>

Returns the “default value” for a type. Read more
§

impl<T, S> DefinedAt for MaybeSignal<T, S>
where S: Storage<T>,

§

fn defined_at(&self) -> Option<&'static Location<'static>>

Returns the location at which the signal was defined. This is usually simply None in release mode.
§

impl<'de, T, St> Deserialize<'de> for MaybeSignal<T, St>
where T: Deserialize<'de>, St: Storage<T>,

§

fn deserialize<D>( deserializer: D, ) -> Result<MaybeSignal<T, St>, <D as Deserializer<'de>>::Error>
where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
§

impl<S> From<&str> for MaybeSignal<String, S>
where S: Storage<String> + Storage<Arc<RwLock<String>>>,

§

fn from(value: &str) -> MaybeSignal<String, S>

Converts to this type from the input type.
§

impl<T> From<ArcMemo<T>> for MaybeSignal<T>
where T: Send + Sync,

§

fn from(value: ArcMemo<T>) -> MaybeSignal<T>

Converts to this type from the input type.
§

impl<T> From<ArcReadSignal<T>> for MaybeSignal<T>
where T: Send + Sync,

§

fn from(value: ArcReadSignal<T>) -> MaybeSignal<T>

Converts to this type from the input type.
§

impl<T> From<ArcRwSignal<T>> for MaybeSignal<T>
where T: Send + Sync + 'static,

§

fn from(value: ArcRwSignal<T>) -> MaybeSignal<T>

Converts to this type from the input type.
§

impl<T> From<MaybeSignal<Option<T>>> for MaybeProp<T>
where T: Send + Sync, SyncStorage: Storage<Option<T>>,

§

fn from(value: MaybeSignal<Option<T>>) -> MaybeProp<T>

Converts to this type from the input type.
§

impl<T> From<MaybeSignal<Option<T>, LocalStorage>> for MaybeProp<T, LocalStorage>
where T: Send + Sync,

§

fn from( value: MaybeSignal<Option<T>, LocalStorage>, ) -> MaybeProp<T, LocalStorage>

Converts to this type from the input type.
§

impl<T> From<MaybeSignal<T>> for Signal<Option<T>>
where T: Clone + Send + Sync + 'static,

§

fn from(value: MaybeSignal<T>) -> Signal<Option<T>>

Converts to this type from the input type.
§

impl<T> From<MaybeSignal<T>> for Signal<T>
where T: Send + Sync + 'static,

§

fn from(value: MaybeSignal<T>) -> Signal<T>

Converts to this type from the input type.
§

impl<T> From<MaybeSignal<T, LocalStorage>> for Signal<Option<T>, LocalStorage>
where T: Clone + Send + Sync + 'static,

§

fn from(value: MaybeSignal<T, LocalStorage>) -> Signal<Option<T>, LocalStorage>

Converts to this type from the input type.
§

impl<T> From<MaybeSignal<T, LocalStorage>> for Signal<T, LocalStorage>
where T: Send + Sync + 'static,

§

fn from(value: MaybeSignal<T, LocalStorage>) -> Signal<T, LocalStorage>

Converts to this type from the input type.
§

impl<V, S> From<MaybeSignal<V, S>> for TextProp
where V: Into<Oco<'static, str>> + Clone + Send + Sync + 'static, MaybeSignal<V, S>: Get<Value = V>, S: Storage<V> + Storage<Option<V>> + Send + Sync + 'static,

§

fn from(s: MaybeSignal<V, S>) -> TextProp

Converts to this type from the input type.
§

impl<T> From<Memo<T>> for MaybeSignal<T>
where T: Send + Sync,

§

fn from(value: Memo<T>) -> MaybeSignal<T>

Converts to this type from the input type.
§

impl<T> From<Memo<T, LocalStorage>> for MaybeSignal<T, LocalStorage>

§

fn from(value: Memo<T, LocalStorage>) -> MaybeSignal<T, LocalStorage>

Converts to this type from the input type.
§

impl<T> From<ReadSignal<T>> for MaybeSignal<T>
where T: Send + Sync,

§

fn from(value: ReadSignal<T>) -> MaybeSignal<T>

Converts to this type from the input type.
§

impl<T> From<ReadSignal<T, LocalStorage>> for MaybeSignal<T, LocalStorage>

§

fn from(value: ReadSignal<T, LocalStorage>) -> MaybeSignal<T, LocalStorage>

Converts to this type from the input type.
§

impl<T> From<RwSignal<T>> for MaybeSignal<T>
where T: Send + Sync,

§

fn from(value: RwSignal<T>) -> MaybeSignal<T>

Converts to this type from the input type.
§

impl<T> From<RwSignal<T, LocalStorage>> for MaybeSignal<T, LocalStorage>

§

fn from(value: RwSignal<T, LocalStorage>) -> MaybeSignal<T, LocalStorage>

Converts to this type from the input type.
§

impl<T, S> From<Signal<T, S>> for MaybeSignal<T, S>
where S: Storage<T>,

§

fn from(value: Signal<T, S>) -> MaybeSignal<T, S>

Converts to this type from the input type.
§

impl<T> From<T> for MaybeSignal<T>
where SyncStorage: Storage<T>,

§

fn from(value: T) -> MaybeSignal<T>

Converts to this type from the input type.
§

impl<T> FromLocal<ArcMemo<T, LocalStorage>> for MaybeSignal<T, LocalStorage>

§

fn from_local(value: ArcMemo<T, LocalStorage>) -> MaybeSignal<T, LocalStorage>

Converts between the types.
§

impl<T> FromLocal<ArcReadSignal<T>> for MaybeSignal<T, LocalStorage>

§

fn from_local(value: ArcReadSignal<T>) -> MaybeSignal<T, LocalStorage>

Converts between the types.
§

impl<T> FromLocal<ArcRwSignal<T>> for MaybeSignal<T, LocalStorage>
where T: 'static,

§

fn from_local(value: ArcRwSignal<T>) -> MaybeSignal<T, LocalStorage>

Converts between the types.
§

impl<T> FromLocal<T> for MaybeSignal<T, LocalStorage>
where LocalStorage: Storage<T>,

§

fn from_local(value: T) -> MaybeSignal<T, LocalStorage>

Converts between the types.
§

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

§

type AsyncOutput = MaybeSignal<V, S>

The type after all async data have resolved.
§

type State = RenderEffect<<V as InnerHtmlValue>::State>

The view state retained between building and rebuilding.
§

type Cloneable = MaybeSignal<V, S>

An equivalent value that can be cloned.
§

type CloneableOwned = MaybeSignal<V, S>

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

fn html_len(&self) -> usize

The estimated length of the HTML.
§

fn to_html(self, buf: &mut String)

Renders the class to HTML.
§

fn to_template(_buf: &mut String)

Renders the class to HTML for a <template>.
§

fn hydrate<const FROM_SERVER: bool>( self, el: &Element, ) -> <MaybeSignal<V, S> as InnerHtmlValue>::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) -> <MaybeSignal<V, S> as InnerHtmlValue>::State

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

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

Updates the value.
§

fn into_cloneable(self) -> <MaybeSignal<V, S> as InnerHtmlValue>::Cloneable

Converts this to a cloneable type.
§

fn into_cloneable_owned( self, ) -> <MaybeSignal<V, S> as InnerHtmlValue>::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.
§

async fn resolve(self) -> <MaybeSignal<V, S> as InnerHtmlValue>::AsyncOutput

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

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

§

type AsyncOutput = MaybeSignal<V, S>

The type after all async data have resolved.
§

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

The view state retained between building and rebuilding.
§

type Cloneable = MaybeSignal<V, S>

An equivalent value that can be cloned.
§

type CloneableOwned = MaybeSignal<V, S>

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

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, ) -> <MaybeSignal<V, S> as IntoClass>::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) -> <MaybeSignal<V, S> as IntoClass>::State

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

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

Updates the value.
§

fn into_cloneable(self) -> <MaybeSignal<V, S> as IntoClass>::Cloneable

Converts this to a cloneable type.
§

fn into_cloneable_owned( self, ) -> <MaybeSignal<V, S> as IntoClass>::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.
§

async fn resolve(self) -> <MaybeSignal<V, S> as IntoClass>::AsyncOutput

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

fn reset(state: &mut <MaybeSignal<V, S> as IntoClass>::State)

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

const TEMPLATE: &'static str = ""

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

const MIN_LENGTH: usize = _

The minimum length of the HTML.
§

fn should_overwrite(&self) -> bool

Whether this class attribute should overwrite previous class values. Returns true for class="..." attributes, false for class:name=value directives.
§

fn to_template(class: &mut String)

Renders the class to HTML for a <template>.
§

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

§

type State = RenderEffect<<V as IntoProperty>::State>

The view state retained between building and rebuilding.
§

type Cloneable = MaybeSignal<V, S>

An equivalent value that can be cloned.
§

type CloneableOwned = MaybeSignal<V, S>

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

fn hydrate<const FROM_SERVER: bool>( self, el: &Element, key: &str, ) -> <MaybeSignal<V, S> as IntoProperty>::State

Adds the property on an element created from HTML.
§

fn build( self, el: &Element, key: &str, ) -> <MaybeSignal<V, S> as IntoProperty>::State

Adds the property during client-side rendering.
§

fn rebuild( self, state: &mut <MaybeSignal<V, S> as IntoProperty>::State, key: &str, )

Updates the property with a new value.
§

fn into_cloneable(self) -> <MaybeSignal<V, S> as IntoProperty>::Cloneable

Converts this to a cloneable type.
§

fn into_cloneable_owned( self, ) -> <MaybeSignal<V, S> as IntoProperty>::CloneableOwned

Converts this to a cloneable, owned type.
§

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

§

type AsyncOutput = MaybeSignal<V, S>

The type after all async data have resolved.
§

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

The view state retained between building and rebuilding.
§

type Cloneable = MaybeSignal<V, S>

An equivalent value that can be cloned.
§

type CloneableOwned = MaybeSignal<V, S>

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

fn to_html(self, style: &mut String)

Renders the style to HTML.
§

fn hydrate<const FROM_SERVER: bool>( self, el: &Element, ) -> <MaybeSignal<V, S> as IntoStyle>::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) -> <MaybeSignal<V, S> as IntoStyle>::State

Adds this style to the element during client-side rendering.
§

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

Updates the value.
§

fn into_cloneable(self) -> <MaybeSignal<V, S> as IntoStyle>::Cloneable

Converts this to a cloneable type.
§

fn into_cloneable_owned( self, ) -> <MaybeSignal<V, S> as IntoStyle>::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.
§

async fn resolve(self) -> <MaybeSignal<V, S> as IntoStyle>::AsyncOutput

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

fn reset(state: &mut <MaybeSignal<V, S> as IntoStyle>::State)

Reset the styling to the state before this style was added.
§

impl<V, S> IntoStyleValue for MaybeSignal<V, S>
where V: IntoStyleValue + Send + Sync + Clone + 'static, MaybeSignal<V, S>: Get<Value = V>, S: Storage<V> + Storage<Option<V>> + Send + Sync + 'static,

§

type AsyncOutput = MaybeSignal<V, S>

The type after all async data have resolved.
§

type State = (Arc<str>, RenderEffect<<V as IntoStyleValue>::State>)

The view state retained between building and rebuilding.
§

type Cloneable = MaybeSignal<V, S>

An equivalent value that can be cloned.
§

type CloneableOwned = MaybeSignal<V, S>

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

fn to_html(self, name: &str, style: &mut String)

Renders the style to HTML.
§

fn build( self, style: &CssStyleDeclaration, name: &str, ) -> <MaybeSignal<V, S> as IntoStyleValue>::State

Adds this style to the element during client-side rendering.
§

fn rebuild( self, style: &CssStyleDeclaration, name: &str, state: &mut <MaybeSignal<V, S> as IntoStyleValue>::State, )

Updates the value.
§

fn hydrate( self, style: &CssStyleDeclaration, name: &str, ) -> <MaybeSignal<V, S> as IntoStyleValue>::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 into_cloneable(self) -> <MaybeSignal<V, S> as IntoStyleValue>::Cloneable

Converts this to a cloneable type.
§

fn into_cloneable_owned( self, ) -> <MaybeSignal<V, S> as IntoStyleValue>::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.
§

async fn resolve(self) -> <MaybeSignal<V, S> as IntoStyleValue>::AsyncOutput

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

impl<T, S> PartialEq for MaybeSignal<T, S>
where T: PartialEq + 'static, S: PartialEq + Storage<T>,

§

fn eq(&self, other: &MaybeSignal<T, S>) -> bool

Tests for self and other values to be equal, and is used by ==.
1.0.0 (const: unstable) · Source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
§

impl<T, S> ReadUntracked for MaybeSignal<T, S>
where T: Clone, S: Storage<SignalTypes<T, S>> + Storage<T>,

§

type Value = ReadGuard<T, SignalReadGuard<T, S>>

The guard type that will be returned, which can be dereferenced to the value.
§

fn try_read_untracked( &self, ) -> Option<<MaybeSignal<T, S> as ReadUntracked>::Value>

Returns the guard, or None if the signal has already been disposed.
§

fn custom_try_read( &self, ) -> Option<Option<<MaybeSignal<T, S> as ReadUntracked>::Value>>

This is a backdoor to allow overriding the Read::try_read implementation despite it being auto implemented. Read more
§

fn read_untracked(&self) -> Self::Value

Returns the guard. Read more
§

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

§

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

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

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

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

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

Updates the view with new data.
§

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

§

const MIN_LENGTH: usize = 0

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

type AsyncOutput = MaybeSignal<V, S>

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

type Owned = MaybeSignal<V, S>

An equivalent value that is 'static.
§

fn dry_resolve(&mut self)

“Runs” the view without other side effects. For primitive types, this is a no-op. For reactive types, this can be used to gather data about reactivity or about asynchronous data that needs to be loaded.
§

async fn resolve(self) -> <MaybeSignal<V, S> as RenderHtml>::AsyncOutput

Waits for any asynchronous sections of the view to load and returns the output.
§

fn html_len(&self) -> usize

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

fn to_html_with_buf( self, buf: &mut String, position: &mut Position, escape: bool, mark_branches: bool, extra_attrs: Vec<AnyAttribute>, )

Renders a view to HTML, writing it into the given buffer.
§

fn to_html_async_with_buf<const OUT_OF_ORDER: bool>( self, buf: &mut StreamBuilder, position: &mut Position, escape: bool, mark_branches: bool, extra_attrs: Vec<AnyAttribute>, )
where MaybeSignal<V, S>: Sized,

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

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

Makes a set of DOM nodes rendered from HTML interactive. Read more
§

fn into_owned(self) -> <MaybeSignal<V, S> as RenderHtml>::Owned

Convert into the equivalent value that is 'static.
§

const EXISTS: bool = true

Whether this should actually exist in the DOM, if it is the child of an element.
§

fn to_html(self) -> String
where Self: Sized,

Renders a view to an HTML string.
§

fn to_html_branching(self) -> String
where Self: Sized,

Renders a view to HTML with branch markers. This can be used to support libraries that diff HTML pages against one another, by marking sections of the view that branch to different types with marker comments.
§

fn to_html_stream_in_order(self) -> StreamBuilder
where Self: Sized,

Renders a view to an in-order stream of HTML.
§

fn to_html_stream_in_order_branching(self) -> StreamBuilder
where Self: Sized,

Renders a view to an in-order stream of HTML with branch markers. This can be used to support libraries that diff HTML pages against one another, by marking sections of the view that branch to different types with marker comments.
§

fn to_html_stream_out_of_order(self) -> StreamBuilder
where Self: Sized,

Renders a view to an out-of-order stream of HTML.
§

fn to_html_stream_out_of_order_branching(self) -> StreamBuilder
where Self: Sized,

Renders a view to an out-of-order stream of HTML with branch markers. This can be used to support libraries that diff HTML pages against one another, by marking sections of the view that branch to different types with marker comments.
§

fn hydrate_async( self, cursor: &Cursor, position: &PositionState, ) -> impl Future<Output = Self::State>

Asynchronously makes a set of DOM nodes rendered from HTML interactive. Read more
§

fn hydrate_from<const FROM_SERVER: bool>(self, el: &Element) -> Self::State
where Self: Sized,

Hydrates using RenderHtml::hydrate, beginning at the given element.
§

fn hydrate_from_position<const FROM_SERVER: bool>( self, el: &Element, position: Position, ) -> Self::State
where Self: Sized,

Hydrates using RenderHtml::hydrate, beginning at the given element and position.
§

impl<T, St> Serialize for MaybeSignal<T, St>
where T: Clone + Send + Sync + Serialize, St: Storage<SignalTypes<T, St>> + Storage<T>,

§

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where S: Serializer,

Serialize this value into the given Serde serializer. Read more
§

impl<T, S> Track for MaybeSignal<T, S>
where S: Storage<T> + Storage<SignalTypes<T, S>>,

§

fn track(&self)

Subscribes to this signal in the current reactive scope without doing anything with its value.
§

impl<T, S> Copy for MaybeSignal<T, S>
where T: Copy, S: Storage<T>,

§

impl<T, S> Eq for MaybeSignal<T, S>
where T: Eq + 'static, S: Eq + Storage<T>,

§

impl<T, S> StructuralPartialEq for MaybeSignal<T, S>
where T: 'static, S: Storage<T>,

Auto Trait Implementations§

§

impl<T, S> Freeze for MaybeSignal<T, S>
where T: Freeze,

§

impl<T, S> RefUnwindSafe for MaybeSignal<T, S>
where T: RefUnwindSafe,

§

impl<T, S> Send for MaybeSignal<T, S>
where T: Send,

§

impl<T, S> Sync for MaybeSignal<T, S>
where T: Sync,

§

impl<T, S> Unpin for MaybeSignal<T, S>
where T: Unpin,

§

impl<T, S> UnsafeUnpin for MaybeSignal<T, S>
where T: UnsafeUnpin,

§

impl<T, S> UnwindSafe for MaybeSignal<T, S>
where T: UnwindSafe,

Blanket Implementations§

Source§

impl<S, D, Swp, Dwp, T> AdaptInto<D, Swp, Dwp, T> for S
where T: Real + Zero + Arithmetics + Clone, Swp: WhitePoint<T>, Dwp: WhitePoint<T>, D: AdaptFrom<S, Swp, Dwp, T>,

Source§

fn adapt_into_using<M>(self, method: M) -> D
where M: TransformMatrix<T>,

Convert the source color to the destination color using the specified method.
Source§

fn adapt_into(self) -> D

Convert the source color to the destination color using the bradford method by default.
Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T, C> ArraysFrom<C> for T
where C: IntoArrays<T>,

Source§

fn arrays_from(colors: C) -> T

Cast a collection of colors into a collection of arrays.
Source§

impl<T, C> ArraysInto<C> for T
where C: FromArrays<T>,

Source§

fn arrays_into(self) -> C

Cast this collection of arrays into a collection of colors.
§

impl<V, Key, Sig, T> BindAttribute<Key, Sig, T> for V
where V: AddAnyAttr, Key: AttributeKey, Sig: IntoSplitSignal<Value = T>, T: FromEventTarget + AttributeValue + PartialEq + Sync + 'static, Signal<BoolOrT<T>>: IntoProperty, <Sig as IntoSplitSignal>::Read: Get<Value = T> + Send + Sync + Clone + 'static, <Sig as IntoSplitSignal>::Write: Send + Clone + 'static, Element: GetValue<T>,

§

type Output = <V as AddAnyAttr>::Output<Bind<Key, T, <Sig as IntoSplitSignal>::Read, <Sig as IntoSplitSignal>::Write>>

The type of the element with the two-way binding added.
§

fn bind( self, key: Key, signal: Sig, ) -> <V as BindAttribute<Key, Sig, T>>::Output

Adds a two-way binding to the element, which adds an attribute and an event listener to the element when the element is created or hydrated. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<WpParam, T, U> Cam16IntoUnclamped<WpParam, T> for U
where T: FromCam16Unclamped<WpParam, U>,

Source§

type Scalar = <T as FromCam16Unclamped<WpParam, U>>::Scalar

The number type that’s used in parameters when converting.
Source§

fn cam16_into_unclamped( self, parameters: BakedParameters<WpParam, <U as Cam16IntoUnclamped<WpParam, T>>::Scalar>, ) -> T

Converts self into C, using the provided parameters.
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
Source§

impl<T, C> ComponentsFrom<C> for T
where C: IntoComponents<T>,

Source§

fn components_from(colors: C) -> T

Cast a collection of colors into a collection of color components.
§

impl<T, K, V> CustomAttribute<K, V> for T
where T: AddAnyAttr, K: CustomAttributeKey, V: AttributeValue,

§

fn attr(self, key: K, value: V) -> Self::Output<CustomAttr<K, V>>

Adds an HTML attribute by key and value.
§

impl<V, T, P, D> DirectiveAttribute<T, P, D> for V
where V: AddAnyAttr, D: IntoDirective<T, P>, P: Clone + 'static, T: 'static,

§

type Output = <V as AddAnyAttr>::Output<Directive<T, D, P>>

The type of the element with the directive added.
§

fn directive( self, handler: D, param: P, ) -> <V as DirectiveAttribute<T, P, D>>::Output

Adds a directive to the element, which runs some custom logic in the browser when the element is created or hydrated.
§

impl<T> Downcast for T
where T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Converts Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>, which can then be downcast into Box<dyn ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Converts Rc<Trait> (where Trait: Downcast) to Rc<Any>, which can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Converts &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Converts &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
§

impl<T> DowncastSend for T
where T: Any + Send,

§

fn into_any_send(self: Box<T>) -> Box<dyn Any + Send>

Converts Box<Trait> (where Trait: DowncastSend) to Box<dyn Any + Send>, which can then be downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

impl<T> DowncastSync for T
where T: Any + Send + Sync,

§

fn into_any_sync(self: Box<T>) -> Box<dyn Any + Sync + Send>

Converts Box<Trait> (where Trait: DowncastSync) to Box<dyn Any + Send + Sync>, which can then be downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send> ⓘ

Converts Arc<Trait> (where Trait: DowncastSync) to Arc<Any>, which can then be downcast into Arc<ConcreteType> where ConcreteType implements Trait.
§

impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

§

fn equivalent(&self, key: &K) -> bool

Checks if this value is equivalent to the given key. Read more
§

impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

§

fn equivalent(&self, key: &K) -> bool

Compare self to key and return true if they are equal.
§

impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

§

fn equivalent(&self, key: &K) -> bool

Checks if this value is equivalent to the given key. Read more
Source§

impl<T> From<!> for T

Source§

fn from(t: !) -> T

Converts to this type from the input type.
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T> FromAngle<T> for T

Source§

fn from_angle(angle: T) -> T

Performs a conversion from angle.
§

impl<T> FromFormData for T
where T: DeserializeOwned,

§

fn from_event(ev: &Event) -> Result<T, FromFormDataError>

Tries to deserialize the data, given only the submit event.
§

fn from_form_data(form_data: &FormData) -> Result<T, Error>

Tries to deserialize the data, given the actual form data.
§

impl<T> FromRef<T> for T
where T: Clone,

§

fn from_ref(input: &T) -> T

Converts to this type from a reference to the input type.
§

impl<E, T, Request> FromReq<DeleteUrl, Request, E> for T
where Request: Req<E> + Send + 'static, T: DeserializeOwned, E: FromServerFnError,

§

async fn from_req(req: Request) -> Result<T, E>

Attempts to deserialize the arguments from a request.
§

impl<E, T, Request> FromReq<GetUrl, Request, E> for T
where Request: Req<E> + Send + 'static, T: DeserializeOwned, E: FromServerFnError,

§

async fn from_req(req: Request) -> Result<T, E>

Attempts to deserialize the arguments from a request.
§

impl<E, T, Request, Encoding> FromReq<Patch<Encoding>, Request, E> for T
where Request: Req<E> + Send + 'static, Encoding: Decodes<T>, E: FromServerFnError,

§

async fn from_req(req: Request) -> Result<T, E>

Attempts to deserialize the arguments from a request.
§

impl<E, T, Request> FromReq<PatchUrl, Request, E> for T
where Request: Req<E> + Send + 'static, T: DeserializeOwned, E: FromServerFnError,

§

async fn from_req(req: Request) -> Result<T, E>

Attempts to deserialize the arguments from a request.
§

impl<E, T, Request, Encoding> FromReq<Post<Encoding>, Request, E> for T
where Request: Req<E> + Send + 'static, Encoding: Decodes<T>, E: FromServerFnError,

§

async fn from_req(req: Request) -> Result<T, E>

Attempts to deserialize the arguments from a request.
§

impl<E, T, Request> FromReq<PostUrl, Request, E> for T
where Request: Req<E> + Send + 'static, T: DeserializeOwned, E: FromServerFnError,

§

async fn from_req(req: Request) -> Result<T, E>

Attempts to deserialize the arguments from a request.
§

impl<E, T, Request, Encoding> FromReq<Put<Encoding>, Request, E> for T
where Request: Req<E> + Send + 'static, Encoding: Decodes<T>, E: FromServerFnError,

§

async fn from_req(req: Request) -> Result<T, E>

Attempts to deserialize the arguments from a request.
§

impl<E, T, Request> FromReq<PutUrl, Request, E> for T
where Request: Req<E> + Send + 'static, T: DeserializeOwned, E: FromServerFnError,

§

async fn from_req(req: Request) -> Result<T, E>

Attempts to deserialize the arguments from a request.
§

impl<E, Encoding, Response, T> FromRes<Patch<Encoding>, Response, E> for T
where Response: ClientRes<E> + Send, Encoding: Decodes<T>, E: FromServerFnError,

§

async fn from_res(res: Response) -> Result<T, E>

Attempts to deserialize the outputs from a response.
§

impl<E, Encoding, Response, T> FromRes<Post<Encoding>, Response, E> for T
where Response: ClientRes<E> + Send, Encoding: Decodes<T>, E: FromServerFnError,

§

async fn from_res(res: Response) -> Result<T, E>

Attempts to deserialize the outputs from a response.
§

impl<E, Encoding, Response, T> FromRes<Put<Encoding>, Response, E> for T
where Response: ClientRes<E> + Send, Encoding: Decodes<T>, E: FromServerFnError,

§

async fn from_res(res: Response) -> Result<T, E>

Attempts to deserialize the outputs from a response.
Source§

impl<T, U> FromStimulus<U> for T
where U: IntoStimulus<T>,

Source§

fn from_stimulus(other: U) -> T

Converts other into Self, while performing the appropriate scaling, rounding and clamping.
§

impl<S, T> FromStream<T> for S
where S: From<ArcReadSignal<Option<T>>> + Send + Sync, T: Send + Sync + 'static,

§

fn from_stream(stream: impl Stream<Item = T> + Send + 'static) -> S

Creates a signal that contains the latest value of the stream.
§

fn from_stream_unsync(stream: impl Stream<Item = T> + 'static) -> S

Creates a signal that contains the latest value of the stream.
§

impl<T> Hexable for T
where T: Serialize + for<'de> Deserialize<'de>,

§

fn as_hex_string(&self) -> Result<String, AsHexError>

Errors Read more
§

fn from_hex(s: &str) -> Result<T, FromHexError>

Errors Read more
§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T, U> IntoAngle<U> for T
where U: FromAngle<T>,

Source§

fn into_angle(self) -> U

Performs a conversion into T.
§

impl<T> IntoAny for T
where T: Send + RenderHtml,

§

fn into_any(self) -> AnyView

Converts the view into a type-erased AnyView.
§

impl<T> IntoAttributeValue for T
where T: AttributeValue,

§

type Output = T

The attribute value into which this type can be converted.
§

fn into_attribute_value(self) -> <T as IntoAttributeValue>::Output

Consumes this value, transforming it into an attribute value.
Source§

impl<WpParam, T, U> IntoCam16Unclamped<WpParam, T> for U
where T: Cam16FromUnclamped<WpParam, U>,

Source§

type Scalar = <T as Cam16FromUnclamped<WpParam, U>>::Scalar

The number type that’s used in parameters when converting.
Source§

fn into_cam16_unclamped( self, parameters: BakedParameters<WpParam, <U as IntoCam16Unclamped<WpParam, T>>::Scalar>, ) -> T

Converts self into C, using the provided parameters.
Source§

impl<T, U> IntoColor<U> for T
where U: FromColor<T>,

Source§

fn into_color(self) -> U

Convert into T with values clamped to the color defined bounds Read more
Source§

impl<T, U> IntoColorUnclamped<U> for T
where U: FromColorUnclamped<T>,

Source§

fn into_color_unclamped(self) -> U

Convert into T. The resulting color might be invalid in its color space Read more
Source§

impl<T> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

impl<ET, Err, A> IntoErr<ET, Err> for A
where ET: EngineTypes, Err: From<A>,

Source§

fn into_err( self, _aux: &EngineAux<ET>, _state: &<ET as EngineTypes>::State, ) -> Err

§

impl<T> IntoMaybeErased for T
where T: RenderHtml,

§

type Output = T

The type of the output.
§

fn into_maybe_erased(self) -> <T as IntoMaybeErased>::Output

Converts the view into a type-erased view if in erased mode.
§

impl<T, S> IntoOptionGetter<T, SignalMarker> for S
where S: Get<Value = Option<T>> + Clone + Send + Sync + 'static,

§

fn into_option_getter(self) -> OptionGetter<T>

Converts the given value into an OptionGetter.
§

impl<T, I> IntoReactiveValue<T, __IntoReactiveValueMarkerBaseCase> for I
where I: Into<T>,

§

fn into_reactive_value(self) -> T

Converts self into a T.
§

impl<T> IntoRender for T
where T: Render,

§

type Output = T

The renderable type into which this type can be converted.
§

fn into_render(self) -> <T as IntoRender>::Output

Consumes this value, transforming it into the renderable type.
§

impl<E, T, Request> IntoReq<DeleteUrl, Request, E> for T
where Request: ClientReq<E>, T: Serialize + Send, E: FromServerFnError,

§

fn into_req(self, path: &str, accepts: &str) -> Result<Request, E>

Attempts to serialize the arguments into an HTTP request.
§

impl<E, T, Request> IntoReq<GetUrl, Request, E> for T
where Request: ClientReq<E>, T: Serialize + Send, E: FromServerFnError,

§

fn into_req(self, path: &str, accepts: &str) -> Result<Request, E>

Attempts to serialize the arguments into an HTTP request.
§

impl<E, T, Encoding, Request> IntoReq<Patch<Encoding>, Request, E> for T
where Request: ClientReq<E>, Encoding: Encodes<T>, E: FromServerFnError,

§

fn into_req(self, path: &str, accepts: &str) -> Result<Request, E>

Attempts to serialize the arguments into an HTTP request.
§

impl<E, T, Request> IntoReq<PatchUrl, Request, E> for T
where Request: ClientReq<E>, T: Serialize + Send, E: FromServerFnError,

§

fn into_req(self, path: &str, accepts: &str) -> Result<Request, E>

Attempts to serialize the arguments into an HTTP request.
§

impl<E, T, Encoding, Request> IntoReq<Post<Encoding>, Request, E> for T
where Request: ClientReq<E>, Encoding: Encodes<T>, E: FromServerFnError,

§

fn into_req(self, path: &str, accepts: &str) -> Result<Request, E>

Attempts to serialize the arguments into an HTTP request.
§

impl<E, T, Request> IntoReq<PostUrl, Request, E> for T
where Request: ClientReq<E>, T: Serialize + Send, E: FromServerFnError,

§

fn into_req(self, path: &str, accepts: &str) -> Result<Request, E>

Attempts to serialize the arguments into an HTTP request.
§

impl<E, T, Encoding, Request> IntoReq<Put<Encoding>, Request, E> for T
where Request: ClientReq<E>, Encoding: Encodes<T>, E: FromServerFnError,

§

fn into_req(self, path: &str, accepts: &str) -> Result<Request, E>

Attempts to serialize the arguments into an HTTP request.
§

impl<E, T, Request> IntoReq<PutUrl, Request, E> for T
where Request: ClientReq<E>, T: Serialize + Send, E: FromServerFnError,

§

fn into_req(self, path: &str, accepts: &str) -> Result<Request, E>

Attempts to serialize the arguments into an HTTP request.
§

impl<E, Response, Encoding, T> IntoRes<Patch<Encoding>, Response, E> for T
where Response: TryRes<E>, Encoding: Encodes<T>, E: FromServerFnError + Send, T: Send,

§

async fn into_res(self) -> Result<Response, E>

Attempts to serialize the output into an HTTP response.
§

impl<E, Response, Encoding, T> IntoRes<Post<Encoding>, Response, E> for T
where Response: TryRes<E>, Encoding: Encodes<T>, E: FromServerFnError + Send, T: Send,

§

async fn into_res(self) -> Result<Response, E>

Attempts to serialize the output into an HTTP response.
§

impl<E, Response, Encoding, T> IntoRes<Put<Encoding>, Response, E> for T
where Response: TryRes<E>, Encoding: Encodes<T>, E: FromServerFnError + Send, T: Send,

§

async fn into_res(self) -> Result<Response, E>

Attempts to serialize the output into an HTTP response.
Source§

impl<T> IntoStimulus<T> for T

Source§

fn into_stimulus(self) -> T

Converts self into T, while performing the appropriate scaling, rounding and clamping.
§

impl<T> IntoView for T
where T: Render + RenderHtml + Send,

§

fn into_view(self) -> View<T>

Wraps the inner type.
§

impl<D> OwoColorize for D

§

fn fg<C>(&self) -> FgColorDisplay<'_, C, Self>
where C: Color,

Set the foreground color generically Read more
§

fn bg<C>(&self) -> BgColorDisplay<'_, C, Self>
where C: Color,

Set the background color generically. Read more
§

fn black(&self) -> FgColorDisplay<'_, Black, Self>

Change the foreground color to black
§

fn on_black(&self) -> BgColorDisplay<'_, Black, Self>

Change the background color to black
§

fn red(&self) -> FgColorDisplay<'_, Red, Self>

Change the foreground color to red
§

fn on_red(&self) -> BgColorDisplay<'_, Red, Self>

Change the background color to red
§

fn green(&self) -> FgColorDisplay<'_, Green, Self>

Change the foreground color to green
§

fn on_green(&self) -> BgColorDisplay<'_, Green, Self>

Change the background color to green
§

fn yellow(&self) -> FgColorDisplay<'_, Yellow, Self>

Change the foreground color to yellow
§

fn on_yellow(&self) -> BgColorDisplay<'_, Yellow, Self>

Change the background color to yellow
§

fn blue(&self) -> FgColorDisplay<'_, Blue, Self>

Change the foreground color to blue
§

fn on_blue(&self) -> BgColorDisplay<'_, Blue, Self>

Change the background color to blue
§

fn magenta(&self) -> FgColorDisplay<'_, Magenta, Self>

Change the foreground color to magenta
§

fn on_magenta(&self) -> BgColorDisplay<'_, Magenta, Self>

Change the background color to magenta
§

fn purple(&self) -> FgColorDisplay<'_, Magenta, Self>

Change the foreground color to purple
§

fn on_purple(&self) -> BgColorDisplay<'_, Magenta, Self>

Change the background color to purple
§

fn cyan(&self) -> FgColorDisplay<'_, Cyan, Self>

Change the foreground color to cyan
§

fn on_cyan(&self) -> BgColorDisplay<'_, Cyan, Self>

Change the background color to cyan
§

fn white(&self) -> FgColorDisplay<'_, White, Self>

Change the foreground color to white
§

fn on_white(&self) -> BgColorDisplay<'_, White, Self>

Change the background color to white
§

fn default_color(&self) -> FgColorDisplay<'_, Default, Self>

Change the foreground color to the terminal default
§

fn on_default_color(&self) -> BgColorDisplay<'_, Default, Self>

Change the background color to the terminal default
§

fn bright_black(&self) -> FgColorDisplay<'_, BrightBlack, Self>

Change the foreground color to bright black
§

fn on_bright_black(&self) -> BgColorDisplay<'_, BrightBlack, Self>

Change the background color to bright black
§

fn bright_red(&self) -> FgColorDisplay<'_, BrightRed, Self>

Change the foreground color to bright red
§

fn on_bright_red(&self) -> BgColorDisplay<'_, BrightRed, Self>

Change the background color to bright red
§

fn bright_green(&self) -> FgColorDisplay<'_, BrightGreen, Self>

Change the foreground color to bright green
§

fn on_bright_green(&self) -> BgColorDisplay<'_, BrightGreen, Self>

Change the background color to bright green
§

fn bright_yellow(&self) -> FgColorDisplay<'_, BrightYellow, Self>

Change the foreground color to bright yellow
§

fn on_bright_yellow(&self) -> BgColorDisplay<'_, BrightYellow, Self>

Change the background color to bright yellow
§

fn bright_blue(&self) -> FgColorDisplay<'_, BrightBlue, Self>

Change the foreground color to bright blue
§

fn on_bright_blue(&self) -> BgColorDisplay<'_, BrightBlue, Self>

Change the background color to bright blue
§

fn bright_magenta(&self) -> FgColorDisplay<'_, BrightMagenta, Self>

Change the foreground color to bright magenta
§

fn on_bright_magenta(&self) -> BgColorDisplay<'_, BrightMagenta, Self>

Change the background color to bright magenta
§

fn bright_purple(&self) -> FgColorDisplay<'_, BrightMagenta, Self>

Change the foreground color to bright purple
§

fn on_bright_purple(&self) -> BgColorDisplay<'_, BrightMagenta, Self>

Change the background color to bright purple
§

fn bright_cyan(&self) -> FgColorDisplay<'_, BrightCyan, Self>

Change the foreground color to bright cyan
§

fn on_bright_cyan(&self) -> BgColorDisplay<'_, BrightCyan, Self>

Change the background color to bright cyan
§

fn bright_white(&self) -> FgColorDisplay<'_, BrightWhite, Self>

Change the foreground color to bright white
§

fn on_bright_white(&self) -> BgColorDisplay<'_, BrightWhite, Self>

Change the background color to bright white
§

fn bold(&self) -> BoldDisplay<'_, Self>

Make the text bold
§

fn dimmed(&self) -> DimDisplay<'_, Self>

Make the text dim
§

fn italic(&self) -> ItalicDisplay<'_, Self>

Make the text italicized
§

fn underline(&self) -> UnderlineDisplay<'_, Self>

Make the text underlined
Make the text blink
Make the text blink (but fast!)
§

fn reversed(&self) -> ReversedDisplay<'_, Self>

Swap the foreground and background colors
§

fn hidden(&self) -> HiddenDisplay<'_, Self>

Hide the text
§

fn strikethrough(&self) -> StrikeThroughDisplay<'_, Self>

Cross out the text
§

fn color<Color>(&self, color: Color) -> FgDynColorDisplay<'_, Color, Self>
where Color: DynColor,

Set the foreground color at runtime. Only use if you do not know which color will be used at compile-time. If the color is constant, use either [OwoColorize::fg] or a color-specific method, such as [OwoColorize::green], Read more
§

fn on_color<Color>(&self, color: Color) -> BgDynColorDisplay<'_, Color, Self>
where Color: DynColor,

Set the background color at runtime. Only use if you do not know what color to use at compile-time. If the color is constant, use either [OwoColorize::bg] or a color-specific method, such as [OwoColorize::on_yellow], Read more
§

fn fg_rgb<const R: u8, const G: u8, const B: u8>( &self, ) -> FgColorDisplay<'_, CustomColor<R, G, B>, Self>

Set the foreground color to a specific RGB value.
§

fn bg_rgb<const R: u8, const G: u8, const B: u8>( &self, ) -> BgColorDisplay<'_, CustomColor<R, G, B>, Self>

Set the background color to a specific RGB value.
§

fn truecolor(&self, r: u8, g: u8, b: u8) -> FgDynColorDisplay<'_, Rgb, Self>

Sets the foreground color to an RGB value.
§

fn on_truecolor(&self, r: u8, g: u8, b: u8) -> BgDynColorDisplay<'_, Rgb, Self>

Sets the background color to an RGB value.
§

fn style(&self, style: Style) -> Styled<&Self>

Apply a runtime-determined style
§

fn if_supports_color<'a, Out, ApplyFn>( &'a self, stream: impl Into<Stream>, apply: ApplyFn, ) -> SupportsColorsDisplay<'a, Self, Out, ApplyFn>
where ApplyFn: Fn(&'a Self) -> Out,

Available on crate feature supports-colors only.
Apply a given transformation function to all formatters if the given stream supports at least basic ANSI colors, allowing you to conditionally apply given styles/colors. Read more
§

impl<T> Pointable for T

§

const ALIGN: usize

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
§

impl<T> PolicyExt for T
where T: ?Sized,

§

fn and<P, B, E>(self, other: P) -> And<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns [Action::Follow] only if self and other return Action::Follow. Read more
§

fn or<P, B, E>(self, other: P) -> Or<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns [Action::Follow] if either self or other returns Action::Follow. Read more
§

impl<T> Read for T
where T: Track + ReadUntracked,

§

type Value = <T as ReadUntracked>::Value

The guard type that will be returned, which can be dereferenced to the value.
§

fn try_read(&self) -> Option<<T as Read>::Value>

Subscribes to the signal, and returns the guard, or None if the signal has already been disposed.
§

fn read(&self) -> Self::Value

Subscribes to the signal, and returns the guard. Read more
Source§

impl<R, P> ReadPrimitive<R> for P
where R: Read + ReadEndian<P>, P: Default,

Source§

fn read_from_little_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_little_endian().
Source§

fn read_from_big_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_big_endian().
Source§

fn read_from_native_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_native_endian().
Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
§

impl<T> SerializableKey for T

§

fn ser_key(&self) -> String

Serializes the key to a unique string. Read more
§

impl<T> StorageAccess<T> for T

§

fn as_borrowed(&self) -> &T

Borrows the value.
§

fn into_taken(self) -> T

Takes the value.
Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T, C> TryComponentsInto<C> for T
where C: TryFromComponents<T>,

Source§

type Error = <C as TryFromComponents<T>>::Error

The error for when try_into_colors fails to cast.
Source§

fn try_components_into(self) -> Result<C, <T as TryComponentsInto<C>>::Error>

Try to cast this collection of color components into a collection of colors. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<T, U> TryIntoColor<U> for T
where U: TryFromColor<T>,

Source§

fn try_into_color(self) -> Result<U, OutOfBounds<U>>

Convert into T, returning ok if the color is inside of its defined range, otherwise an OutOfBounds error is returned which contains the unclamped color. Read more
Source§

impl<C, U> UintsFrom<C> for U
where C: IntoUints<U>,

Source§

fn uints_from(colors: C) -> U

Cast a collection of colors into a collection of unsigned integers.
Source§

impl<C, U> UintsInto<C> for U
where C: FromUints<U>,

Source§

fn uints_into(self) -> C

Cast this collection of unsigned integers into a collection of colors.
Source§

impl<S, T> Upcast<T> for S
where T: UpcastFrom<S> + ?Sized, S: ?Sized,

Source§

fn upcast(&self) -> &T
where Self: ErasableGeneric, T: ErasableGeneric<Repr = Self::Repr>,

Perform a zero-cost type-safe upcast to a wider ref type within the Wasm bindgen generics type system. Read more
Source§

fn upcast_into(self) -> T
where Self: Sized + ErasableGeneric, T: ErasableGeneric<Repr = Self::Repr>,

Perform a zero-cost type-safe upcast to a wider type within the Wasm bindgen generics type system. Read more
§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> With for T
where T: Read,

§

type Value = <<T as Read>::Value as Deref>::Target

The type of the value contained in the signal.
§

fn try_with<U>(&self, fun: impl FnOnce(&<T as With>::Value) -> U) -> Option<U>

Subscribes to the signal, applies the closure to the value, and returns the result, or None if the signal has already been disposed.
§

fn with<U>(&self, fun: impl FnOnce(&Self::Value) -> U) -> U

Subscribes to the signal, applies the closure to the value, and returns the result. Read more
§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

impl<T> WithUntracked for T
where T: DefinedAt + ReadUntracked,

§

type Value = <<T as ReadUntracked>::Value as Deref>::Target

The type of the value contained in the signal.
§

fn try_with_untracked<U>( &self, fun: impl FnOnce(&<T as WithUntracked>::Value) -> U, ) -> Option<U>

Applies the closure to the value, and returns the result, or None if the signal has already been disposed.
§

fn with_untracked<U>(&self, fun: impl FnOnce(&Self::Value) -> U) -> U

Applies the closure to the value, and returns the result. Read more
Source§

impl<T> CondSerialize for T
where T: Serialize,

Source§

impl<T> DeserializeOwned for T
where T: for<'de> Deserialize<'de>,

§

impl<T> Fruit for T
where T: Send + Downcast,