Proposal: allow multiple implementation for the same interface and being able to return all them

[GregPja]

Hi! I am doing some research on DI for Golang and I find this library to be the perfect middle ground of simplicity, efficiency and static stability. There's one missing feature that at the moment doesn't seem to be possible (correct me please if I'm wrong).

There's no way right now to register multiple implementation of the same interface and then being able to retrieve all of them.
I come from Java, where with Springboot, you can inject a Collection<IService>.

Would that make sense to do it here too?
If you wondering "ok, but how do you handle the case of having 2 implementation of the same interface but your struct only needs one?"
In Springboot in this case you would have an error, because the framework wouldn't know which one to inject.. And we could have the same here too.

[Jictyvoo]

I think that it's possible, but can be really slow, because we gonna try to discover all elements type that fits with the given interface. I'm a mantainer in another DI library, later today I gonna check if I can do this there.

[Jictyvoo]

Yeah, that is possible to do

[GregPja]

nice! That would same me quite some manual work. At the end I found a solution where I provide the list of all dependencies, but I then need to list them manually.

[Jictyvoo]

nice! That would same me quite some manual work. At the end I found a solution where I provide the list of all dependencies, but I then need to list them manually.

Looks nice, can you share a piece of code that represents it?

[Jictyvoo]

I don't know if have any problem by linking this here, but this is the PR that I made on the DI that I work on

[GregPja]

nice! That would same me quite some manual work. At the end I found a solution where I provide the list of all dependencies, but I then need to list them manually.

Looks nice, can you share a piece of code that represents it?

type ISomething interface {
	
}

func Inject(i *do.Injector) ([]ISomething, error){
	return []ISomething{
		Impl1{}, Impl2{}, Impl3{},
	}, nil
}

func InjectService(i *do.Injector) (IService, error) {
 	return ServiceImpl{
		 somethings : do.MustInvoke[[]ISomething](i),
	}, nil
}

This is it basically. But of course it would be nicer to be able to register those ISomething one by one...
But I see also the limitation of this request. Maybe instead of having do.Provide(Inject,i) we could have an explicit do.ProvideMany and a do.MustInvokeMany that don't panic if there is more than 1 implementation