Trait AddAnyAttr

pub trait AddAnyAttr {
    type Output<SomeNewAttr: Attribute>: RenderHtml;

    // Required method
    fn add_any_attr<NewAttr>(self, attr: NewAttr) -> Self::Output<NewAttr>
       where NewAttr: Attribute,
             Self::Output<NewAttr>: RenderHtml;
}

Allows adding a new attribute to some type, before it is rendered. This takes place at compile time as part of the builder syntax for creating a statically typed view tree.

Normally, this is used to add an attribute to an HTML element. But it is required to be implemented for all types that implement RenderHtml, so that attributes can be spread onto other structures like the return type of a component.

Required Associated Types

type Output<SomeNewAttr: Attribute>: RenderHtml

The new type once the attribute has been added.

Required Methods

fn add_any_attr<NewAttr>(self, attr: NewAttr) -> Self::Output<NewAttr>

where NewAttr: Attribute, Self::Output<NewAttr>: RenderHtml,

Adds an attribute to the view.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl AddAnyAttr for ()

type Output<SomeNewAttr: Attribute> = ()

fn add_any_attr<NewAttr>( self, _attr: NewAttr, ) -> <() as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute, <() as AddAnyAttr>::Output<NewAttr>: RenderHtml,

impl<'a> AddAnyAttr for &'a str

type Output<SomeNewAttr: Attribute> = &'a str

fn add_any_attr<NewAttr>( self, _attr: NewAttr, ) -> <&'a str as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute,

impl<'a> AddAnyAttr for Cow<'a, str>

type Output<SomeNewAttr: Attribute> = Cow<'a, str>

fn add_any_attr<NewAttr>( self, _attr: NewAttr, ) -> <Cow<'a, str> as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute,

impl<'a> AddAnyAttr for bool

type Output<SomeNewAttr: Attribute> = bool

fn add_any_attr<NewAttr>( self, _attr: NewAttr, ) -> <bool as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute,

impl<'a> AddAnyAttr for char

type Output<SomeNewAttr: Attribute> = char

fn add_any_attr<NewAttr>( self, _attr: NewAttr, ) -> <char as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute,

impl<'a> AddAnyAttr for f32

type Output<SomeNewAttr: Attribute> = f32

fn add_any_attr<NewAttr>( self, _attr: NewAttr, ) -> <f32 as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute,

impl<'a> AddAnyAttr for f64

type Output<SomeNewAttr: Attribute> = f64

fn add_any_attr<NewAttr>( self, _attr: NewAttr, ) -> <f64 as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute,

impl<'a> AddAnyAttr for i8

type Output<SomeNewAttr: Attribute> = i8

fn add_any_attr<NewAttr>( self, _attr: NewAttr, ) -> <i8 as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute,

impl<'a> AddAnyAttr for i16

type Output<SomeNewAttr: Attribute> = i16

fn add_any_attr<NewAttr>( self, _attr: NewAttr, ) -> <i16 as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute,

impl<'a> AddAnyAttr for i32

type Output<SomeNewAttr: Attribute> = i32

fn add_any_attr<NewAttr>( self, _attr: NewAttr, ) -> <i32 as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute,

impl<'a> AddAnyAttr for i64

type Output<SomeNewAttr: Attribute> = i64

fn add_any_attr<NewAttr>( self, _attr: NewAttr, ) -> <i64 as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute,

impl<'a> AddAnyAttr for i128

type Output<SomeNewAttr: Attribute> = i128

fn add_any_attr<NewAttr>( self, _attr: NewAttr, ) -> <i128 as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute,

impl<'a> AddAnyAttr for isize

type Output<SomeNewAttr: Attribute> = isize

fn add_any_attr<NewAttr>( self, _attr: NewAttr, ) -> <isize as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute,

impl<'a> AddAnyAttr for u8

type Output<SomeNewAttr: Attribute> = u8

fn add_any_attr<NewAttr>( self, _attr: NewAttr, ) -> <u8 as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute,

impl<'a> AddAnyAttr for u16

type Output<SomeNewAttr: Attribute> = u16

fn add_any_attr<NewAttr>( self, _attr: NewAttr, ) -> <u16 as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute,

impl<'a> AddAnyAttr for u32

type Output<SomeNewAttr: Attribute> = u32

fn add_any_attr<NewAttr>( self, _attr: NewAttr, ) -> <u32 as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute,

impl<'a> AddAnyAttr for u64

type Output<SomeNewAttr: Attribute> = u64

fn add_any_attr<NewAttr>( self, _attr: NewAttr, ) -> <u64 as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute,

impl<'a> AddAnyAttr for u128

type Output<SomeNewAttr: Attribute> = u128

fn add_any_attr<NewAttr>( self, _attr: NewAttr, ) -> <u128 as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute,

impl<'a> AddAnyAttr for usize

type Output<SomeNewAttr: Attribute> = usize

fn add_any_attr<NewAttr>( self, _attr: NewAttr, ) -> <usize as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute,

impl<'a> AddAnyAttr for String

type Output<SomeNewAttr: Attribute> = String

fn add_any_attr<NewAttr>( self, _attr: NewAttr, ) -> <String as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute,

impl<'a> AddAnyAttr for Arc<str>

type Output<SomeNewAttr: Attribute> = Arc<str>

fn add_any_attr<NewAttr>( self, _attr: NewAttr, ) -> <Arc<str> as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute,

impl<A> AddAnyAttr for (A,)

where A: AddAnyAttr,

type Output<SomeNewAttr: Attribute> = (<A as AddAnyAttr>::Output<SomeNewAttr>,)

fn add_any_attr<NewAttr>( self, attr: NewAttr, ) -> <(A,) as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute, <(A,) as AddAnyAttr>::Output<NewAttr>: RenderHtml,

impl<A, B> AddAnyAttr for (A, B)

where A: AddAnyAttr, B: AddAnyAttr,

type Output<SomeNewAttr: Attribute> = (<A as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <B as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>)

fn add_any_attr<NewAttr>( self, attr: NewAttr, ) -> <(A, B) as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute, <(A, B) as AddAnyAttr>::Output<NewAttr>: RenderHtml,

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

where A: RenderHtml, B: RenderHtml,

type Output<SomeNewAttr: Attribute> = Either<<A as AddAnyAttr>::Output<SomeNewAttr>, <B as AddAnyAttr>::Output<SomeNewAttr>>

fn add_any_attr<NewAttr>( self, attr: NewAttr, ) -> <Either<A, B> as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute, <Either<A, B> as AddAnyAttr>::Output<NewAttr>: RenderHtml,

impl<A, B, C> AddAnyAttr for (A, B, C)

where A: AddAnyAttr, B: AddAnyAttr, C: AddAnyAttr,

type Output<SomeNewAttr: Attribute> = (<A as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <B as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <C as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>)

fn add_any_attr<NewAttr>( self, attr: NewAttr, ) -> <(A, B, C) as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute, <(A, B, C) as AddAnyAttr>::Output<NewAttr>: RenderHtml,

impl<A, B, C> AddAnyAttr for EitherOf3<A, B, C>

where A: RenderHtml, B: RenderHtml, C: RenderHtml,

