Is there a graceful approach to deserializing Go interface types? [duplicate]

Question

Given the following:

type Foo struct {
  Td ThingDoer
  // ... other stuff
}


type ThingDoer interface {
  doThing()
}

type doerA struct {
  AGuts string
}
func (a doerA) doThing() {}

type doerB struct {
  BGuts string
}
func (b doerB) doThing() {}

is there a preferred serialization / deserialization strategy for Foo?

Attaching, eg, a MarshalJSON function onto doerA and doerB satisfies the serialization, but then Foo.UnmarshalJSON is effectively stuck: it can't know in advance whether the supplied JSON is of doerA or doerB type.

Edit: The linked "similar" question addresses the specific non-solution example outlined in this question. This question is asking about the existence of a graceful solution.

Answer 1

Imagine you have an structure Foo with one or more fields using interface types.

Lets say you have an interface Bar with two possible structures: Baz and Bam.

You can define auxiliary type (FooConf), without any interface. Only concrete types.

This structure may have a method Build() Foo that will choose the right type on each case.

To be possible define what is the concrete type you can define a signature. For instance an extra field “type” (baz or bam).

You just need to be sure about each type can marshal/unmarshal with consistency.