Estou tendo problemas para iterar sobre fatias de interfaces que contêm fatias de interfaces.

Esse problema surgiu ao tentar trabalhar com uma chamada de API que retorna dados JSON. Há muitos dados retornados e a estrutura difere bastante, dependendo da solicitação. Também não há estrutura para as respostas JSON na documentação da API, então estou tentando implementar alguns métodos para trabalhar com respostas JSON arbitrárias.

Atualmente, quando a chamada inicial é feita, ela é descartada em uma interface [string] de mapa {} e, em seguida, uma instrução switch é executada para determinar o tipo de cada elemento, o problema ocorre quando uma fatia de interfaces é encontrada. Parece que não consigo fazer nada com eles.

Eu tentei usar o pacote de classificação algumas vezes (especificamente as funções de classificação e slicestable) sem sucesso.

O erro que estou recebendo é:

interface conversion: interface {} is []interface {}, not map[string]interface {}

O que ocorre quando tento mapear a fatia de interfaces para que eu possa iterar sobre elas com a instrução switch novamente.

output := make(map[string]interface{})
err = json.Unmarshal(body, &output)

fmt.Println(err)
identify(output)

return err
}

func identify(output map[string]interface{}) {
    fmt.Printf("%T", output)
    for a, b := range output {
        switch bb := b.(type) {
        case string:
            fmt.Println("This is a string")
        case float64:
            fmt.Println("this is a float")
        case []interface{}:
            fmt.Println(" is []interface ", bb)
            test := b.(map[string]interface{}) // falis here
            fmt.Println("Success!", test)
        default:
            return
        }
    }
}

Portanto, a questão básica é como iterar sobre fatias aninhadas de interfaces sem conhecer a estrutura de antemão?