type Output<SomeNewAttr: Attribute> = EitherOf3<<A as AddAnyAttr>::Output<SomeNewAttr>, <B as AddAnyAttr>::Output<SomeNewAttr>, <C as AddAnyAttr>::Output<SomeNewAttr>>

fn add_any_attr<NewAttr>( self, attr: NewAttr, ) -> <EitherOf3<A, B, C> as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute, <EitherOf3<A, B, C> as AddAnyAttr>::Output<NewAttr>: RenderHtml,

impl<A, B, C, D> AddAnyAttr for (A, B, C, D)

where A: AddAnyAttr, B: AddAnyAttr, C: AddAnyAttr, D: AddAnyAttr,

type Output<SomeNewAttr: Attribute> = (<A as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <B as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <C as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <D as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>)

fn add_any_attr<NewAttr>( self, attr: NewAttr, ) -> <(A, B, C, D) as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute, <(A, B, C, D) as AddAnyAttr>::Output<NewAttr>: RenderHtml,

impl<A, B, C, D> AddAnyAttr for EitherOf4<A, B, C, D>

where A: RenderHtml, B: RenderHtml, C: RenderHtml, D: RenderHtml,

type Output<SomeNewAttr: Attribute> = EitherOf4<<A as AddAnyAttr>::Output<SomeNewAttr>, <B as AddAnyAttr>::Output<SomeNewAttr>, <C as AddAnyAttr>::Output<SomeNewAttr>, <D as AddAnyAttr>::Output<SomeNewAttr>>

fn add_any_attr<NewAttr>( self, attr: NewAttr, ) -> <EitherOf4<A, B, C, D> as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute, <EitherOf4<A, B, C, D> as AddAnyAttr>::Output<NewAttr>: RenderHtml,

impl<A, B, C, D, E> AddAnyAttr for (A, B, C, D, E)

where A: AddAnyAttr, B: AddAnyAttr, C: AddAnyAttr, D: AddAnyAttr, E: AddAnyAttr,

type Output<SomeNewAttr: Attribute> = (<A as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <B as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <C as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <D as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <E as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>)

fn add_any_attr<NewAttr>( self, attr: NewAttr, ) -> <(A, B, C, D, E) as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute, <(A, B, C, D, E) as AddAnyAttr>::Output<NewAttr>: RenderHtml,

impl<A, B, C, D, E> AddAnyAttr for EitherOf5<A, B, C, D, E>

where A: RenderHtml, B: RenderHtml, C: RenderHtml, D: RenderHtml, E: RenderHtml,

type Output<SomeNewAttr: Attribute> = EitherOf5<<A as AddAnyAttr>::Output<SomeNewAttr>, <B as AddAnyAttr>::Output<SomeNewAttr>, <C as AddAnyAttr>::Output<SomeNewAttr>, <D as AddAnyAttr>::Output<SomeNewAttr>, <E as AddAnyAttr>::Output<SomeNewAttr>>

fn add_any_attr<NewAttr>( self, attr: NewAttr, ) -> <EitherOf5<A, B, C, D, E> as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute, <EitherOf5<A, B, C, D, E> as AddAnyAttr>::Output<NewAttr>: RenderHtml,

impl<A, B, C, D, E, F> AddAnyAttr for (A, B, C, D, E, F)

where A: AddAnyAttr, B: AddAnyAttr, C: AddAnyAttr, D: AddAnyAttr, E: AddAnyAttr, F: AddAnyAttr,

type Output<SomeNewAttr: Attribute> = (<A as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <B as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <C as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <D as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <E as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <F as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>)

fn add_any_attr<NewAttr>( self, attr: NewAttr, ) -> <(A, B, C, D, E, F) as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute, <(A, B, C, D, E, F) as AddAnyAttr>::Output<NewAttr>: RenderHtml,

impl<A, B, C, D, E, F> AddAnyAttr for EitherOf6<A, B, C, D, E, F>

where A: RenderHtml, B: RenderHtml, C: RenderHtml, D: RenderHtml, E: RenderHtml, F: RenderHtml,

type Output<SomeNewAttr: Attribute> = EitherOf6<<A as AddAnyAttr>::Output<SomeNewAttr>, <B as AddAnyAttr>::Output<SomeNewAttr>, <C as AddAnyAttr>::Output<SomeNewAttr>, <D as AddAnyAttr>::Output<SomeNewAttr>, <E as AddAnyAttr>::Output<SomeNewAttr>, <F as AddAnyAttr>::Output<SomeNewAttr>>

fn add_any_attr<NewAttr>( self, attr: NewAttr, ) -> <EitherOf6<A, B, C, D, E, F> as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute, <EitherOf6<A, B, C, D, E, F> as AddAnyAttr>::Output<NewAttr>: RenderHtml,

impl<A, B, C, D, E, F, G> AddAnyAttr for (A, B, C, D, E, F, G)

where A: AddAnyAttr, B: AddAnyAttr, C: AddAnyAttr, D: AddAnyAttr, E: AddAnyAttr, F: AddAnyAttr, G: AddAnyAttr,

type Output<SomeNewAttr: Attribute> = (<A as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <B as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <C as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <D as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <E as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <F as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <G as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>)

fn add_any_attr<NewAttr>( self, attr: NewAttr, ) -> <(A, B, C, D, E, F, G) as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute, <(A, B, C, D, E, F, G) as AddAnyAttr>::Output<NewAttr>: RenderHtml,

impl<A, B, C, D, E, F, G> AddAnyAttr for EitherOf7<A, B, C, D, E, F, G>

where A: RenderHtml, B: RenderHtml, C: RenderHtml, D: RenderHtml, E: RenderHtml, F: RenderHtml, G: RenderHtml,

type Output<SomeNewAttr: Attribute> = EitherOf7<<A as AddAnyAttr>::Output<SomeNewAttr>, <B as AddAnyAttr>::Output<SomeNewAttr>, <C as AddAnyAttr>::Output<SomeNewAttr>, <D as AddAnyAttr>::Output<SomeNewAttr>, <E as AddAnyAttr>::Output<SomeNewAttr>, <F as AddAnyAttr>::Output<SomeNewAttr>, <G as AddAnyAttr>::Output<SomeNewAttr>>

fn add_any_attr<NewAttr>( self, attr: NewAttr, ) -> <EitherOf7<A, B, C, D, E, F, G> as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute, <EitherOf7<A, B, C, D, E, F, G> as AddAnyAttr>::Output<NewAttr>: RenderHtml,

impl<A, B, C, D, E, F, G, H> AddAnyAttr for (A, B, C, D, E, F, G, H)

where A: AddAnyAttr, B: AddAnyAttr, C: AddAnyAttr, D: AddAnyAttr, E: AddAnyAttr, F: AddAnyAttr, G: AddAnyAttr, H: AddAnyAttr,

type Output<SomeNewAttr: Attribute> = (<A as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <B as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <C as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <D as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <E as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <F as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <G as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <H as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>)

fn add_any_attr<NewAttr>( self, attr: NewAttr, ) -> <(A, B, C, D, E, F, G, H) as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute, <(A, B, C, D, E, F, G, H) as AddAnyAttr>::Output<NewAttr>: RenderHtml,

