Collections of different structs keyed by trait

As part of my Rust learning process, I'm trying to convert a pattern I've used several times. This is a repository of "services" that are registered by a key (usually an interface name). This repository is then able to be queried to retrieve a "service" which can then be used. I've used this in the past as a simple DI method to allow the implementations to be replaced with mocks during tests.

I'm having a bit of trouble implementing a simple version of this in Rust.

What I would like to see is this sort of code:

// The service contract
trait DoSomethingService {
    fn do_something(&self);
}

// The service implementation
struct DoSomethingServiceImpl {}

impl DoSomethingService for DoSomethingServiceImpl {
    fn do_something(&self) {
        println!("Doing something for MyService");
    }
}

// BaseService is a marker trait
impl BaseService for DoSomethingServiceImpl {}


fn main() {
    let mut repo = ServiceRepo::new();

    let service1 = DoSomethingServiceImpl {};

    // Register our implementation with the repo as the trait DoSomethingService
    repo.register_service::<DoSomethingService>(Box::new(service1));

    // Get the service from the repo and have it cast to the trait NOT the concrete type
    if let Some(x) = repo.get_service::<DoSomethingService>() {
        x.do_something();
    }
}

My current implementation looks like this

#[derive(Default)]
struct ServiceRepo {
    services: HashMap<String, Box<dyn BaseService>>,
}

impl ServiceRepo {
    fn new() -> Self {
        Self {
            ..Default::default()
        }
    }

    fn register_service<T: BaseService>(&mut self, service: Box<dyn BaseService>) {
        self.services
            .insert(std::any::type_name::<T>().to_string(), service);
    }

    fn get_service<T: BaseService>(&self) -> Option<&Box<T>> {
        let service = self.services.get(&std::any::type_name::<T>().to_string());

        // TODO: Want to return an Option<&T> here
        // Not sure what to do!
    }
}

I "think" I'm storing the service implementation fine but retrieving it pre-cast as the required trait is evading me.

So a couple of questions:

1. Is this a reasonable pattern in Rust? If not why not?
2. How would I implement this? What am I currently missing?

You cannot do this the way how you described this. And the reason is that it doesn't make any sense. Traits "describe" types (their capabilities), not the other way around. However you are close, and you could reverse your solution and have system that would work.

You must think of types (not traits) as your services, and you can store that using dyn Any. For example:

use std::any::Any;

struct Service1;

impl Service1 {
    fn do_thing(&self) {
        println!("Service1")
    }
}

struct Service2;

impl Service2 {
    fn do_other_thing(&mut self) {
        println!("Service2")
    }
}

struct Services {
    services: Vec<Box<dyn Any>>,
}

impl Services {
    fn new() -> Self {
        Self { services: vec![] }
    }

    fn register(&mut self, service: Box<dyn Any>) {
        self.services.push(service)
    }

    fn get_service<S: 'static>(&self) -> Option<&S> {
        self.services
            .iter()
            .map(|s| s.downcast_ref::<S>())
            .find(Option::is_some)
            .flatten()
    }

    fn get_service_mut<S: 'static>(&mut self) -> Option<&mut S> {
        self.services
            .iter_mut()
            .map(|s| s.downcast_mut::<S>())
            .find(Option::is_some)
            .flatten()
    }
}

fn main() {
    let mut services = Services::new();
    services.register(Box::new(Service1));

    services.get_service::<Service1>().unwrap().do_thing();
    assert!(services.get_service::<Service2>().is_none());

    services.register(Box::new(Service2));

    services.get_service::<Service1>().unwrap().do_thing();
    services
        .get_service_mut::<Service2>()
        .unwrap()
        .do_other_thing();
}

EDIT. And by the way do not use output of std::any::type_name as basis for uniquely identifying services. This is only intended for debugging purposes! Use std::any::TypeId obtained with std::any::TypeId::of.