comprehensive-rust/src/generics/trait-objects.md

# Trait Objects

We've seen how a function can take arguments which implement a trait:

```rust,editable
use std::fmt::Display;

fn print<T: Display>(x: T) {
    println!("Your value: {x}");
}

fn main() {
    print(123);
    print("Hello");
}
```

However, how can we store a collection of mixed types which implement `Display`?

```rust,editable,compile_fail
fn main() {
    let displayables = vec![123, "Hello"];
}
```

For this, we need _trait objects_:

```rust,editable
use std::fmt::Display;

fn main() {
    let displayables: Vec<Box<dyn Display>> = vec![Box::new(123), Box::new("Hello")];
    for x in displayables {
        println!("x: {x}");
    }
}
```

Memory layout after allocating `displayables`:

```bob
 Stack                             Heap
.- - - - - - - - - - - - - -.     .- - - - - - - - - - - - - - - - - - - - - - - -.
:                           :     :                                               :
:    displayables           :     :                                               :
:   +-----------+-------+   :     :   +-----+-----+                               :
:   | ptr       |   o---+---+-----+-->| o o | o o |                               :
:   | len       |     2 |   :     :   +-|-|-+-|-|-+                               :
:   | capacity  |     2 |   :     :     | |   | |   +----+----+----+----+----+    :
:   +-----------+-------+   :     :     | |   | '-->| H  | e  | l  | l  | o  |    :
:                           :     :     | |   |     +----+----+----+----+----+    :
`- - - - - - - - - - - - - -'     :     | |   |                                   :
                                  :     | |   |     +-------------------------+   :
                                  :     | |   '---->| "<str as Display>::fmt" |   :
                                  :     | |         +-------------------------+   :
                                  :     | |                                       :
                                  :     | |   +----+----+----+----+               :
                                  :     | '-->| 7b | 00 | 00 | 00 |               :
                                  :     |     +----+----+----+----+               :
                                  :     |                                         :
                                  :     |     +-------------------------+         :
                                  :     '---->| "<i32 as Display>::fmt" |         :
                                  :           +-------------------------+         :
                                  :                                               :
                                  :                                               :
                                  '- - - - - - - - - - - - - - - - - - - - - - - -'
```

Similarly, you need a trait object if you want to return different types
implementing a trait:

```rust,editable
fn numbers(n: i32) -> Box<dyn Iterator<Item=i32>> {
    if n > 0 {
        Box::new(0..n)
    } else {
        Box::new((n..0).rev())
    }
}

fn main() {
    println!("{:?}", numbers(-5).collect::<Vec<_>>());
    println!("{:?}", numbers(5).collect::<Vec<_>>());
}

```

<details>

* Types that implement a given trait may be of different sizes. This makes it impossible to have things like `Vec<Display>` in the example above.
* `dyn Display` is a way to tell the compiler about a dynamically sized type that implements `Display`.
* In the example, `displayables` holds *fat pointers* to objects that implement `Display`. The fat pointer consists of two components, a pointer to the actual object and a pointer to the virtual method table for the `Display` implementation of that particular object.
* Compare these outputs in the above example:
     ```rust,ignore
		 use std::fmt::Display;
         println!("{}", std::mem::size_of::<u32>());
         println!("{}", std::mem::size_of::<&u32>());
         println!("{}", std::mem::size_of::<&dyn Display>());
         println!("{}", std::mem::size_of::<Box<dyn Display>>());
     ```

</details>