这个特定的 Rust 代码是如何实现的？

Question

I'm reading the documentation for the Amethyst game engine , and I've encountered this interesting piece of code:

use amethyst::ecs::World;

struct MyResource {
    pub game_score: i32,
}

fn main() {
    let mut world = World::empty();
    
    let my = MyResource {
        game_score: 0,
    };
    
    world.insert(my);
}

And:

  // try_fetch returns a Option<Fetch<MyResource>>
  let fetched = world.try_fetch::<MyResource>();
  if let Some(fetched_resource) = fetched {
      //dereference Fetch<MyResource> to access data
      assert_eq!(*fetched_resource, MyResource{ game_score: 0, });
  } else {
      println!("No MyResource present in `World`");
  }

And I don't see how it can work, really.

Apparently, there is some kind of collection inside World that can hold members of a completely arbitrary data type -- how can that be possible? The MyResource struct doesn't implement any particular trait, so we can't say something like Box<dyn Trait>.

And then we can recover that item based on its type. Again, I can't see how this can work. How can we iterate through a collection and check every item's type? Is there even a dynamic type checker in Rust? Again, the struct does not implement any particular trait, so how can it possibly interface with it at all?

Answer 1

The signature of insert :

pub fn insert<R>(&mut self, r: R) where
    R: Resource, 

There is a blanket implementation for Resource

impl<T> Resource for T where
    T: Any + Send + Sync,

There is also a blanket implementation for Any ( Any trait implementors ):

impl<T> Any for T where
    T: 'static + ?Sized, 

The Any docs are probably also relevant.

Conclusion : your MyResource does implement a relevant trait, namely the Resource trait.