AttrValue::Owned != AttrValue::Static

[mibes]

Hi,

A quick question. When comparing AttrValue::Owned with AttrValue::Static with the same inner value, a.as_ref() == b.as_ref(), but a != b. Is this the expected behaviour, or should both be considered equal?

#[cfg(test)]
mod tests {
    use yew::virtual_dom::AttrValue;

    #[test]
    fn test_eq() {
        let a = AttrValue::Owned("same".to_string());
        let b = AttrValue::Static("same");
        assert_eq!(a.as_ref(), b.as_ref()); // <- equals
        assert_eq!(a, b) // <- does not equal
    }
}

[voidpumpkin]

Looks to me like in a.as_ref() == b.as_ref() you do a &str == &str compare
And in a != b String == &str, its different data types right?

[mibes]

Correct. What I wonder is the following. The AttrValue is often used as a property. If a component gets updated with a new AttrValue-variant, containing the same value, would you consider that for a re-render?

        // first render
        let use_language: Option<String> = None;
        let _use_lang_attr = match use_language {
            Some(s) => AttrValue::Owned(s),
            None => AttrValue::Static("en"),
        };

        // update
        let use_language: Option<String> = Some("en".to_string());
        let _use_lang_attr = match use_language {
            Some(s) => AttrValue::Owned(s),
            None => AttrValue::Static("en"),
        };

[voidpumpkin]

Im not that familiar with yew-macros. Does anything change for the end user? Do people actually use AttrValue enum directly when building yew applications? Or the state is Option<String> like you showed?

[voidpumpkin]

Im just going to jump out of this discussion, im just not that familiar with yew-macros.
Perhaps other maintainers will have answers

[mibes]

Not sure if this helps. In previous yew releases AttrValue was an alias for Cow<str>, as far as I know.
In comparison Cow equality is irrespective of the value being owned or borrowed:

    #[test]
    fn test_cow_eq() {
        let a: Cow<str> = Cow::Owned("same".to_string());
        let b: Cow<str> = Cow::Borrowed("same");
        assert_eq!(a.as_ref(), b.as_ref()); // <- equals
        assert_eq!(a, b) // <- also equals
    }

[ranile]

In comparison Cow equality is irrespective of the value being owned or borrowed:

That's how it should be here. If it isn't that's a bug (please file an issue)

The macro constructs AttrValue by using the From implementation. If comparison of different varients returns false, that might lead to unexpected re-renders.

I'm not sure why that is happening. attr_value.as_ref() should just return a &str and the comparison will be between &str and &str`.

Here's the relevant code if you want to take a look.

I misunderstood, see my other reply (#2159 (comment))

[ranile]

The Cow type implements PartialEq manually to account for different variations, AttrValue doesn't (it derives it). That's why this problem occurs. Manually implementing PartialEq should solve this issue