impl<A, B, C, D, E, F, G, H> AddAnyAttr for EitherOf8<A, B, C, D, E, F, G, H>

where A: RenderHtml, B: RenderHtml, C: RenderHtml, D: RenderHtml, E: RenderHtml, F: RenderHtml, G: RenderHtml, H: RenderHtml,

type Output<SomeNewAttr: Attribute> = EitherOf8<<A as AddAnyAttr>::Output<SomeNewAttr>, <B as AddAnyAttr>::Output<SomeNewAttr>, <C as AddAnyAttr>::Output<SomeNewAttr>, <D as AddAnyAttr>::Output<SomeNewAttr>, <E as AddAnyAttr>::Output<SomeNewAttr>, <F as AddAnyAttr>::Output<SomeNewAttr>, <G as AddAnyAttr>::Output<SomeNewAttr>, <H as AddAnyAttr>::Output<SomeNewAttr>>

fn add_any_attr<NewAttr>( self, attr: NewAttr, ) -> <EitherOf8<A, B, C, D, E, F, G, H> as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute, <EitherOf8<A, B, C, D, E, F, G, H> as AddAnyAttr>::Output<NewAttr>: RenderHtml,

impl<A, B, C, D, E, F, G, H, I> AddAnyAttr for (A, B, C, D, E, F, G, H, I)

where A: AddAnyAttr, B: AddAnyAttr, C: AddAnyAttr, D: AddAnyAttr, E: AddAnyAttr, F: AddAnyAttr, G: AddAnyAttr, H: AddAnyAttr, I: AddAnyAttr,

type Output<SomeNewAttr: Attribute> = (<A as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <B as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <C as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <D as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <E as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <F as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <G as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <H as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <I as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>)

fn add_any_attr<NewAttr>( self, attr: NewAttr, ) -> <(A, B, C, D, E, F, G, H, I) as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute, <(A, B, C, D, E, F, G, H, I) as AddAnyAttr>::Output<NewAttr>: RenderHtml,

impl<A, B, C, D, E, F, G, H, I> AddAnyAttr for EitherOf9<A, B, C, D, E, F, G, H, I>

where A: RenderHtml, B: RenderHtml, C: RenderHtml, D: RenderHtml, E: RenderHtml, F: RenderHtml, G: RenderHtml, H: RenderHtml, I: RenderHtml,

type Output<SomeNewAttr: Attribute> = EitherOf9<<A as AddAnyAttr>::Output<SomeNewAttr>, <B as AddAnyAttr>::Output<SomeNewAttr>, <C as AddAnyAttr>::Output<SomeNewAttr>, <D as AddAnyAttr>::Output<SomeNewAttr>, <E as AddAnyAttr>::Output<SomeNewAttr>, <F as AddAnyAttr>::Output<SomeNewAttr>, <G as AddAnyAttr>::Output<SomeNewAttr>, <H as AddAnyAttr>::Output<SomeNewAttr>, <I as AddAnyAttr>::Output<SomeNewAttr>>

fn add_any_attr<NewAttr>( self, attr: NewAttr, ) -> <EitherOf9<A, B, C, D, E, F, G, H, I> as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute, <EitherOf9<A, B, C, D, E, F, G, H, I> as AddAnyAttr>::Output<NewAttr>: RenderHtml,

impl<A, B, C, D, E, F, G, H, I, J> AddAnyAttr for (A, B, C, D, E, F, G, H, I, J)

where A: AddAnyAttr, B: AddAnyAttr, C: AddAnyAttr, D: AddAnyAttr, E: AddAnyAttr, F: AddAnyAttr, G: AddAnyAttr, H: AddAnyAttr, I: AddAnyAttr, J: AddAnyAttr,

type Output<SomeNewAttr: Attribute> = (<A as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <B as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <C as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <D as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <E as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <F as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <G as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <H as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <I as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <J as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>)

fn add_any_attr<NewAttr>( self, attr: NewAttr, ) -> <(A, B, C, D, E, F, G, H, I, J) as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute, <(A, B, C, D, E, F, G, H, I, J) as AddAnyAttr>::Output<NewAttr>: RenderHtml,

impl<A, B, C, D, E, F, G, H, I, J> AddAnyAttr for EitherOf10<A, B, C, D, E, F, G, H, I, J>

where A: RenderHtml, B: RenderHtml, C: RenderHtml, D: RenderHtml, E: RenderHtml, F: RenderHtml, G: RenderHtml, H: RenderHtml, I: RenderHtml, J: RenderHtml,

type Output<SomeNewAttr: Attribute> = EitherOf10<<A as AddAnyAttr>::Output<SomeNewAttr>, <B as AddAnyAttr>::Output<SomeNewAttr>, <C as AddAnyAttr>::Output<SomeNewAttr>, <D as AddAnyAttr>::Output<SomeNewAttr>, <E as AddAnyAttr>::Output<SomeNewAttr>, <F as AddAnyAttr>::Output<SomeNewAttr>, <G as AddAnyAttr>::Output<SomeNewAttr>, <H as AddAnyAttr>::Output<SomeNewAttr>, <I as AddAnyAttr>::Output<SomeNewAttr>, <J as AddAnyAttr>::Output<SomeNewAttr>>

fn add_any_attr<NewAttr>( self, attr: NewAttr, ) -> <EitherOf10<A, B, C, D, E, F, G, H, I, J> as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute, <EitherOf10<A, B, C, D, E, F, G, H, I, J> as AddAnyAttr>::Output<NewAttr>: RenderHtml,

impl<A, B, C, D, E, F, G, H, I, J, K> AddAnyAttr for (A, B, C, D, E, F, G, H, I, J, K)

where A: AddAnyAttr, B: AddAnyAttr, C: AddAnyAttr, D: AddAnyAttr, E: AddAnyAttr, F: AddAnyAttr, G: AddAnyAttr, H: AddAnyAttr, I: AddAnyAttr, J: AddAnyAttr, K: AddAnyAttr,

type Output<SomeNewAttr: Attribute> = (<A as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <B as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <C as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <D as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <E as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <F as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <G as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <H as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <I as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <J as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <K as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>)

fn add_any_attr<NewAttr>( self, attr: NewAttr, ) -> <(A, B, C, D, E, F, G, H, I, J, K) as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute, <(A, B, C, D, E, F, G, H, I, J, K) as AddAnyAttr>::Output<NewAttr>: RenderHtml,

impl<A, B, C, D, E, F, G, H, I, J, K> AddAnyAttr for EitherOf11<A, B, C, D, E, F, G, H, I, J, K>

where A: RenderHtml, B: RenderHtml, C: RenderHtml, D: RenderHtml, E: RenderHtml, F: RenderHtml, G: RenderHtml, H: RenderHtml, I: RenderHtml, J: RenderHtml, K: RenderHtml,

type Output<SomeNewAttr: Attribute> = EitherOf11<<A as AddAnyAttr>::Output<SomeNewAttr>, <B as AddAnyAttr>::Output<SomeNewAttr>, <C as AddAnyAttr>::Output<SomeNewAttr>, <D as AddAnyAttr>::Output<SomeNewAttr>, <E as AddAnyAttr>::Output<SomeNewAttr>, <F as AddAnyAttr>::Output<SomeNewAttr>, <G as AddAnyAttr>::Output<SomeNewAttr>, <H as AddAnyAttr>::Output<SomeNewAttr>, <I as AddAnyAttr>::Output<SomeNewAttr>, <J as AddAnyAttr>::Output<SomeNewAttr>, <K as AddAnyAttr>::Output<SomeNewAttr>>

