only require Show for elements joined with connect

[panzi]

In most high level languages it's easy to turn a list/array of things into a comma separated string. In Rust there is the connect method, but it requires the elements to implement the trait std::str::Str. I would like this method to require std::fmt::Show instead. Alternatively a join method with according semantics that requires std::fmt::Show would suffice.

Currently you have to write:

let xs = [1, 2, 3];
let str_xs: ~[~str] = xs.iter().map(|x| x.to_str()).collect();
println!("xs = {}", str_xs.connect(", "));

let mut ys = Vec::new();
ys.push(4);
ys.push(5);
ys.push(6);
let str_ys: Vec<~str> = ys.iter().map(|y| y.to_str()).collect();
println!("ys = {}", str_ys.connect(", "));

This is pretty horrible. This would be much nicer:

let xs = [1, 2, 3];
println!("xs = {}", xs.connect(", "));

let mut ys = Vec::new();
ys.push(4);
ys.push(5);
ys.push(6);
println!("ys = {}", ys.connect(", "));

[ghost]

Would it be a better idea to define connect() on iterators of strings instead? It would then just be:

xs.iter().map(|x| x.to_str()).connect(", ")

but I think that explicit step is useful. It doesn't feel right for the formatting step to happen implicitly if there's no way to pass in a custom formatter.

[huonw]

Theoretically we can have low-alloc connection by using Show directly (using .to_str like that will mean a ~str gets allocated for every element).

The most general form would be something like

fn connect_into<W: Writer, S: Show, It: Iterator<S>>(w: &mut W, it: It, connector: &str) {
    for (i, x) in it.enumerate() {
       if i == 0 {
           write!(w, "{}", x);
       } else {
            write!(w, "{}{}", connector, x)
       }
    }
}

connect_into(&mut std::io::stdout(), range(0, 3), ", "); // prints: 0, 1, 2

(I guess you could even have the connector being generic too.)

[hackervera]

+1 for having connect for a Show or something simple like that

[Swatinem]

Yes. It should definitely be defined for Iterator<Show>.

[steveklabnik]

I'm pulling a massive triage effort to get us ready for 1.0. This method is now stable, and so would need to go through an RFC to change.

This issue has been moved to the RFCs repo: rust-lang/rfcs#720