Rust expected dyn ToString, found f64 - rust

Question

I am struggling with code to write containers to file. I have specified a trait bound of std::fmt::Display because any type implementing this has to_string(). f64 implements this trait, so I don't understand how this error could happen. I checked the rust issues on github and nothing appears to be there but I wanted to check my understanding before raising an issue.
type mismatch resolving `<Vec<f64> as IntoIterator>::Item == (dyn std::fmt::Display + 'static)`
expected trait object `(dyn std::fmt::Display + 'static)`
found type `f64` rustc (E0271)
Edit:
The ToString trait is what I actually tried first, and it gives the same error
type mismatch resolving `<Vec<f64> as IntoIterator>::Item == (dyn ToString + 'static)`
expected trait object `(dyn ToString + 'static)`
found type `f64` rustc (E0271)
Edit:
Added relevant code. I also have an error where the compiler complains about x not being a reference, which I haven't figured out and is why I didn't initially have the code in this question.
use std::error::Error;
// Write to a file
pub fn write_to_file<T>(data_line: T) -> Result<(), Box<dyn Error>>
where
T: IntoIterator<Item = dyn ToString> + len_trait::Len,
{
let file = std::fs::OpenOptions::new()
.write(true)
.create(true)
.append(true)
.open("test_data/data.tsv")
.unwrap();
let mut wtr = csv::WriterBuilder::new()
.delimiter(b'\t')
.quote_style(csv::QuoteStyle::NonNumeric)
.from_writer(file);
let mut data_line_str: Vec<String> = Vec::with_capacity(data_line.len());
// into_iter() is used instead of iter() because iter() doesn't have a trait
// and into_iter() consumes the reference, not the original object
data_line
.into_iter()
.for_each(|x| data_line_str.push(x.to_string()));
wtr.write_record(&data_line_str)?;
wtr.flush()?;
Ok(())
}
// Use assertions to check for problems
#[test]
fn test_write() -> Result<(), Box<dyn Error>>
{
let test: Vec<f64> = vec![1.423, 0.61324, 123.865];
write_to_file(test)?;
// Could use assert_eq! and open file and check matching
let _remove_success = std::fs::remove_file("test_data/data.tsv");
Ok(())
}
Edit:
I've tried changing the function definition, haven't changed to use collect yet because I'm trying to pick apart how this works, and I get this error... I thought I understood but now I'm confused again.
error[E0599]: no method named `len` found for type parameter `T` in the current scope
--> src/io.rs:22:71
|
4 | pub fn write_to_file<T, I>(data_line: T) -> Result<(), Box<dyn Error>>
| - method `len` not found for this type parameter
...
22 | let mut data_line_str: Vec<String> = Vec::with_capacity(data_line.len());
| ^^^ method not found in `T`
|
= help: items from traits can only be used if the type parameter is bounded by the trait
help: the following traits define an item `len`, perhaps you need to restrict type parameter `T` with one of them:
|
6 | T: IntoIterator<IntoIter = I> + ExactSizeIterator,
| +++++++++++++++++++
6 | T: IntoIterator<IntoIter = I> + FixedInitializer,
| ++++++++++++++++++
For more information about this error, try `rustc --explain E0599`.
Final edit:
I believe that I understand the issue. When I bound IntoIterator::IntoIter to ExactSizeIterator, that is specifying what the object that can be turned into an iterator (that is, implements IntoIterator) is turned into an ExactSizeIterator which at that point has a len(). So data_line may not have a len() method, but data_line.into_iter() would when I do as PitaJ suggests and use a type signature like
pub fn write_to_file<T, I>(data_line: T) -> Result<(), Box<dyn Error>>
where
T: IntoIterator<IntoIter = I>,
I: ExactSizeIterator,
<I as Iterator>::Item: ToString,

Answer 1

T: IntoIterator<Item = dyn ToString> + len_trait::Len,
What this says is "I expect T to be able to be converted into an iterator containing some unknown type of trait objects for ToString. That's actually a pretty complicated iterator type, and since dyn ToString is unsized, I'm not entirely confident you can ever have any valid instance of this type.
In most reasonable use cases for this function, we know the type of the iterator at compile time, so you're looking for generics, not trait objects. Consider
pub fn write_to_file<T, I>(data_line: T) -> Result<(), Box<dyn Error>>
where
T: IntoIterator<Item = I> + len_trait::Len,
I: ToString