fn add_any_attr<NewAttr>( self, attr: NewAttr, ) -> <EitherOf11<A, B, C, D, E, F, G, H, I, J, K> as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute, <EitherOf11<A, B, C, D, E, F, G, H, I, J, K> as AddAnyAttr>::Output<NewAttr>: RenderHtml,

impl<A, B, C, D, E, F, G, H, I, J, K, L> AddAnyAttr for (A, B, C, D, E, F, G, H, I, J, K, L)

where A: AddAnyAttr, B: AddAnyAttr, C: AddAnyAttr, D: AddAnyAttr, E: AddAnyAttr, F: AddAnyAttr, G: AddAnyAttr, H: AddAnyAttr, I: AddAnyAttr, J: AddAnyAttr, K: AddAnyAttr, L: AddAnyAttr,

type Output<SomeNewAttr: Attribute> = (<A as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <B as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <C as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <D as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <E as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <F as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <G as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <H as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <I as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <J as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <K as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <L as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>)

fn add_any_attr<NewAttr>( self, attr: NewAttr, ) -> <(A, B, C, D, E, F, G, H, I, J, K, L) as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute, <(A, B, C, D, E, F, G, H, I, J, K, L) as AddAnyAttr>::Output<NewAttr>: RenderHtml,

impl<A, B, C, D, E, F, G, H, I, J, K, L> AddAnyAttr for EitherOf12<A, B, C, D, E, F, G, H, I, J, K, L>

where A: RenderHtml, B: RenderHtml, C: RenderHtml, D: RenderHtml, E: RenderHtml, F: RenderHtml, G: RenderHtml, H: RenderHtml, I: RenderHtml, J: RenderHtml, K: RenderHtml, L: RenderHtml,

type Output<SomeNewAttr: Attribute> = EitherOf12<<A as AddAnyAttr>::Output<SomeNewAttr>, <B as AddAnyAttr>::Output<SomeNewAttr>, <C as AddAnyAttr>::Output<SomeNewAttr>, <D as AddAnyAttr>::Output<SomeNewAttr>, <E as AddAnyAttr>::Output<SomeNewAttr>, <F as AddAnyAttr>::Output<SomeNewAttr>, <G as AddAnyAttr>::Output<SomeNewAttr>, <H as AddAnyAttr>::Output<SomeNewAttr>, <I as AddAnyAttr>::Output<SomeNewAttr>, <J as AddAnyAttr>::Output<SomeNewAttr>, <K as AddAnyAttr>::Output<SomeNewAttr>, <L as AddAnyAttr>::Output<SomeNewAttr>>

fn add_any_attr<NewAttr>( self, attr: NewAttr, ) -> <EitherOf12<A, B, C, D, E, F, G, H, I, J, K, L> as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute, <EitherOf12<A, B, C, D, E, F, G, H, I, J, K, L> as AddAnyAttr>::Output<NewAttr>: RenderHtml,

impl<A, B, C, D, E, F, G, H, I, J, K, L, M> AddAnyAttr for (A, B, C, D, E, F, G, H, I, J, K, L, M)

where A: AddAnyAttr, B: AddAnyAttr, C: AddAnyAttr, D: AddAnyAttr, E: AddAnyAttr, F: AddAnyAttr, G: AddAnyAttr, H: AddAnyAttr, I: AddAnyAttr, J: AddAnyAttr, K: AddAnyAttr, L: AddAnyAttr, M: AddAnyAttr,

type Output<SomeNewAttr: Attribute> = (<A as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <B as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <C as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <D as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <E as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <F as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <G as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <H as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <I as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <J as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <K as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <L as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <M as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>)

fn add_any_attr<NewAttr>( self, attr: NewAttr, ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M) as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute, <(A, B, C, D, E, F, G, H, I, J, K, L, M) as AddAnyAttr>::Output<NewAttr>: RenderHtml,

impl<A, B, C, D, E, F, G, H, I, J, K, L, M> AddAnyAttr for EitherOf13<A, B, C, D, E, F, G, H, I, J, K, L, M>

where A: RenderHtml, B: RenderHtml, C: RenderHtml, D: RenderHtml, E: RenderHtml, F: RenderHtml, G: RenderHtml, H: RenderHtml, I: RenderHtml, J: RenderHtml, K: RenderHtml, L: RenderHtml, M: RenderHtml,

type Output<SomeNewAttr: Attribute> = EitherOf13<<A as AddAnyAttr>::Output<SomeNewAttr>, <B as AddAnyAttr>::Output<SomeNewAttr>, <C as AddAnyAttr>::Output<SomeNewAttr>, <D as AddAnyAttr>::Output<SomeNewAttr>, <E as AddAnyAttr>::Output<SomeNewAttr>, <F as AddAnyAttr>::Output<SomeNewAttr>, <G as AddAnyAttr>::Output<SomeNewAttr>, <H as AddAnyAttr>::Output<SomeNewAttr>, <I as AddAnyAttr>::Output<SomeNewAttr>, <J as AddAnyAttr>::Output<SomeNewAttr>, <K as AddAnyAttr>::Output<SomeNewAttr>, <L as AddAnyAttr>::Output<SomeNewAttr>, <M as AddAnyAttr>::Output<SomeNewAttr>>

fn add_any_attr<NewAttr>( self, attr: NewAttr, ) -> <EitherOf13<A, B, C, D, E, F, G, H, I, J, K, L, M> as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute, <EitherOf13<A, B, C, D, E, F, G, H, I, J, K, L, M> as AddAnyAttr>::Output<NewAttr>: RenderHtml,

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N> AddAnyAttr for (A, B, C, D, E, F, G, H, I, J, K, L, M, N)

where A: AddAnyAttr, B: AddAnyAttr, C: AddAnyAttr, D: AddAnyAttr, E: AddAnyAttr, F: AddAnyAttr, G: AddAnyAttr, H: AddAnyAttr, I: AddAnyAttr, J: AddAnyAttr, K: AddAnyAttr, L: AddAnyAttr, M: AddAnyAttr, N: AddAnyAttr,

type Output<SomeNewAttr: Attribute> = (<A as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <B as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <C as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <D as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <E as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <F as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <G as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <H as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <I as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <J as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <K as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <L as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <M as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <N as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>)

fn add_any_attr<NewAttr>( self, attr: NewAttr, ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N) as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute, <(A, B, C, D, E, F, G, H, I, J, K, L, M, N) as AddAnyAttr>::Output<NewAttr>: RenderHtml,

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N> AddAnyAttr for EitherOf14<A, B, C, D, E, F, G, H, I, J, K, L, M, N>

where A: RenderHtml, B: RenderHtml, C: RenderHtml, D: RenderHtml, E: RenderHtml, F: RenderHtml, G: RenderHtml, H: RenderHtml, I: RenderHtml, J: RenderHtml, K: RenderHtml, L: RenderHtml, M: RenderHtml, N: RenderHtml,

