How to create a static array of objects that implement a common trait?

Question

I am trying to create a static array of objects that implement a common trait. All these structs and their sizes are known at compile time. But when accessing a field defined on the struct the compiler tells me that the field is not on the type.

fn main() {
    for &thing in ALL_THINGS {
        println!("{}", thing.name)
    }
}
trait Thing: Sync { }

struct SpecificThing { 
    name: &'static str
}
impl Thing for SpecificThing { }

static ALL_THINGS: &'static [&dyn Thing] = &[&SpecificThing {name: "test"}];

---

error[E0609]: no field `name` on type `&dyn Thing`
 --> src/main.rs:3:30
  |
3 |         println!("{}", thing.name)
  |                              ^^^^

Example: https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=28a29e98cadf97edb8d4ec61703e8959

The questions static array of trait objects, Create vector of objects implementing a trait in Rust, Can I have a static borrowed reference to a trait object? or Vector of objects belonging to a trait doesn't help with explaining why this happens or how to resolve it.

Please what am I doing wrong here? Is there a better method to solve this task that I have not found yet?

Answer 1

When you define &dyn Thing, you erase all the information about specific data type. That means you can't access fields of dinamically dispatched objects.

Just imagine that you have two different structs in ALL_THINGS:

struct SpecificThing { 
    name: &'static str
}
struct SpecificAnotherThing { 
    no_name: &'static str
}

static ALL_THINGS: &'static [&dyn Thing] = &[&SpecificThing {name: "test"}, &SpecificAnotherThing { no_name: "" }];

You can't access name field because trait Thing know nothing about concrete types it implemented for. Therefore you can't access it's fields directly.

If you really need it, you should define a method in Thing trait which will return value you need:

trait Thing: Sync {
   fn name(&self) -> &str;
}
// ...
// ...
impl Thing for SpecificThing {
   fn name(&self) -> &str {
       self.name
   }
}

Or you can use static dispatching and algebraic data types (enum).