How do I convert an Iterator<&str> to a String, interspersed with a constant string such as "\n"?
For instance, given:
let xs = vec!["first", "second", "third"];
let it = xs.iter();
One may produce a string s by collecting into a Vec<&str> and joining the result:
let s = it
.map(|&x| x)
.collect::<Vec<&str>>()
.join("\n");
However, this unnecessarily allocates memory for a Vec<&str>.
Is there a more direct method?
You could use the itertools crate for that. I use the intersperse helper in the example, it is pretty much the join equivalent for iterators.
cloned() is needed to convert &&str items to &str items, it is not doing any allocations. It can be eventually replaced by copied() when [email protected] gets a stable release.
use itertools::Itertools; // 0.8.0
fn main() {
let words = ["alpha", "beta", "gamma"];
let merged: String = words.iter().cloned().intersperse(", ").collect();
assert_eq!(merged, "alpha, beta, gamma");
}
You can do it by using fold function of the iterator easily:
let s = it.fold(String::new(), |a, b| a + b + "\n");
The Full Code will be like following:
fn main() {
let xs = vec!["first", "second", "third"];
let it = xs.into_iter();
// let s = it.collect::<Vec<&str>>().join("\n");
let s = it.fold(String::new(), |a, b| a + b + "\n");
let s = s.trim_end();
println!("{:?}", s);
}
EDIT: After the comment of Sebastian Redl I have checked the performance cost of the fold usage and created a benchmark test on playground.
You can see that fold usage takes significantly more time for the many iterative approaches.
Did not check the allocated memory usage though.
String's + operator takes ownership of the strings, calls push_str(rhs) on it, and returns it.a + b operated on &a and &b, but it looks like the addition operator moves out of a if a is not copy. I guess it's just slow in the benchmark because a short string is added 100,000 times and the string needs to be reallocated multiple times as it grows. The join version knows how the exact size of the resulting string and allocates only one new string.
let mut it = xs.into_iter(); let first = it.next().unwrap_or("").to_owned(); let r = it.fold(first, |a, b| a + "\n" + b); Then you end up with a String instead of &strWith itertools, you have not only intersperse() but also join():
use itertools::Itertools;
let s = it.join("\n");
It is more general than intersperse() (it accepts any Display-implementing type) but therefore may be slower (I didn't benchmark though).
use Iterator::reduce.
fn main() {
let it = ["1", "2", "3"].into_iter();
let res = it.map(String::from).reduce(|acc, s| format!("{acc}, {s}")).unwrap_or_default();
assert_eq!(&res, "1, 2, 3");
}
You can use Cow to avoid unnecessary allocation.
use std::borrow::Cow;
fn main() {
let it = ["1", "2", "3"].into_iter();
let res = it.map(Cow::from).reduce(|mut acc, s| {
acc.to_mut().push('\n');
acc.to_mut().push_str(&s);
acc
}).unwrap_or_default();
assert_eq!(&res, "1\n2\n3");
}
there's relevant example in rust documentation: here.
let words = ["alpha", "beta", "gamma"];
// chars() returns an iterator
let merged: String = words.iter()
.flat_map(|s| s.chars())
.collect();
assert_eq!(merged, "alphabetagamma");
You can also use Extend trait:
fn f<'a, I: Iterator<Item=&'a str>>(data: I) -> String {
let mut ret = String::new();
ret.extend(data);
ret
}
flat_map, as String already implements Extend<&str>.
itertoolscrate doesn't allocate the vectoritertools, sinceSliceConcatExt::joincan calculate the needed size for the full string ahead of time and thus definitely doesn't need to reallocate during accumulation; whereas the other methods may have to reallocate the string. You should definitely benchmark.