type Output<SomeNewAttr: Attribute> = EitherOf14<<A as AddAnyAttr>::Output<SomeNewAttr>, <B as AddAnyAttr>::Output<SomeNewAttr>, <C as AddAnyAttr>::Output<SomeNewAttr>, <D as AddAnyAttr>::Output<SomeNewAttr>, <E as AddAnyAttr>::Output<SomeNewAttr>, <F as AddAnyAttr>::Output<SomeNewAttr>, <G as AddAnyAttr>::Output<SomeNewAttr>, <H as AddAnyAttr>::Output<SomeNewAttr>, <I as AddAnyAttr>::Output<SomeNewAttr>, <J as AddAnyAttr>::Output<SomeNewAttr>, <K as AddAnyAttr>::Output<SomeNewAttr>, <L as AddAnyAttr>::Output<SomeNewAttr>, <M as AddAnyAttr>::Output<SomeNewAttr>, <N as AddAnyAttr>::Output<SomeNewAttr>>

fn add_any_attr<NewAttr>( self, attr: NewAttr, ) -> <EitherOf14<A, B, C, D, E, F, G, H, I, J, K, L, M, N> as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute, <EitherOf14<A, B, C, D, E, F, G, H, I, J, K, L, M, N> as AddAnyAttr>::Output<NewAttr>: RenderHtml,

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> AddAnyAttr for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)

where A: AddAnyAttr, B: AddAnyAttr, C: AddAnyAttr, D: AddAnyAttr, E: AddAnyAttr, F: AddAnyAttr, G: AddAnyAttr, H: AddAnyAttr, I: AddAnyAttr, J: AddAnyAttr, K: AddAnyAttr, L: AddAnyAttr, M: AddAnyAttr, N: AddAnyAttr, O: AddAnyAttr,

type Output<SomeNewAttr: Attribute> = (<A as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <B as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <C as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <D as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <E as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <F as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <G as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <H as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <I as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <J as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <K as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <L as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <M as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <N as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <O as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>)

fn add_any_attr<NewAttr>( self, attr: NewAttr, ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute, <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) as AddAnyAttr>::Output<NewAttr>: RenderHtml,

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> AddAnyAttr for EitherOf15<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>

where A: RenderHtml, B: RenderHtml, C: RenderHtml, D: RenderHtml, E: RenderHtml, F: RenderHtml, G: RenderHtml, H: RenderHtml, I: RenderHtml, J: RenderHtml, K: RenderHtml, L: RenderHtml, M: RenderHtml, N: RenderHtml, O: RenderHtml,

type Output<SomeNewAttr: Attribute> = EitherOf15<<A as AddAnyAttr>::Output<SomeNewAttr>, <B as AddAnyAttr>::Output<SomeNewAttr>, <C as AddAnyAttr>::Output<SomeNewAttr>, <D as AddAnyAttr>::Output<SomeNewAttr>, <E as AddAnyAttr>::Output<SomeNewAttr>, <F as AddAnyAttr>::Output<SomeNewAttr>, <G as AddAnyAttr>::Output<SomeNewAttr>, <H as AddAnyAttr>::Output<SomeNewAttr>, <I as AddAnyAttr>::Output<SomeNewAttr>, <J as AddAnyAttr>::Output<SomeNewAttr>, <K as AddAnyAttr>::Output<SomeNewAttr>, <L as AddAnyAttr>::Output<SomeNewAttr>, <M as AddAnyAttr>::Output<SomeNewAttr>, <N as AddAnyAttr>::Output<SomeNewAttr>, <O as AddAnyAttr>::Output<SomeNewAttr>>

fn add_any_attr<NewAttr>( self, attr: NewAttr, ) -> <EitherOf15<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute, <EitherOf15<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> as AddAnyAttr>::Output<NewAttr>: RenderHtml,

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> AddAnyAttr for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)

where A: AddAnyAttr, B: AddAnyAttr, C: AddAnyAttr, D: AddAnyAttr, E: AddAnyAttr, F: AddAnyAttr, G: AddAnyAttr, H: AddAnyAttr, I: AddAnyAttr, J: AddAnyAttr, K: AddAnyAttr, L: AddAnyAttr, M: AddAnyAttr, N: AddAnyAttr, O: AddAnyAttr, P: AddAnyAttr,

type Output<SomeNewAttr: Attribute> = (<A as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <B as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <C as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <D as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <E as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <F as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <G as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <H as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <I as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <J as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <K as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <L as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <M as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <N as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <O as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <P as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>)

fn add_any_attr<NewAttr>( self, attr: NewAttr, ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute, <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) as AddAnyAttr>::Output<NewAttr>: RenderHtml,

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> AddAnyAttr for EitherOf16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>

where A: RenderHtml, B: RenderHtml, C: RenderHtml, D: RenderHtml, E: RenderHtml, F: RenderHtml, G: RenderHtml, H: RenderHtml, I: RenderHtml, J: RenderHtml, K: RenderHtml, L: RenderHtml, M: RenderHtml, N: RenderHtml, O: RenderHtml, P: RenderHtml,

type Output<SomeNewAttr: Attribute> = EitherOf16<<A as AddAnyAttr>::Output<SomeNewAttr>, <B as AddAnyAttr>::Output<SomeNewAttr>, <C as AddAnyAttr>::Output<SomeNewAttr>, <D as AddAnyAttr>::Output<SomeNewAttr>, <E as AddAnyAttr>::Output<SomeNewAttr>, <F as AddAnyAttr>::Output<SomeNewAttr>, <G as AddAnyAttr>::Output<SomeNewAttr>, <H as AddAnyAttr>::Output<SomeNewAttr>, <I as AddAnyAttr>::Output<SomeNewAttr>, <J as AddAnyAttr>::Output<SomeNewAttr>, <K as AddAnyAttr>::Output<SomeNewAttr>, <L as AddAnyAttr>::Output<SomeNewAttr>, <M as AddAnyAttr>::Output<SomeNewAttr>, <N as AddAnyAttr>::Output<SomeNewAttr>, <O as AddAnyAttr>::Output<SomeNewAttr>, <P as AddAnyAttr>::Output<SomeNewAttr>>

fn add_any_attr<NewAttr>( self, attr: NewAttr, ) -> <EitherOf16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute, <EitherOf16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> as AddAnyAttr>::Output<NewAttr>: RenderHtml,

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> AddAnyAttr for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)

where A: AddAnyAttr, B: AddAnyAttr, C: AddAnyAttr, D: AddAnyAttr, E: AddAnyAttr, F: AddAnyAttr, G: AddAnyAttr, H: AddAnyAttr, I: AddAnyAttr, J: AddAnyAttr, K: AddAnyAttr, L: AddAnyAttr, M: AddAnyAttr, N: AddAnyAttr, O: AddAnyAttr, P: AddAnyAttr, Q: AddAnyAttr,

type Output<SomeNewAttr: Attribute> = (<A as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <B as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <C as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <D as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <E as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <F as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <G as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <H as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <I as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <J as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <K as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <L as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <M as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <N as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <O as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <P as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <Q as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>)

