Convert interface{} from JSON to one of multiple concrete types

I've been looking around for a solution to this problem, and couldn't find one here on SO. I'm not sure it's possible, but its worth asking.

I have an interface, and my app reads JSON data from a server. There are few types that might return in response, so I'm using interface{} to consume it.

After I've unmarshaled the json bytes to an interface{}, how can I convert it to a concrete type? If it fails, I would like to check the next type for conversation, until I have a successful conversation.

It looks something like this (some code is removed for brevity)

type Fooer interface {
    Foo()
}

type A struct { }

func (a *A) Foo() { .. }

type B struct { }

func (b *B) Foo() { .. }

// resp is io.ReadCloser
func heavvyWork(resp) {
    var parsedResp interface{}
    bytesData, err := ioutil.ReadAll(resp)
    json.Unmarshal(bytesData, parsedResp)

    // convert parsedResp to a concrete type, it might be A or B struct
    // try A, if fails, try B.
    ...
    concreteType.Foo()
}

I have looked over type assertions and casting, but couldn't get this to work.

Is that possible with Go?

Example for JSON response content

A:
{
  "data": {
    "access_key": "AKIA...",
    "secret_key": "xlCs...",
  }
}

B:
{
  "data": {
    "data": {
      "foo": "bar"
    },
    "metadata": {
      ...
    }
  }
}

You have options. None of them are exactly wonderful.

One is, as mentioned, to just look inside the map for keys. I wrote up an example of this here. It's meant to be instructive, but not particularly efficient or anything.

Another is to use json.RawMessage to defer parsing a bit. I wrote up an example of this here. Note how I resort to pointer members of the various structs in the decoder. This makes things annoying: you might want to have pointer-ized data types just for the decode, and use non-pointer types once you've picked a type. But it does let you use more of the json package directly (via struct tags).

Yet another is to use json.NewDecoder to get a stream decoder and work through it. This would probably be the most robust method, but also the trickiest.