Help Understanding Optional Dependencies

[m13t]

Hello!

I am having some trouble understanding the difference between option and non-optional parameters. As far as I can tell from the documentation, dependency specified in a params (fx.In) struct that do not have constructors providing those parameters should fail. This does not seem to be the case in my implementation. I have a parameter struct with several pointers to other structs, and when those values are not provided by a constructor, the params struct simply contains the nil values. From reading the docs, it seems this should only be the case when specifying the optional struct tag on the properties of the params struct.

Is my understanding correct? If not, then if objects not provided by constructors are simply the zero value, what is the purpose of having the optional param struct tag?

[m13t]

Just to add a simple example to my above question:

package main

import (
	"fmt"

	"go.uber.org/fx"
)

type Thingy struct {
	Value string
}

type Params struct {
	fx.In

	Thing *Thingy
}

type Result struct {
	fx.Out

	Thing *Thingy
}

func main() {
	fx.New(
		fx.Provide(func() Result {
			return Result{}
		}),

		fx.Invoke(func(p Params) {
			fmt.Printf("Thing is nil? %t\n", p.Thing == nil)
		}),
	).Run()
}

The output of this states that the Thing object of params is nil, I would expect the Invoke action to fail as being unable to provide the expected value. I would only expect the seen behaviour if the params struct had Thing tagged with optional.

[JacobOaks]

The optional tag indicates that it is a OK for a dependency to not be provided at all. For example, if you remove the provide from your code example but don't mark *Thingy as optional in Params, you will see an error (ex: https://go.dev/play/p/Dj-Etok6CQt). Adding the optional tag allows for this case to pass. (ex: https://go.dev/play/p/SATNJuUXEuQ). Fx isn't concerned with the value of a dependency, only whether it is provided at all. Providing something as nil is valid in the eyes of Fx initialization.

I think (an OG contributor that has been around longer can confirm) that the point of adding optional:"true" was to allow for adding new inputs into core modules without having to make sure that all current users of the modules provide them. Making new parameters optional allows adding functionality as a non-breaking change in this way.

The optional tag also allows for modules to function differently based on each consumers needs. Some users of a module may have a *Thingy that they want the module to use, some might not. An optional tag allows modules to support both.

[m13t]

Hey @JacobOaks, thanks for the reply.

I suppose this makes sense, I just needed the clarrification as I wasn't quite sure if that was intended or not. I guess as the param struct is valid (with either nil pointers or provided values) so as long as some constructor returns all the required parameters, then yes, a nil value is still a value of the expected type.

Appreciate the demonstrations of the optional vs non-optional params too 👍🏼