fn add_any_attr<NewAttr>( self, attr: NewAttr, ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute, <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) as AddAnyAttr>::Output<NewAttr>: RenderHtml,

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R> AddAnyAttr for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)

where A: AddAnyAttr, B: AddAnyAttr, C: AddAnyAttr, D: AddAnyAttr, E: AddAnyAttr, F: AddAnyAttr, G: AddAnyAttr, H: AddAnyAttr, I: AddAnyAttr, J: AddAnyAttr, K: AddAnyAttr, L: AddAnyAttr, M: AddAnyAttr, N: AddAnyAttr, O: AddAnyAttr, P: AddAnyAttr, Q: AddAnyAttr, R: AddAnyAttr,

type Output<SomeNewAttr: Attribute> = (<A as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <B as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <C as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <D as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <E as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <F as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <G as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <H as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <I as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <J as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <K as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <L as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <M as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <N as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <O as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <P as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <Q as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <R as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>)

fn add_any_attr<NewAttr>( self, attr: NewAttr, ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute, <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) as AddAnyAttr>::Output<NewAttr>: RenderHtml,

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S> AddAnyAttr for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)

where A: AddAnyAttr, B: AddAnyAttr, C: AddAnyAttr, D: AddAnyAttr, E: AddAnyAttr, F: AddAnyAttr, G: AddAnyAttr, H: AddAnyAttr, I: AddAnyAttr, J: AddAnyAttr, K: AddAnyAttr, L: AddAnyAttr, M: AddAnyAttr, N: AddAnyAttr, O: AddAnyAttr, P: AddAnyAttr, Q: AddAnyAttr, R: AddAnyAttr, S: AddAnyAttr,

type Output<SomeNewAttr: Attribute> = (<A as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <B as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <C as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <D as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <E as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <F as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <G as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <H as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <I as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <J as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <K as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <L as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <M as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <N as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <O as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <P as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <Q as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <R as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <S as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>)

fn add_any_attr<NewAttr>( self, attr: NewAttr, ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute, <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) as AddAnyAttr>::Output<NewAttr>: RenderHtml,

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> AddAnyAttr for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

where A: AddAnyAttr, B: AddAnyAttr, C: AddAnyAttr, D: AddAnyAttr, E: AddAnyAttr, F: AddAnyAttr, G: AddAnyAttr, H: AddAnyAttr, I: AddAnyAttr, J: AddAnyAttr, K: AddAnyAttr, L: AddAnyAttr, M: AddAnyAttr, N: AddAnyAttr, O: AddAnyAttr, P: AddAnyAttr, Q: AddAnyAttr, R: AddAnyAttr, S: AddAnyAttr, T: AddAnyAttr,

type Output<SomeNewAttr: Attribute> = (<A as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <B as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <C as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <D as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <E as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <F as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <G as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <H as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <I as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <J as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <K as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <L as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <M as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <N as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <O as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <P as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <Q as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <R as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <S as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <T as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>)

fn add_any_attr<NewAttr>( self, attr: NewAttr, ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute, <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) as AddAnyAttr>::Output<NewAttr>: RenderHtml,

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U> AddAnyAttr for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)

where A: AddAnyAttr, B: AddAnyAttr, C: AddAnyAttr, D: AddAnyAttr, E: AddAnyAttr, F: AddAnyAttr, G: AddAnyAttr, H: AddAnyAttr, I: AddAnyAttr, J: AddAnyAttr, K: AddAnyAttr, L: AddAnyAttr, M: AddAnyAttr, N: AddAnyAttr, O: AddAnyAttr, P: AddAnyAttr, Q: AddAnyAttr, R: AddAnyAttr, S: AddAnyAttr, T: AddAnyAttr, U: AddAnyAttr,

type Output<SomeNewAttr: Attribute> = (<A as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <B as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <C as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <D as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <E as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <F as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <G as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <H as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <I as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <J as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <K as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <L as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <M as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <N as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <O as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <P as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <Q as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <R as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <S as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <T as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <U as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>)

fn add_any_attr<NewAttr>( self, attr: NewAttr, ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute, <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) as AddAnyAttr>::Output<NewAttr>: RenderHtml,

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V> AddAnyAttr for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)

where A: AddAnyAttr, B: AddAnyAttr, C: AddAnyAttr, D: AddAnyAttr, E: AddAnyAttr, F: AddAnyAttr, G: AddAnyAttr, H: AddAnyAttr, I: AddAnyAttr, J: AddAnyAttr, K: AddAnyAttr, L: AddAnyAttr, M: AddAnyAttr, N: AddAnyAttr, O: AddAnyAttr, P: AddAnyAttr, Q: AddAnyAttr, R: AddAnyAttr, S: AddAnyAttr, T: AddAnyAttr, U: AddAnyAttr, V: AddAnyAttr,

type Output<SomeNewAttr: Attribute> = (<A as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <B as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <C as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <D as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <E as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <F as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <G as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <H as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <I as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <J as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <K as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <L as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <M as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <N as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <O as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <P as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <Q as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <R as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <S as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <T as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <U as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <V as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>)

fn add_any_attr<NewAttr>( self, attr: NewAttr, ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute, <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) as AddAnyAttr>::Output<NewAttr>: RenderHtml,

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W> AddAnyAttr for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)

where A: AddAnyAttr, B: AddAnyAttr, C: AddAnyAttr, D: AddAnyAttr, E: AddAnyAttr, F: AddAnyAttr, G: AddAnyAttr, H: AddAnyAttr, I: AddAnyAttr, J: AddAnyAttr, K: AddAnyAttr, L: AddAnyAttr, M: AddAnyAttr, N: AddAnyAttr, O: AddAnyAttr, P: AddAnyAttr, Q: AddAnyAttr, R: AddAnyAttr, S: AddAnyAttr, T: AddAnyAttr, U: AddAnyAttr, V: AddAnyAttr, W: AddAnyAttr,

type Output<SomeNewAttr: Attribute> = (<A as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <B as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <C as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <D as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <E as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <F as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <G as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <H as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <I as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <J as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <K as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <L as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <M as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <N as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <O as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <P as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <Q as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <R as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <S as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <T as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <U as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <V as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <W as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>)

fn add_any_attr<NewAttr>( self, attr: NewAttr, ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W) as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute, <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W) as AddAnyAttr>::Output<NewAttr>: RenderHtml,

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X> AddAnyAttr for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)

where A: AddAnyAttr, B: AddAnyAttr, C: AddAnyAttr, D: AddAnyAttr, E: AddAnyAttr, F: AddAnyAttr, G: AddAnyAttr, H: AddAnyAttr, I: AddAnyAttr, J: AddAnyAttr, K: AddAnyAttr, L: AddAnyAttr, M: AddAnyAttr, N: AddAnyAttr, O: AddAnyAttr, P: AddAnyAttr, Q: AddAnyAttr, R: AddAnyAttr, S: AddAnyAttr, T: AddAnyAttr, U: AddAnyAttr, V: AddAnyAttr, W: AddAnyAttr, X: AddAnyAttr,

type Output<SomeNewAttr: Attribute> = (<A as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <B as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <C as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <D as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <E as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <F as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <G as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <H as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <I as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <J as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <K as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <L as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <M as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <N as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <O as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <P as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <Q as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <R as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <S as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <T as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <U as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <V as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <W as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <X as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>)

