Using dig.As() to provide the same interface to 2 different concrete types

[stepanen]

Hello, I am trying to use dig.As() to provide the same interface as 2 different concrete types. Take a look at this example:

Interface

type Receiver interface {
     Receive(someObj Object) error
}

Concrete type 1

type ReceiveOperationV1 struct {
    // ...
}

func NewReceiveOperationV1() *ReceiveOperationV1 {
    return &ReceiveOperationV1{
       // ...
     }
}

func (s *ReceiveOperationV1) Receive(someObj Object) error {
    // ...
}

Concrete type 2

type ReceiveOperationV2 struct {
    // ...
}

func NewReceiveOperationV2() *ReceiveOperationV2 {
    return &ReceiveOperationV2{
       // ...
     }
}

func (s *ReceiveOperationV2) Receive(someObj Object) error {
    // ...
}

in main.go

container.Provide(NewReceiveOperationV1, dig.As(new(Receiver)))
container.Provide(NewReceiveOperationV2, dig.As(new(Receiver)))

The error:
cannot provide Receiver from [0]: already provided by .NewReceiveOperationV1

Question:
Is there any way to use dig to provide the same to 2 different concrete types?

[abhinav]

Hey, @stepanen. Yes, Dig allows that but exactly how/what depends on how you're using them. Some of the options are:

Value groups

If you're using them all together, e.g. at some point, you build a []Receiver and do something with it, you'll want to use value groups. These allow multiple components to provide the same thing to a named group, and then another component to request that entire named group.

For example,

container.Provide(NewReceiveOperationV1, dig.As(new(Receiver)), dig.Group("foo"))
container.Provide(NewReceiveOperationV2, dig.As(new(Receiver))), dig.Group("foo"))

// Elsewhere:

type fooParams struct {
  dig.In

  Receivers []Receiver `group:"foo"`
}

containers.Provide(func(p fooParams) *Foo {
  doStuffWith(p.Receivers)
})

This makes use of parameter objects to specify the group.

flowchart LR
  NewReceiveOperationV1 & NewReceiveOperationV2 --> Group{{"name=foo type=Receiver"}} --> fooParams

Loading

Named values

If you're using them together or separately, and sometimes need access to both, and know in each consumer which one you want to use, you can use named values.

At Provide time, you give them names, and then in consumers, you declare a parameter object (like above) to specify which ones you want:

container.Provide(NewReceiveOperationV1, dig.As(new(Receiver)), dig.Name("v1"))
container.Provide(NewReceiveOperationV2, dig.As(new(Receiver))), dig.Name("v2"))

// Elsewhere

type fooParams struct {
  dig.In

  V1Receiver Receiver `name:"v1"`
  V2Receiver Receiver `name:"v2"`
}
container.Invoke(func(p fooParams) { ... })

The params struct can reference one or both by name.

flowchart LR
  NewReceiveOperationV1 --> V1["Receiver name=v1"]
  NewReceiveOperationV2 --> V2["Receiver name=v2"]
  V1 & V2 --> fooParams

Loading

Scopes

This is the most advanced feature of the three and affords a fair bit of flexibility by scoping what you provide where. As an example, you can provide both concrete types to your parent container, and then create a scope each for the components that use V1 and V2. Inside those scopes, you'll cast the concrete implementations as those interfaces, and consume them, exporting the consumers from that scope if needed.

Roughly:

container.Provide(NewReceiveOperationV1)
container.Provide(NewReceiveOperationV2)

v1Scope := container.Scope("v1")
v2Scope := container.Scope("v2")

// Provide each implementation as a Receiver
// to its own scope. This will not be available to container.
v1.Provide(func(r *ReceiveOperationV1) Receiver { return r })
v2.Provide(func(r *ReceiveOperationV2) Receiver { return r })

// Add consumers for both interfaces, and export them (or not).
v1.Provide(NewFoo, dig.Export(true)) // given, 'func NewFoo(Receiver) *Foo'
v2.Invoke(doStuff) // given, 'doStuff(Receiver)'

flowchart LR
  NewReceiveOperationV1; NewReceiveOperationV2

  subgraph V1
    Receiver1[Receiver]
  end

  subgraph V2
    Receiver2[Receiver] --> doStuff
  end

  NewReceiveOperationV1 --->Receiver1
  NewReceiveOperationV2 --->Receiver2

  Receiver1 -->|NewFoo| Foo["*Foo"]

Loading

Hope this helps!