Struct silkenweb::node::element::GenericElement

pub struct GenericElement<D: Dom = DefaultDom, Mutability = Mut> { /* private fields */ }

Expand description

A generic HTML element.

Where available, specific DOM elements from crate::elements::html should be used in preference to this.

Mutability should be one of Mut or Const.

Implementations§

impl<D: Dom> GenericElement<D>

pub fn new(namespace: &Namespace, tag: &str) -> Self

Construct an element with type tag in namespace.

pub fn freeze(self) -> GenericElement<D, Const>

Make this element immutable.

impl<Param, D> GenericElement<Template<Param, D>>
where Param: 'static, D: InstantiableDom,

pub fn on_instantiate( self, f: impl 'static + Fn(GenericElement<D>, &Param) -> GenericElement<D> ) -> Self

impl<Param, D> GenericElement<Template<Param, D>, Const>
where D: InstantiableDom, Param: 'static,

pub fn instantiate(&self, param: &Param) -> GenericElement<D>

Instantiate a template with param.

See Template for an example.

Trait Implementations§

impl<D> Display for GenericElement<D, Const>
where D: Dom,

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

Formats the value using the given formatter. Read more

impl<D: Dom> Element for GenericElement<D>

type Dom = D

type DomElement = Element

fn class<'a, T>(self, class: impl RefSignalOrValue<'a, Item = T>) -> Self
where T: 'a + AsRef<str>,

Add a class to the element. Read more

fn classes<'a, T, Iter>( self, classes: impl RefSignalOrValue<'a, Item = Iter> ) -> Self
where T: 'a + AsRef<str>, Iter: 'a + IntoIterator<Item = T>,

Set the classes on an element Read more

fn attribute<'a>( self, name: &str, value: impl RefSignalOrValue<'a, Item = impl Attribute> ) -> Self

Set an attribute Read more

fn style_property<'a>( self, name: impl Into<String>, value: impl RefSignalOrValue<'a, Item = impl AsRef<str> + 'a> ) -> Self

Set an inline style property Read more

