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

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);

See also [How to iterate over a collection of structs as an iterator of trait object references?](https://stackoverflow.com/q/47156009/155423). — Shepmaster, Feb 04 '19 at 16:20
See also [Trait mismatch for function argument](https://stackoverflow.com/q/48218224/155423) and [Why does Rust not allow coercion to trait objects inside containers?](https://stackoverflow.com/q/41889727/155423). — Shepmaster, Feb 04 '19 at 16:24
Both `show_items` and `show_item` would be more idiomatic as generic functions: `show_items(items: impl Iterator)`. Since [`&T` implements `Display` when `T` does](https://doc.rust-lang.org/std/fmt/trait.Display.html#impl-Display-72), this will work for `show_items(items.iter())` (and if you use `IntoIterator`, you can also just write `show_items(&items)`). — trent, Feb 04 '19 at 17:00
I did almost the same: `show_items(items: impl Iterator)`. But still I was curious about the original case. — flopacero, Feb 06 '19 at 12:23

Sven Marnach · Accepted Answer · 2019-02-04T20:30:01.433

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.)

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

1 Answers1

Linked