Debug for str writes one byte at a time

[bluss]

The Debug formatter for str outputs one byte at a time to the underlying writer.

We could improve this, for example we could skip forward while no escaping is needed, and if we find a char to escape, write the backlog and then write escape for the current char, and continue.

Exploration impl:

impl Debug for str {
    fn fmt(&self, f: &mut Formatter) -> Result {
        try!(write!(f, "\""));
        let mut write_from = 0;
        for (index, ch) in self.char_indices() {
            // if char needs escaping, flush backlog so far and write, else skip
            let mut escaped = ch.escape_default();
            if let Some(first) = escaped.next() {
                if let Some(second) = escaped.next() {
                    if write_from != index {
                        try!(write!(f, "{}", &self[write_from..index]));
                    }
                    write_from = index + ch.len_utf8();
                    try!(write!(f, "{}{}", first, second));
                    for ech in escaped {
                        try!(write!(f, "{}", ech));
                    }
                }
            }
        }
        try!(write!(f, "{}", &self[write_from..]));
        write!(f, "\"")
    }
}

[bluss]

Reported a bug to gauge the importance. I'd tackle it, but is it a bug? Worth fixing?

[huonw]

It seems silly to have unnecessarily slow code hanging around, but if the fixed code is complicated, maybe it's not worth it yet?

[semmaz]

I'm willing to give this a stab and #24588 while I'm at it, but unsure if this still relevant, or what current opinion on this might be. Should I give a go for these two?