fn effect(self, f: impl FnOnce(&Self::DomElement) + 'static) -> Self

Apply an effect after the next render. Read more

fn effect_signal<T>( self, sig: impl Signal<Item = T> + 'static, f: impl Clone + Fn(&Self::DomElement, T) + 'static ) -> Self
where T: 'static,

Apply an effect after the next render each time a signal yields a new value.

fn map_element(self, f: impl FnOnce(&Self::DomElement) + 'static) -> Self

Map a function over the element.

fn map_element_signal<T>( self, sig: impl Signal<Item = T> + 'static, f: impl Clone + Fn(&Self::DomElement, T) + 'static ) -> Self
where T: 'static,

Map a function over the element each time a signal changes.

fn handle(&self) -> ElementHandle<Self::Dom, Self::DomElement>

Get a handle to the element. Read more

fn spawn_future(self, future: impl Future<Output = ()> + 'static) -> Self

Spawn a future on the element. Read more

fn on(self, name: &'static str, f: impl FnMut(JsValue) + 'static) -> Self

Register an event handler. Read more

impl<D: Dom> Executor for GenericElement<D>

fn spawn(&mut self, future: impl Future<Output = ()> + 'static)

impl<Dom: Dom> From<A<Dom>> for GenericElement<Dom, Const>

fn from(elem: A<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<A<Dom>> for GenericElement<Dom, Const>

fn from(elem: A<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<A<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: A<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<A<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: A<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Abbr<Dom>> for GenericElement<Dom, Const>

fn from(elem: Abbr<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Abbr<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Abbr<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Address<Dom>> for GenericElement<Dom, Const>

fn from(elem: Address<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Address<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Address<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Animate<Dom>> for GenericElement<Dom, Const>

fn from(elem: Animate<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Animate<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Animate<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Area<Dom>> for GenericElement<Dom, Const>

fn from(elem: Area<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Area<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Area<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Article<Dom>> for GenericElement<Dom, Const>

fn from(elem: Article<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Article<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Article<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Aside<Dom>> for GenericElement<Dom, Const>

fn from(elem: Aside<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Aside<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Aside<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Audio<Dom>> for GenericElement<Dom, Const>

fn from(elem: Audio<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Audio<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Audio<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<B<Dom>> for GenericElement<Dom, Const>

fn from(elem: B<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<B<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: B<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Base<Dom>> for GenericElement<Dom, Const>

fn from(elem: Base<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Base<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Base<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Bdi<Dom>> for GenericElement<Dom, Const>

fn from(elem: Bdi<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Bdi<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Bdi<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Bdo<Dom>> for GenericElement<Dom, Const>

fn from(elem: Bdo<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Bdo<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Bdo<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Blockquote<Dom>> for GenericElement<Dom, Const>

fn from(elem: Blockquote<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Blockquote<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Blockquote<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Br<Dom>> for GenericElement<Dom, Const>

fn from(elem: Br<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Br<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Br<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Button<Dom>> for GenericElement<Dom, Const>

fn from(elem: Button<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Button<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Button<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Canvas<Dom>> for GenericElement<Dom, Const>

fn from(elem: Canvas<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Canvas<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Canvas<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Caption<Dom>> for GenericElement<Dom, Const>

fn from(elem: Caption<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Caption<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Caption<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Circle<Dom>> for GenericElement<Dom, Const>

fn from(elem: Circle<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Circle<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Circle<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Cite<Dom>> for GenericElement<Dom, Const>

fn from(elem: Cite<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Cite<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Cite<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<ClipPath<Dom>> for GenericElement<Dom, Const>

fn from(elem: ClipPath<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<ClipPath<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: ClipPath<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Code<Dom>> for GenericElement<Dom, Const>

fn from(elem: Code<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Code<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Code<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Col<Dom>> for GenericElement<Dom, Const>

fn from(elem: Col<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Col<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Col<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Colgroup<Dom>> for GenericElement<Dom, Const>

fn from(elem: Colgroup<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Colgroup<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Colgroup<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<D: InstantiableDom> From<Component<D>> for GenericElement<D>

fn from(value: Component<D>) -> Self

Converts to this type from the input type.

impl<D: InstantiableDom> From<Component<D>> for GenericElement<D, Const>

fn from(value: Component<D>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Data<Dom>> for GenericElement<Dom, Const>

fn from(elem: Data<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Data<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Data<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Datalist<Dom>> for GenericElement<Dom, Const>

fn from(elem: Datalist<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Datalist<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Datalist<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Dd<Dom>> for GenericElement<Dom, Const>

fn from(elem: Dd<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Dd<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Dd<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Defs<Dom>> for GenericElement<Dom, Const>

fn from(elem: Defs<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Defs<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Defs<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Del<Dom>> for GenericElement<Dom, Const>

fn from(elem: Del<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Del<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Del<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Desc<Dom>> for GenericElement<Dom, Const>

fn from(elem: Desc<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Desc<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Desc<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Details<Dom>> for GenericElement<Dom, Const>

fn from(elem: Details<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Details<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Details<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Dfn<Dom>> for GenericElement<Dom, Const>

fn from(elem: Dfn<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Dfn<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Dfn<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Dialog<Dom>> for GenericElement<Dom, Const>

fn from(elem: Dialog<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Dialog<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Dialog<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Div<Dom>> for GenericElement<Dom, Const>

fn from(elem: Div<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Div<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Div<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Dl<Dom>> for GenericElement<Dom, Const>

fn from(elem: Dl<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Dl<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Dl<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Dt<Dom>> for GenericElement<Dom, Const>

fn from(elem: Dt<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Dt<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Dt<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Ellipse<Dom>> for GenericElement<Dom, Const>

fn from(elem: Ellipse<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Ellipse<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Ellipse<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Em<Dom>> for GenericElement<Dom, Const>

fn from(elem: Em<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Em<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Em<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Embed<Dom>> for GenericElement<Dom, Const>

fn from(elem: Embed<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Embed<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Embed<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<FeBlend<Dom>> for GenericElement<Dom, Const>

fn from(elem: FeBlend<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<FeBlend<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: FeBlend<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<FeColorMatrix<Dom>> for GenericElement<Dom, Const>

fn from(elem: FeColorMatrix<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<FeColorMatrix<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: FeColorMatrix<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<FeComponentTransfer<Dom>> for GenericElement<Dom, Const>

fn from(elem: FeComponentTransfer<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<FeComponentTransfer<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: FeComponentTransfer<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<FeComposite<Dom>> for GenericElement<Dom, Const>

fn from(elem: FeComposite<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<FeComposite<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: FeComposite<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<FeConvolveMatrix<Dom>> for GenericElement<Dom, Const>

fn from(elem: FeConvolveMatrix<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<FeConvolveMatrix<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: FeConvolveMatrix<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<FeDiffuseLighting<Dom>> for GenericElement<Dom, Const>

fn from(elem: FeDiffuseLighting<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<FeDiffuseLighting<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: FeDiffuseLighting<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<FeDisplacementMap<Dom>> for GenericElement<Dom, Const>

fn from(elem: FeDisplacementMap<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<FeDisplacementMap<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: FeDisplacementMap<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<FeDistantLight<Dom>> for GenericElement<Dom, Const>

fn from(elem: FeDistantLight<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<FeDistantLight<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: FeDistantLight<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<FeFlood<Dom>> for GenericElement<Dom, Const>

fn from(elem: FeFlood<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<FeFlood<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: FeFlood<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<FeFuncA<Dom>> for GenericElement<Dom, Const>

fn from(elem: FeFuncA<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<FeFuncA<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: FeFuncA<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<FeFuncB<Dom>> for GenericElement<Dom, Const>

fn from(elem: FeFuncB<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<FeFuncB<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: FeFuncB<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<FeFuncG<Dom>> for GenericElement<Dom, Const>

fn from(elem: FeFuncG<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<FeFuncG<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: FeFuncG<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<FeFuncR<Dom>> for GenericElement<Dom, Const>

fn from(elem: FeFuncR<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<FeFuncR<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: FeFuncR<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<FeGaussianBlur<Dom>> for GenericElement<Dom, Const>

fn from(elem: FeGaussianBlur<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<FeGaussianBlur<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: FeGaussianBlur<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<FeImage<Dom>> for GenericElement<Dom, Const>

fn from(elem: FeImage<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<FeImage<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: FeImage<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<FeMerge<Dom>> for GenericElement<Dom, Const>

fn from(elem: FeMerge<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<FeMerge<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: FeMerge<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<FeMergeNode<Dom>> for GenericElement<Dom, Const>

fn from(elem: FeMergeNode<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<FeMergeNode<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: FeMergeNode<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<FeMorphology<Dom>> for GenericElement<Dom, Const>

fn from(elem: FeMorphology<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<FeMorphology<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: FeMorphology<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<FeOffset<Dom>> for GenericElement<Dom, Const>

fn from(elem: FeOffset<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<FeOffset<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: FeOffset<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<FePointLight<Dom>> for GenericElement<Dom, Const>

fn from(elem: FePointLight<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<FePointLight<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: FePointLight<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<FeSpecularLighting<Dom>> for GenericElement<Dom, Const>

fn from(elem: FeSpecularLighting<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<FeSpecularLighting<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: FeSpecularLighting<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<FeSpotLight<Dom>> for GenericElement<Dom, Const>

fn from(elem: FeSpotLight<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<FeSpotLight<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: FeSpotLight<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<FeTile<Dom>> for GenericElement<Dom, Const>

fn from(elem: FeTile<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<FeTile<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: FeTile<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<FeTurbulence<Dom>> for GenericElement<Dom, Const>

fn from(elem: FeTurbulence<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<FeTurbulence<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: FeTurbulence<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Fieldset<Dom>> for GenericElement<Dom, Const>

fn from(elem: Fieldset<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Fieldset<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Fieldset<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Figcaption<Dom>> for GenericElement<Dom, Const>

fn from(elem: Figcaption<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Figcaption<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Figcaption<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Figure<Dom>> for GenericElement<Dom, Const>

fn from(elem: Figure<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Figure<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Figure<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Filter<Dom>> for GenericElement<Dom, Const>

fn from(elem: Filter<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Filter<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Filter<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Footer<Dom>> for GenericElement<Dom, Const>

fn from(elem: Footer<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Footer<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Footer<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<ForeignObject<Dom>> for GenericElement<Dom, Const>

fn from(elem: ForeignObject<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<ForeignObject<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: ForeignObject<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Form<Dom>> for GenericElement<Dom, Const>

fn from(elem: Form<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Form<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Form<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<G<Dom>> for GenericElement<Dom, Const>

fn from(elem: G<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<G<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: G<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<D: Dom, Mutability> From<GenericElement<D, Mutability>> for Node<D>

fn from(elem: GenericElement<D, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<H1<Dom>> for GenericElement<Dom, Const>

fn from(elem: H1<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<H1<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: H1<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<H2<Dom>> for GenericElement<Dom, Const>

fn from(elem: H2<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<H2<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: H2<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<H3<Dom>> for GenericElement<Dom, Const>

fn from(elem: H3<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<H3<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: H3<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<H4<Dom>> for GenericElement<Dom, Const>

fn from(elem: H4<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<H4<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: H4<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<H5<Dom>> for GenericElement<Dom, Const>

fn from(elem: H5<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<H5<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: H5<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<H6<Dom>> for GenericElement<Dom, Const>

fn from(elem: H6<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<H6<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: H6<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Head<Dom>> for GenericElement<Dom, Const>

fn from(elem: Head<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Head<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Head<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Header<Dom>> for GenericElement<Dom, Const>

fn from(elem: Header<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Header<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Header<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Hgroup<Dom>> for GenericElement<Dom, Const>

fn from(elem: Hgroup<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Hgroup<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Hgroup<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Hr<Dom>> for GenericElement<Dom, Const>

fn from(elem: Hr<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Hr<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Hr<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<I<Dom>> for GenericElement<Dom, Const>

fn from(elem: I<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<I<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: I<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Iframe<Dom>> for GenericElement<Dom, Const>

fn from(elem: Iframe<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Iframe<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Iframe<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Img<Dom>> for GenericElement<Dom, Const>

fn from(elem: Img<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Img<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Img<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Input<Dom>> for GenericElement<Dom, Const>

fn from(elem: Input<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Input<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Input<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Ins<Dom>> for GenericElement<Dom, Const>

fn from(elem: Ins<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Ins<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Ins<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Kbd<Dom>> for GenericElement<Dom, Const>

fn from(elem: Kbd<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Kbd<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Kbd<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Label<Dom>> for GenericElement<Dom, Const>

fn from(elem: Label<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Label<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Label<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Legend<Dom>> for GenericElement<Dom, Const>

fn from(elem: Legend<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Legend<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Legend<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Li<Dom>> for GenericElement<Dom, Const>

fn from(elem: Li<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Li<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Li<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Line<Dom>> for GenericElement<Dom, Const>

fn from(elem: Line<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Line<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Line<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Link<Dom>> for GenericElement<Dom, Const>

fn from(elem: Link<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Link<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Link<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Main<Dom>> for GenericElement<Dom, Const>

fn from(elem: Main<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Main<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Main<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Map<Dom>> for GenericElement<Dom, Const>

fn from(elem: Map<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Map<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Map<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Mark<Dom>> for GenericElement<Dom, Const>

fn from(elem: Mark<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Mark<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Mark<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Marker<Dom>> for GenericElement<Dom, Const>

fn from(elem: Marker<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Marker<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Marker<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Mask<Dom>> for GenericElement<Dom, Const>

fn from(elem: Mask<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Mask<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Mask<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Menu<Dom>> for GenericElement<Dom, Const>

fn from(elem: Menu<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Menu<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Menu<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Meta<Dom>> for GenericElement<Dom, Const>

fn from(elem: Meta<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Meta<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Meta<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Metadata<Dom>> for GenericElement<Dom, Const>

fn from(elem: Metadata<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Metadata<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Metadata<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Meter<Dom>> for GenericElement<Dom, Const>

fn from(elem: Meter<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Meter<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Meter<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Mpath<Dom>> for GenericElement<Dom, Const>

fn from(elem: Mpath<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Mpath<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Mpath<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Nav<Dom>> for GenericElement<Dom, Const>

fn from(elem: Nav<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Nav<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Nav<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Noscript<Dom>> for GenericElement<Dom, Const>

fn from(elem: Noscript<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Noscript<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Noscript<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Object<Dom>> for GenericElement<Dom, Const>

fn from(elem: Object<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Object<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Object<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Ol<Dom>> for GenericElement<Dom, Const>

fn from(elem: Ol<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Ol<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Ol<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Optgroup<Dom>> for GenericElement<Dom, Const>

fn from(elem: Optgroup<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Optgroup<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Optgroup<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Option<Dom>> for GenericElement<Dom, Const>

fn from(elem: Option<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Option<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Option<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Output<Dom>> for GenericElement<Dom, Const>

fn from(elem: Output<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Output<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Output<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<P<Dom>> for GenericElement<Dom, Const>

fn from(elem: P<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<P<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: P<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Param<Dom>> for GenericElement<Dom, Const>

fn from(elem: Param<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Param<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Param<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Path<Dom>> for GenericElement<Dom, Const>

fn from(elem: Path<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Path<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Path<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Pattern<Dom>> for GenericElement<Dom, Const>

fn from(elem: Pattern<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Pattern<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Pattern<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Picture<Dom>> for GenericElement<Dom, Const>

fn from(elem: Picture<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Picture<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Picture<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Polygon<Dom>> for GenericElement<Dom, Const>

fn from(elem: Polygon<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Polygon<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Polygon<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Polyline<Dom>> for GenericElement<Dom, Const>

fn from(elem: Polyline<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Polyline<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Polyline<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Pre<Dom>> for GenericElement<Dom, Const>

fn from(elem: Pre<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Pre<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Pre<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Progress<Dom>> for GenericElement<Dom, Const>

fn from(elem: Progress<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Progress<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Progress<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Q<Dom>> for GenericElement<Dom, Const>

fn from(elem: Q<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Q<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Q<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Rb<Dom>> for GenericElement<Dom, Const>

fn from(elem: Rb<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Rb<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Rb<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Rect<Dom>> for GenericElement<Dom, Const>

fn from(elem: Rect<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Rect<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Rect<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Rp<Dom>> for GenericElement<Dom, Const>

fn from(elem: Rp<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Rp<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Rp<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Rt<Dom>> for GenericElement<Dom, Const>

fn from(elem: Rt<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Rt<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Rt<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Rtc<Dom>> for GenericElement<Dom, Const>

fn from(elem: Rtc<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Rtc<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Rtc<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Ruby<Dom>> for GenericElement<Dom, Const>

fn from(elem: Ruby<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Ruby<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Ruby<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<S<Dom>> for GenericElement<Dom, Const>

fn from(elem: S<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<S<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: S<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Samp<Dom>> for GenericElement<Dom, Const>

fn from(elem: Samp<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Samp<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Samp<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Script<Dom>> for GenericElement<Dom, Const>

fn from(elem: Script<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Script<Dom>> for GenericElement<Dom, Const>

fn from(elem: Script<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Script<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Script<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Script<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Script<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Section<Dom>> for GenericElement<Dom, Const>

fn from(elem: Section<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Section<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Section<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Select<Dom>> for GenericElement<Dom, Const>

fn from(elem: Select<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Select<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Select<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Set<Dom>> for GenericElement<Dom, Const>

fn from(elem: Set<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Set<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Set<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Slot<Dom>> for GenericElement<Dom, Const>

fn from(elem: Slot<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Slot<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Slot<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Small<Dom>> for GenericElement<Dom, Const>

fn from(elem: Small<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Small<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Small<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Source<Dom>> for GenericElement<Dom, Const>

fn from(elem: Source<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Source<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Source<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Span<Dom>> for GenericElement<Dom, Const>

fn from(elem: Span<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Span<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Span<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Stop<Dom>> for GenericElement<Dom, Const>

fn from(elem: Stop<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Stop<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Stop<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Strong<Dom>> for GenericElement<Dom, Const>

fn from(elem: Strong<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Strong<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Strong<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Style<Dom>> for GenericElement<Dom, Const>

fn from(elem: Style<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Style<Dom>> for GenericElement<Dom, Const>

fn from(elem: Style<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Style<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Style<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Style<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Style<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Sub<Dom>> for GenericElement<Dom, Const>

fn from(elem: Sub<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Sub<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Sub<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Summary<Dom>> for GenericElement<Dom, Const>

fn from(elem: Summary<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Summary<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Summary<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Sup<Dom>> for GenericElement<Dom, Const>

fn from(elem: Sup<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Sup<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Sup<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Svg<Dom>> for GenericElement<Dom, Const>

fn from(elem: Svg<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Svg<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Svg<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Switch<Dom>> for GenericElement<Dom, Const>

fn from(elem: Switch<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Switch<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Switch<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Symbol<Dom>> for GenericElement<Dom, Const>

fn from(elem: Symbol<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Symbol<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Symbol<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Table<Dom>> for GenericElement<Dom, Const>

fn from(elem: Table<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Table<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Table<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Tbody<Dom>> for GenericElement<Dom, Const>

fn from(elem: Tbody<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Tbody<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Tbody<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Td<Dom>> for GenericElement<Dom, Const>

fn from(elem: Td<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Td<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Td<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Text<Dom>> for GenericElement<Dom, Const>

fn from(elem: Text<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Text<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Text<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<TextPath<Dom>> for GenericElement<Dom, Const>

fn from(elem: TextPath<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<TextPath<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: TextPath<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Textarea<Dom>> for GenericElement<Dom, Const>

fn from(elem: Textarea<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Textarea<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Textarea<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Tfoot<Dom>> for GenericElement<Dom, Const>

fn from(elem: Tfoot<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Tfoot<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Tfoot<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Th<Dom>> for GenericElement<Dom, Const>

fn from(elem: Th<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Th<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Th<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Thead<Dom>> for GenericElement<Dom, Const>

fn from(elem: Thead<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Thead<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Thead<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Time<Dom>> for GenericElement<Dom, Const>

fn from(elem: Time<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Time<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Time<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Title<Dom>> for GenericElement<Dom, Const>

fn from(elem: Title<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Title<Dom>> for GenericElement<Dom, Const>

fn from(elem: Title<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Title<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Title<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Title<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Title<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Tr<Dom>> for GenericElement<Dom, Const>

fn from(elem: Tr<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Tr<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Tr<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Track<Dom>> for GenericElement<Dom, Const>

fn from(elem: Track<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Track<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Track<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Tspan<Dom>> for GenericElement<Dom, Const>

fn from(elem: Tspan<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Tspan<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Tspan<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<U<Dom>> for GenericElement<Dom, Const>

fn from(elem: U<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<U<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: U<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Ul<Dom>> for GenericElement<Dom, Const>

fn from(elem: Ul<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Ul<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Ul<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Use<Dom>> for GenericElement<Dom, Const>

fn from(elem: Use<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Use<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Use<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Var<Dom>> for GenericElement<Dom, Const>

fn from(elem: Var<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Var<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Var<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Video<Dom>> for GenericElement<Dom, Const>

fn from(elem: Video<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Video<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Video<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<View<Dom>> for GenericElement<Dom, Const>

fn from(elem: View<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<View<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: View<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<Dom: Dom> From<Wbr<Dom>> for GenericElement<Dom, Const>

fn from(elem: Wbr<Dom, Mut>) -> Self

Converts to this type from the input type.

impl<Dom: Dom, Mutability> From<Wbr<Dom, Mutability>> for GenericElement<Dom, Mutability>

fn from(elem: Wbr<Dom, Mutability>) -> Self

Converts to this type from the input type.

impl<D: Dom, Mutability> InDom for GenericElement<D, Mutability>

type Dom = D

impl<D: Dom> ParentElement<D> for GenericElement<D>

fn text<'a, T>(self, child: impl RefSignalOrValue<'a, Item = T>) -> Self
where T: 'a + AsRef<str> + Into<String>,

Add a text child to this element Read more

fn optional_child( self, child: impl SignalOrValue<Item = Option<impl ChildNode<D>>> ) -> Self

Add an optional child to the element. Read more

fn children<N>(self, children: impl IntoIterator<Item = N>) -> Self
where N: Into<Node<D>>,

Add children to the element. Read more

fn children_signal<N>( self, children: impl SignalVec<Item = N> + 'static ) -> Self
where N: Into<Node<D>>,

Add children from a SignalVec to the element. Read more

fn child(self, child: impl SignalOrValue<Item = impl ChildNode<D>>) -> Self

Add a child to the element. Read more

impl<D: InstantiableDom> ShadowRootParent<D> for GenericElement<D>

fn attach_shadow_children<N>( self, children: impl IntoIterator<Item = N> + 'static ) -> Self
where N: Into<Node<D>>,

Attach an open shadow root to self and add children to it. Read more

impl<D: Dom, Mutability> Value for GenericElement<D, Mutability>

Auto Trait Implementations§

impl<D, Mutability> Freeze for GenericElement<D, Mutability>
where <D as Dom>::Element: Freeze,

impl<D = Dry, Mutability = Mut> !RefUnwindSafe for GenericElement<D, Mutability>

impl<D = Dry, Mutability = Mut> !Send for GenericElement<D, Mutability>

impl<D = Dry, Mutability = Mut> !Sync for GenericElement<D, Mutability>

impl<D, Mutability> Unpin for GenericElement<D, Mutability>
where <D as Dom>::Element: Unpin, Mutability: Unpin,

impl<D = Dry, Mutability = Mut> !UnwindSafe for GenericElement<D, Mutability>

Blanket Implementations§

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

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

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

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

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

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

Mutably borrows from an owned value. Read more

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

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

fn into(self) -> U

Calls U::from(self).

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

impl<T> IntoEither for T

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

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

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<'a, T> RefSignalOrValue<'a> for T
where T: RefValue<'a> + 'a,

type Item = T

The underlying type of the value or signal.

type Map<'b: 'a, F: FnMut(<T as RefSignalOrValue<'a>>::Item) -> R + 'b, R: RefSignalOrValue<'b, Item = R> + 'b> = R

The return type for Self::map. Read more

type Signal = Always<<T as RefSignalOrValue<'a>>::Item>

The signal type. Use Always for value types.

fn map<'b, F, R>( self, callback: F ) -> <T as RefSignalOrValue<'a>>::Map<'b, F, R>
where 'b: 'a, R: RefSignalOrValue<'b, Item = R> + 'b, F: FnMut(<T as RefSignalOrValue<'a>>::Item) -> R + 'b,

Map a function over this signal/value to produce a new signal/value.

fn select<FVal, FSig, Data, Out>( self, fn_val: FVal, _fn_sig: FSig, data: Data ) -> Out
where FVal: FnOnce(Data, <T as RefSignalOrValue<'a>>::Item) -> Out, FSig: FnOnce(Data, <T as RefSignalOrValue<'a>>::Signal) -> Out,

Select a function based on whether this is a signal or value. Read more

fn select_spawn<FVal, FSig, Task, Exec>( self, fn_val: FVal, _fn_sig: FSig, executor: &mut Exec )
where FVal: FnOnce(&mut Exec, <T as RefSignalOrValue<'a>>::Item), FSig: FnOnce(&mut Exec, <T as RefSignalOrValue<'a>>::Signal) -> Task, Task: Future<Output = ()> + 'a, Exec: Executor,

Select a function based on whether this is a signal or value. Read more

impl<T> ToString for T
where T: Display + ?Sized,

default fn to_string(&self) -> String

Converts the given value to a String. Read more

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

type Error = Infallible

The type returned in the event of a conversion error.

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

Performs the conversion.

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

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

The type returned in the event of a conversion error.

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

Performs the conversion.

impl<D, T> ChildElement<D> for T
where D: Dom, T: Into<GenericElement<D, Const>> + Into<Node<D>> + Value + 'static,

impl<D, T> ChildNode<D> for T
where D: Dom, T: Into<Node<D>> + Value + 'static,

impl<T> RefValue<'static> for T
where T: Value,

impl<T> SignalOrValue for T
where T: RefSignalOrValue<'static>,