fn add_any_attr<NewAttr>( self, attr: NewAttr, ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X) as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute, <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X) as AddAnyAttr>::Output<NewAttr>: RenderHtml,

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y> AddAnyAttr for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)

where A: AddAnyAttr, B: AddAnyAttr, C: AddAnyAttr, D: AddAnyAttr, E: AddAnyAttr, F: AddAnyAttr, G: AddAnyAttr, H: AddAnyAttr, I: AddAnyAttr, J: AddAnyAttr, K: AddAnyAttr, L: AddAnyAttr, M: AddAnyAttr, N: AddAnyAttr, O: AddAnyAttr, P: AddAnyAttr, Q: AddAnyAttr, R: AddAnyAttr, S: AddAnyAttr, T: AddAnyAttr, U: AddAnyAttr, V: AddAnyAttr, W: AddAnyAttr, X: AddAnyAttr, Y: AddAnyAttr,

type Output<SomeNewAttr: Attribute> = (<A as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <B as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <C as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <D as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <E as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <F as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <G as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <H as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <I as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <J as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <K as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <L as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <M as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <N as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <O as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <P as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <Q as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <R as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <S as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <T as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <U as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <V as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <W as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <X as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <Y as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>)

fn add_any_attr<NewAttr>( self, attr: NewAttr, ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y) as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute, <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y) as AddAnyAttr>::Output<NewAttr>: RenderHtml,

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> AddAnyAttr for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)

where A: AddAnyAttr, B: AddAnyAttr, C: AddAnyAttr, D: AddAnyAttr, E: AddAnyAttr, F: AddAnyAttr, G: AddAnyAttr, H: AddAnyAttr, I: AddAnyAttr, J: AddAnyAttr, K: AddAnyAttr, L: AddAnyAttr, M: AddAnyAttr, N: AddAnyAttr, O: AddAnyAttr, P: AddAnyAttr, Q: AddAnyAttr, R: AddAnyAttr, S: AddAnyAttr, T: AddAnyAttr, U: AddAnyAttr, V: AddAnyAttr, W: AddAnyAttr, X: AddAnyAttr, Y: AddAnyAttr, Z: AddAnyAttr,

type Output<SomeNewAttr: Attribute> = (<A as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <B as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <C as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <D as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <E as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <F as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <G as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <H as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <I as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <J as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <K as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <L as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <M as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <N as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <O as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <P as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <Q as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <R as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <S as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <T as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <U as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <V as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <W as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <X as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <Y as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <Z as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>)

fn add_any_attr<NewAttr>( self, attr: NewAttr, ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute, <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) as AddAnyAttr>::Output<NewAttr>: RenderHtml,

impl<Inner, Prev> AddAnyAttr for AtIndex<Inner, Prev>

where <Prev as Index<usize>>::Output: RenderHtml + Clone + Send + Sync + 'static, <<Prev as Index<usize>>::Output as Render>::State: 'static, AtIndex<Inner, Prev>: Get<Value = <Prev as Index<usize>>::Output>, Prev: Send + Sync + IndexMut<usize> + 'static, Inner: Send + Sync + Clone + 'static,

type Output<SomeNewAttr: Attribute> = AtIndex<Inner, Prev>

fn add_any_attr<NewAttr>( self, _attr: NewAttr, ) -> <AtIndex<Inner, Prev> as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute,

impl<Inner, Prev, K, V> AddAnyAttr for AtKeyed<Inner, Prev, K, V>

where V: RenderHtml + Clone + Send + Sync + 'static, <V as Render>::State: 'static, AtKeyed<Inner, Prev, K, V>: Get<Value = V>, Prev: Send + Sync + 'static, Inner: Send + Sync + Clone + 'static, K: Send + Sync + Debug + Clone + 'static, &'a V: for<'a> IntoIterator,

type Output<SomeNewAttr: Attribute> = AtKeyed<Inner, Prev, K, V>

fn add_any_attr<NewAttr>( self, _attr: NewAttr, ) -> <AtKeyed<Inner, Prev, K, V> as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute,

impl<Inner, Prev, K, V> AddAnyAttr for KeyedSubfield<Inner, Prev, K, V>

where V: RenderHtml + Clone + Send + Sync + 'static, <V as Render>::State: 'static, KeyedSubfield<Inner, Prev, K, V>: Get<Value = V>, Prev: Send + Sync + 'static, Inner: Send + Sync + Clone + 'static, K: Send + Sync + Debug + Clone + 'static, &'a V: for<'a> IntoIterator,

type Output<SomeNewAttr: Attribute> = KeyedSubfield<Inner, Prev, K, V>

fn add_any_attr<NewAttr>( self, _attr: NewAttr, ) -> <KeyedSubfield<Inner, Prev, K, V> as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute,

impl<Inner, Prev, V> AddAnyAttr for Subfield<Inner, Prev, V>

where V: RenderHtml + Clone + Send + Sync + 'static, <V as Render>::State: 'static, Subfield<Inner, Prev, V>: Get<Value = V>, Prev: Send + Sync + 'static, Inner: Send + Sync + Clone + 'static,

type Output<SomeNewAttr: Attribute> = Subfield<Inner, Prev, V>

fn add_any_attr<NewAttr>( self, _attr: NewAttr, ) -> <Subfield<Inner, Prev, V> as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute,

impl<S> AddAnyAttr for DerefedField<S>

where <<S as StoreField>::Value as Deref>::Target: RenderHtml + Clone + Send + Sync + 'static, <<<S as StoreField>::Value as Deref>::Target as Render>::State: 'static, S: Clone + StoreField + Send + Sync + 'static, <S as StoreField>::Value: Deref + DerefMut,

type Output<SomeNewAttr: Attribute> = DerefedField<S>

fn add_any_attr<NewAttr>( self, _attr: NewAttr, ) -> <DerefedField<S> as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute,

impl<T> AddAnyAttr for Vec<T>

where T: AddAnyAttr,

type Output<SomeNewAttr: Attribute> = Vec<<T as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>>

fn add_any_attr<NewAttr>( self, attr: NewAttr, ) -> <Vec<T> as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute, <Vec<T> as AddAnyAttr>::Output<NewAttr>: RenderHtml,

impl<T, const N: usize> AddAnyAttr for [T; N]

where T: AddAnyAttr,

type Output<SomeNewAttr: Attribute> = [<T as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>; N]

fn add_any_attr<NewAttr>( self, attr: NewAttr, ) -> <[T; N] as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute, <[T; N] as AddAnyAttr>::Output<NewAttr>: RenderHtml,

impl<V> AddAnyAttr for ArcField<V>

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

type Output<SomeNewAttr: Attribute> = ArcField<V>

fn add_any_attr<NewAttr>( self, _attr: NewAttr, ) -> <ArcField<V> as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute,

impl<V> AddAnyAttr for ArcStore<V>

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

type Output<SomeNewAttr: Attribute> = ArcStore<V>

fn add_any_attr<NewAttr>( self, _attr: NewAttr, ) -> <ArcStore<V> as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute,

impl<V, S> AddAnyAttr for Field<V, S>

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

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

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

