Prevent duplicate initialisation

[tumelowill]

I would like to fulfil an interface while also providing the struct that fulfils that interface. Using fx.As allows us to fulfil the interface, but the struct needs to be re-provided to Fx. Example:

package main

import "go.uber.org/fx"

type Thing1 struct{}

type Thing2 interface{}

func NewThing() *Thing1 {
	println("Hello World!")
	return &Thing1{}
}

func main() {
	// Prints "Hello World!" twice
	fx.New(
		fx.Provide(
			NewThing,
			fx.Annotate(NewThing, fx.As(new(Thing2))),
		),
		fx.Invoke(func(*Thing1, Thing2) {
		}),
	)
}

Is there a shorthand in Fx to ask for *Thing1 and Thing2 that does not cause NewThing to be invoked twice?

[JacobOaks]

Hey @tumelowill - there currently isn't a satisfying way (that I'm aware of) to provide a type as both itself and as an interface in one line. However, you can avoid duplicate initialization by adding a "constructor" that converts the struct to an interface (see here as well).

// Prints "Hello World!" once
fx.New(
	fx.Provide(
		NewThing,
		func(t *Thing1) Thing2 { return t },
	),
	fx.Invoke(func(*Thing1, Thing2) {
	}),
)

[tumelowill]

Interesting, thanks! It'd be cool at some point to see support for us in annotations to fulfil multiple interfaces and the implementation all at once

[tumelowill]

Perhaps an fx.AsItself() option for annotations that also contain fx.As(), or something along those lines