Why are iterator items which are references not cast to a trait object reference? - casting

Question

I'm trying to define a function that should receive an iterator where each item is a reference to a trait object. For example:
use std::fmt::Display;
fn show_items<'a>(items: impl Iterator<Item = &'a Display>) {
items.for_each(|item| println!("{}", item));
}
When I try to call it on an iterator where each item is a reference to a type implementing Display:
let items: Vec<u32> = (1..10).into_iter().collect();
show_items(items.iter());
I get an error:
error[E0271]: type mismatch resolving `<std::slice::Iter<'_, u32> as std::iter::Iterator>::Item == &dyn std::fmt::Display`
--> src/lib.rs:9:5
|
9 | show_items(items.iter());
| ^^^^^^^^^^ expected u32, found trait std::fmt::Display
|
= note: expected type `&u32`
found type `&dyn std::fmt::Display`
note: required by `show_items`
--> src/lib.rs:3:1
|
3 | fn show_items<'a>(items: impl Iterator<Item = &'a Display>) {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Why is &u32 not considered as &dyn std::fmt::Display?
An explicit cast works fine:
show_items(items.iter().map(|item| item as &Display));
It also works fine for a single item:
fn show_item(item: &Display) {
println!("{:?}", item);
}
let item: u32 = 1;
show_item(&item);

Answer 1

The implicit conversion from a type T to dyn Trait for a Trait implemented by T is a so-called unsized coercion, a special kind of coercion. While Rust is somewhat reluctant with implicit type conversions, coercions do happen implicitly at coercion sites, but not in other places.
Function call arguments are coercion sites. This explains why your show_item() function works as desired.
All coercions can also be performed explicitly using the as operator. For this reason, the version using map() works fine.
Your definition of show_items(),
fn show_items<'a>(items: impl Iterator<Item = &'a Display>)
on the other hand is a completely different story. The impl syntax used here is a shorthand for
fn show_items<'a, I>(items: I)
where
I: Iterator<Item = &'a dyn Display>,
The function is generic over the iterator type, and the compiler verifies that the type that you actually pass in implements the trait bound Iterator<Item = &'a dyn Display>. The type std::slice::Iter<'_, u32> from you example code simply does not, hence the error. There is no coercion that converts an argument to a different type to make it implement some trait bound required by a generic function. It is also entirely unclear what type to convert std::slice::Iter<'_, u32> to to turn it into an iterator over &dyn Display.
Note that your version of the function definition is unnecessarily restrictive by requiring an iterator over trait objects. It would be far more natural and more performant to simply require that the iterator items implement Display instead:
fn show_items<I>(items: I)
where
I: IntoIterator,
I::Item: Display,
(I also changed Iterator to IntoIterator, since this is more general and more convenient.)