where NewAttr: Attribute,

impl<V, S> AddAnyAttr for Store<V, S>

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

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

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

where NewAttr: Attribute,

Implementors

impl AddAnyAttr for AnyView

type Output<SomeNewAttr: Attribute> = AnyViewWithAttrs

impl AddAnyAttr for AnyViewWithAttrs

type Output<SomeNewAttr: Attribute> = AnyViewWithAttrs

impl AddAnyAttr for InertElement

type Output<SomeNewAttr: Attribute> = InertElement

impl AddAnyAttr for InertElement

type Output<SomeNewAttr: Attribute> = InertElement

impl<'a> AddAnyAttr for Oco<'static, str>

type Output<SomeNewAttr: Attribute> = Oco<'static, str>

impl<'a> AddAnyAttr for IpAddr

type Output<SomeNewAttr: Attribute> = IpAddr

impl<'a> AddAnyAttr for SocketAddr

type Output<SomeNewAttr: Attribute> = SocketAddr

impl<'a> AddAnyAttr for Ipv4Addr

type Output<SomeNewAttr: Attribute> = Ipv4Addr

impl<'a> AddAnyAttr for Ipv6Addr

type Output<SomeNewAttr: Attribute> = Ipv6Addr

impl<'a> AddAnyAttr for SocketAddrV4

type Output<SomeNewAttr: Attribute> = SocketAddrV4

impl<'a> AddAnyAttr for SocketAddrV6

type Output<SomeNewAttr: Attribute> = SocketAddrV6

impl<'a> AddAnyAttr for NonZero<i8>

type Output<SomeNewAttr: Attribute> = NonZero<i8>

impl<'a> AddAnyAttr for NonZero<i16>

type Output<SomeNewAttr: Attribute> = NonZero<i16>

impl<'a> AddAnyAttr for NonZero<i32>

type Output<SomeNewAttr: Attribute> = NonZero<i32>

impl<'a> AddAnyAttr for NonZero<i64>

type Output<SomeNewAttr: Attribute> = NonZero<i64>

impl<'a> AddAnyAttr for NonZero<i128>

type Output<SomeNewAttr: Attribute> = NonZero<i128>

impl<'a> AddAnyAttr for NonZero<isize>

type Output<SomeNewAttr: Attribute> = NonZero<isize>

impl<'a> AddAnyAttr for NonZero<u8>

type Output<SomeNewAttr: Attribute> = NonZero<u8>

impl<'a> AddAnyAttr for NonZero<u16>

type Output<SomeNewAttr: Attribute> = NonZero<u16>

impl<'a> AddAnyAttr for NonZero<u32>

type Output<SomeNewAttr: Attribute> = NonZero<u32>

impl<'a> AddAnyAttr for NonZero<u64>

type Output<SomeNewAttr: Attribute> = NonZero<u64>

impl<'a> AddAnyAttr for NonZero<u128>

type Output<SomeNewAttr: Attribute> = NonZero<u128>

impl<'a> AddAnyAttr for NonZero<usize>

type Output<SomeNewAttr: Attribute> = NonZero<usize>

impl<'a> AddAnyAttr for Doctype

type Output<SomeNewAttr: Attribute> = Doctype

impl<A, B> AddAnyAttr for EitherKeepAlive<A, B>

where A: RenderHtml, B: RenderHtml,

type Output<SomeNewAttr: Attribute> = EitherKeepAlive<<A as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>, <B as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>>

impl<E, At, Ch> AddAnyAttr for HtmlElement<E, At, Ch>

where E: ElementType + Send, At: Attribute + Send, Ch: RenderHtml + Send,

type Output<SomeNewAttr: Attribute> = HtmlElement<E, <At as NextAttribute>::Output<SomeNewAttr>, Ch>

impl<F, V> AddAnyAttr for F

where F: ReactiveFunction<Output = V>, V: RenderHtml + 'static,

type Output<SomeNewAttr: Attribute> = Box<dyn FnMut() -> <V as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::CloneableOwned> + Send>

impl<T> AddAnyAttr for Option<T>

where T: AddAnyAttr,

type Output<SomeNewAttr: Attribute> = Option<<T as AddAnyAttr>::Output<SomeNewAttr>>

impl<T> AddAnyAttr for Suspend<T>

where T: Send + AddAnyAttr + 'static,

type Output<SomeNewAttr: Attribute> = Suspend<<T as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::CloneableOwned>>

impl<T> AddAnyAttr for Unsuspend<T>

where T: AddAnyAttr + 'static,

type Output<SomeNewAttr: Attribute> = Unsuspend<<T as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::CloneableOwned>>

impl<T> AddAnyAttr for View<T>

where T: AddAnyAttr,

type Output<SomeNewAttr: Attribute> = View<<T as AddAnyAttr>::Output<SomeNewAttr>>

impl<T> AddAnyAttr for OwnedView<T>

where T: AddAnyAttr,

type Output<SomeNewAttr: Attribute> = OwnedView<<T as AddAnyAttr>::Output<SomeNewAttr>>

impl<T> AddAnyAttr for StaticVec<T>

where T: AddAnyAttr,

type Output<SomeNewAttr: Attribute> = StaticVec<<T as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::Cloneable>>

impl<T, E> AddAnyAttr for Result<T, E>

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

type Output<SomeNewAttr: Attribute> = Result<<T as AddAnyAttr>::Output<SomeNewAttr>, E>

impl<T, I, K, KF, VF, VFS, V> AddAnyAttr for Keyed<T, I, K, KF, VF, VFS, V>

where I: IntoIterator<Item = T> + Send + 'static, K: Eq + Hash + SerializableKey + 'static, KF: Fn(&T) -> K + Send + 'static, V: RenderHtml + 'static, VF: Fn(usize, T) -> (VFS, V) + Send + 'static, VFS: Fn(usize) + 'static, T: 'static,

type Output<SomeNewAttr: Attribute> = Keyed<T, I, K, KF, Box<dyn Fn(usize, T) -> (VFS, <V as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::CloneableOwned>) + Send>, VFS, <V as AddAnyAttr>::Output<<SomeNewAttr as Attribute>::CloneableOwned>>

impl<T, Ser> AddAnyAttr for Resource<T, Ser>

where T: RenderHtml + Send + Sync + Clone, Ser: Send + 'static,

type Output<SomeNewAttr: Attribute> = Box<dyn FnMut() -> Suspend<<T as AddAnyAttr>::Output<<<SomeNewAttr as Attribute>::CloneableOwned as Attribute>::CloneableOwned>> + Send>

impl<V> AddAnyAttr for ViewTemplate<V>

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

type Output<SomeNewAttr: Attribute> = ViewTemplate<V>

impl<View> AddAnyAttr for Island<View>

where View: RenderHtml,

type Output<SomeNewAttr: Attribute> = Island<<View as AddAnyAttr>::Output<SomeNewAttr>>

impl<View> AddAnyAttr for IslandChildren<View>

where View: RenderHtml,

type Output<SomeNewAttr: Attribute> = IslandChildren<<View as AddAnyAttr>::Output<SomeNewAttr>>

impl<const V: &'static str> AddAnyAttr for Static<V>

type Output<NewAttr: Attribute> = Static<V>