Support into_string() for AttrValue

[mibes]

Would it make sense to have an into_string() function for AttrValue that consumes the AttrValue and returns the owned String from the AttrValue whenever possible?

I have at least one case where I need to use the embedded String from the AttrValue. Of course I can use to_string(), but this comes with some overhead that may be avoided.

Example implementation:

impl AttrValue {
    /// Consumes the AttrValue and returns the owned String from the AttrValue whenever possible.
    /// For AttrValue::Rc the <str> is cloned to String in case there are other Rc or Weak pointers to the
    /// same allocation.
    pub fn into_string(self) -> String {
        match self {
            AttrValue::Static(s) => (*s).to_owned(),
            AttrValue::Owned(s) => s,
            AttrValue::Rc(mut rc) => {
                if let Some(s) = Rc::get_mut(&mut rc) {
                    (*s).to_owned()
                } else {
                    rc.to_string()
                }
            }
        }
    }
}

#[cfg(test)]
mod tests_attr_value {
    use super::*;

    #[test]
    fn test_into_string() {
        let av = AttrValue::Static("str");
        assert_eq!(av.into_string(), "str");

        let av = AttrValue::Owned("String".to_string());
        assert_eq!(av.into_string(), "String");

        let av = AttrValue::Rc("Rc<str>".into());
        assert_eq!(av.into_string(), "Rc<str>");
    }
}

[ranile]

The to_string method calls the Display implementation (https://doc.rust-lang.org/stable/src/alloc/string.rs.html#2372-2386). The Display implementation uses the write! macro:

yew/packages/yew/src/virtual_dom/mod.rs

Lines 102 to 110 in aa9b9b2

	impl fmt::Display for AttrValue {
	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
	match self {
	AttrValue::Static(s) => write!(f, "{}", s),
	AttrValue::Owned(s) => write!(f, "{}", s),
	AttrValue::Rc(s) => write!(f, "{}", s),
	}
	}
	}

I'm not sure how write! increases the overhead. If there is indeed some overhead here, it'd be great if you could make a PR to add into_string method.

[mibes]

To be sure, I did a small benchmark to see the actual difference:

bench Owned into_string()                                                                            
                        time:   [70.050 ns 71.116 ns 72.297 ns]
Found 2 outliers among 100 measurements (2.00%)
  2 (2.00%) high mild

bench Owned to_string() time:   [193.70 ns 195.46 ns 197.17 ns]                                    
Found 6 outliers among 100 measurements (6.00%)
  3 (3.00%) low mild
  3 (3.00%) high mild

bench Rc into_string()  time:   [176.72 ns 180.48 ns 184.31 ns]                                   
Found 1 outliers among 100 measurements (1.00%)
  1 (1.00%) high mild

bench Rc to_string()    time:   [187.59 ns 190.62 ns 193.51 ns]                                 
Found 5 outliers among 100 measurements (5.00%)
  2 (2.00%) low mild
  2 (2.00%) high mild
  1 (1.00%) high severe

bench Static into_string()                                                                            
                        time:   [69.149 ns 70.439 ns 71.702 ns]
Found 11 outliers among 100 measurements (11.00%)
  8 (8.00%) low mild
  2 (2.00%) high mild
  1 (1.00%) high severe

bench Static to_string()                                                                            
                        time:   [91.266 ns 93.020 ns 95.009 ns]
Found 9 outliers among 100 measurements (9.00%)
  5 (5.00%) high mild
  4 (4.00%) high severe

The only one that is significantly faster is the AttrValue::Owned into_string(), which makes sense, because we're just "taking" the value in that case. The rest is only moderately faster. And we're talking nanoseconds here, so real-life impact is probably very small.

I'll do the pull request, because the feature has some practical use IMHO.

PS.
The benchmark is not done with the wasm target, but x86_64-apple-darwin. I assume this wouldn't impact the relative performance too much.