Go Dependency Inject Container

di.Register("service id", func () (*Service, error) { /* construct service */ })

services, err := di.GetByType[Service]()

service, err := di.Get[Service]("service id")

services, err := di.GetByInterface[Worker]() // Worker is interface for many workers

package di // import "go.neonxp.ru/di"

func Get[T any](id string) (*T, error)
func GetByInterface[Interface any]() ([]Interface, error)
func GetByType[T any]() ([]*T, error)
func Register[T any](id string, constructor func() (*T, error))

di.Register("serviceA", func() (*ServiceA, error) { // <- Register service A
    return &ServiceA{}, nil
})
di.Register("serviceB", func() (*ServiceB, error) { // <- Register service B, that depends from service A
    serviceA, err := di.Get[ServiceA]() // <- Get dependency from container by type
    if err != nil {
        return nil, err
    }

    return &ServiceB{
        ServiceA: serviceA[0],
    }, nil
})

// Do work ...
service, err := di.Get[ServiceB]("serviceB") // <- Get instantinated service B
if err != nil {
    panic(err)
}

service.DoStuff() // Output: Hello, world!


// Services ...
type ServiceA struct{}

func (d *ServiceA) DoStuff() {
    fmt.Println("Hello, world!")
}

type ServiceB struct {
    ServiceA *ServiceA
}

func (d *ServiceB) DoStuff() {
    d.ServiceA.DoStuff()
}