Parse (arbitrary) previously know data from JSON using GO

I have to parse some JSON files.
The problem is: the type of data some field contains varies according some external (already obtained) information.
My question is: how do I perform this using golang?
I've looked for a solution for this for hours and tried coming up with one, but I keep getting runtime errors.
Also, I thought the type coercion/casting would work based on this post.

I am quite a newbie regarding that language, so I ask you for not being too harsh answering this.

package main

import (
	"encoding/json"
	"fmt"
	"reflect"
	"unsafe"
)

func main() {
	birdJson := `{
			"blah": "bleh",
			"coord" : [[1,2], [3, 4], [22, 5]]
		}
	`
	var result map[string]interface{}
	json.Unmarshal([]byte(birdJson), &result)
	fmt.Println("result:: ", result)

	c := result["coord"]
	
	cv := reflect.ValueOf(c)
	ct := reflect.TypeOf(c)

	fmt.Println("c value:", cv)
	fmt.Println("c type: ", ct)
	fmt.Println(cv.Interface().([][]int))
}

The output:

result::  map[blah:bleh coord:[[1 2] [3 4] [22 5]]]
c value: [[1 2] [3 4] [22 5]]
c type:  []interface {}
panic: interface conversion: interface {} is []interface {}, not [][]int

goroutine 1 [running]:
main.main()
	/Users/maffei/golab/t.go:27 +0x497
exit status 2

It's not really clear what you're trying to do, but you can Unmarshal like this:

package main

import (
   "encoding/json"
   "fmt"
)

var birdJson = []byte(`
{
   "blah": "bleh", "coord" : [
      [1,2], [3, 4], [22, 5]
   ]
}
`)

func main() {
   var result struct {
      Blah string
      Coord [][]int
   }
   json.Unmarshal(birdJson, &result)
   fmt.Printf("%+v\n", result) // {Blah:bleh Coord:[[1 2] [3 4] [22 5]]}
}

You cannot type assert nested interfaces with a single expression.

If the dynamic type of c is [][]int, then you can do c.([][]int).

var c interface{} = [][]int{{1,2}, {3,4}}
_, ok := c.([][]int) // ok == true

However, if the dynamic type of c is []interface{}, then you have to do c.([]interface{}), you then have to loop over the []interface{} slice and type assert each element individually, which, in your case, is another []interface{}, so you'll also need to loop over that and then type assert the individual elements of the nested slice.

Also note that since JSON Numbers are by default unmarshaled as float64 when the target type is interface{}, you'll need to do a conversion to int to get the result you want

s1 := c.([]interface{})
out := make([][]int, len(s1))
for i := range s1 {
	if s2, ok := s1[i].([]interface{}); ok {
		s3 := make([]int, len(s2))
		for i := range s2 {
			if f64, ok := s2[i].(float64); ok {
				s3[i] = int(f64) // convert float64 to int
			}
		}
		out[i] = s3
	}
}

https://play.golang.org/p/UEdf2VSPg16