Anonymous Invocation

[hiendaovinh]

Hi, thanks for the great library.
I'm wondering if anonymous invocation is possible because I'm following Go proverbs with accept interfaces, return structs.
What I am expecting is that:

• Providers return structs
• Invocation with [any] is possible
• Casting results (any) to wanted interfaces.
  Thank you.

[samber]

Hi @hiendaovinh

Please check examples: https://github.com/samber/do/blob/master/examples/interface/main.go

[hiendaovinh]

Well, I don't think the example works exactly like the proverbs.
The provider returns interface: https://github.com/samber/do/blob/master/examples/interface/car.go#L18

[samber]

Can you write a quick demo of the API you expect?

[hiendaovinh]

Hi, what I am expecting is that

type carImplem struct {
	Engine Engine
	Wheels []*Wheel
}

func (c *carImplem) Start() {
	println("vroooom")
}

// Provide a concrete type
// at main.go
do.Provide(injector, &carImplem{
	Engine: engine,
	Wheels: wheels,
})

// A thousand years later
// at my-service.go
type Car interface {
	Start()
}
car := do.MustInvoke[Car](injector)

I tried to follow https://github.com/golang/go/wiki/CodeReviewComments#interfaces although I understand that with do's generic resolving, it's currently impossible.

[samber]

Why not using do.ProvideNamed and do.InvokeNamed ?

[hiendaovinh]

It won't work either because of the type hinting.
E.g. I will provide/resolve named wheels

func NewWheel() *Wheel {
        return &Wheel{}
}

// main.go
do.ProvideNamedValue(injector, "wheel-1", NewWheel())
do.ProvideNamedValue(injector, "wheel-2", NewWheel())
do.ProvideNamedValue(injector, "wheel-3", NewWheel())
do.ProvideNamedValue(injector, "wheel-4", NewWheel())

// car.go
type IWheel interface {}
wheels := []IWheel{
        do.MustInvokeNamed[IWheel](i, "wheel-1"),
        do.MustInvokeNamed[IWheel](i, "wheel-2"),
        do.MustInvokeNamed[IWheel](i, "wheel-3"),
        do.MustInvokeNamed[IWheel](i, "wheel-4"),
}

Output:

panic: DI: could not find service `wheel-1`, available services: `*main.Car`, `*main.Engine`, `wheel-1`, `wheel-2`, `wheel-3`, `wheel-4`

[hiendaovinh]

It doesn't depend on the invokers, it depends on the provider. Unlike Java or PHP, Go interfaces generally belong in the package that uses values of the interface type. Which means that the provider will return implementation while the consumer will specify their expected interface.

[zhulik]

I'd be also happy to be able to invoke services by interfaces. We could have something like do.MustInvokeBy which accepts an interface as a type parameter, goes through all registered services and returns the first which implements the given interface. WDYT?

I know it will be slower than MustInvoke or MustInvokeNamed, but I believe it's quiet ok if it's not called regularly and registered service list is not so long

The implementation could look somewhat like

func InvokeBy[T any](i *Injector) (res T, e error) {
	_i := getInjectorOrDefault(i)

	e = fmt.Errorf("not found")

	_i.forEach(func(name string, service any) {
		if v, ok := service.(T); ok {
			res = v
			e = nil
		}
	})
	return
}

func MustInvokeBy[T any](i *Injector) T {
	s, err := InvokeBy[T](i)
	must(err)
	return s
}

[samber]

Hi there,

I made a proposal in do@v2 -> #45

do.As[*carImplem, Car](injector)

// or

do.InvokeAs[Car](injector)