What if VText.value / AttributeValue::Text were Cow<'static, str> instead of String?

[EndilWayfare]

I find there are many cases where a "dynamic" value isn't "potentially any arbitrary string" but rather "generally or always one of a finite number of strings known at compile-time."

For example,

#[component]
pub fn Status(succeeded: ReadOnlySignal<bool>, children: Element) -> Element {
    let class;
    let name;

    if *succeeded.read() {
        class = "is-success";
        name = "check";
    } else {
        class = "is-error";
        name = "x";
    }

    rsx! {
        span { class,
            Icon { name: icon }
            span {
                {children}
            }
        }
    }
}

The icon and class can change at runtime and/or be different among multiple instantiations of this component, but there's never any reason for them to be heap-allocated strings. Certainly not before they cross the javascript threshold into DOM land, which likely would involve at least one clone even if they were Strings already.

Quick Aside:
I am, personally, a massive stickler about unnecessary allocations. I know this about myself. Even in cases where there wouldn't (immediately? in the current usage?) be a perceptible performance impact, it still feels like the Right Thing to Do™️.
The time when it's not the right thing to do is (always) when it actually causes a direct or indirect performance degradation or (generally) when it's unnecessarily complex and/or convoluted (especially w.r.t. everyday ergonomics).
I'm still trying to develop a mature sense for when those times are, but that's where I'm coming from.

Even in cases where it resolves to a static value that is only rendered once and never re-evaluated, I'm allergic to "static str".to_string().

Likely Implies Prop-Passing Improvement

Since it would then be a "first tier" core library type.

type CowStr = Cow<'static, str>;

#[derive(Clone, PartialEq)]
#[derive(Props)]
pub struct IconProps {
    #[props(into)]
    name: CowStr,
    #[props(into)]
    class: Option<CowStr>,
}

rsx! {
    span { class: "tag",
        Icon { name: icon }
        span { "Regular Icon" }
    }
    span { class: "tag",
        Icon {
            name: icon, // works
            // class: "is-small", // naughty
            class: Cow::from("is-small") // works but makes me sad
        }
        span { "Small Icon" }
    }
}

But, even with no change to nodes/attributes, I would really like to have this props thing 😈

[JustSimplyKyle]

#2308