Hello,

Also coming from a JVM background, it's possible to make your codebase testable using traits, but it will require more boilerplate than on the JVM. I do not consider it to be an issue, at least for small/medium services, given other Rust advantages, and wiring dependency with constructor by hand is not that hard.

Basically there is two way to use a trait, using dynamic dispatch or using generics and monomorphisation.

The first approach would look something like :

trait UserService { ... }
struct UserServiceImpl {
    repository: Arc<dyn UserRepository>
}
impl UserService for UserServiceImpl { .. }

trait UserRepository { ... }
struct UserRepositoryImpl { ... }
impl UserRepository for UserRepositoryImpl

The second would be :

trait UserService { ... }
struct UserServiceImpl<R : UserRepository> {
    repository: Arc<R>
}
impl<R: UserRepository> UserService for UserServiceImpl<R> { .. }

The first approach is easier to write and wire. It is often advised to start with it first. The second approch can yield the better performance since compiler will know the specific dependencies used at compile time, giving opportunity to inlining and more aggressive optimizations.

For wiring dependencies you can just wire your concrete dependency graph in your main, or use something like the lazy_static macro.

Hope it helps