Go: type assertion for maps

I'm reading data structures from JSON. There's a little bit of conversions going on and at the end I have a struct where one of the fields is of type interface{}. It's actually a map, so JSON puts it inside a map[string]inteface{}.

I actually know that the underlying structure is map[string]float64 and I would like to use it like that, so I try to do an assertion. The following code reproduces the behaviour:

type T interface{}

func jsonMap() T {
    result := map[string]interface{}{
	    "test": 1.2,
    }
    return T(result)
}

func main() {
    res := jsonMap()

    myMap := res.(map[string]float64)

    fmt.Println(myMap)
}

I get the error:

panic: interface conversion: main.T is map[string]interface {}, not map[string]float64

I can do the following:

func main() {
    // A first assertion
    res := jsonMap().(map[string]interface{})

    myMap := map[string]float64{
        "test": res["test"].(float64), // A second assertion
    }

    fmt.Println(myMap)
}

This works fine, but I find it very ugly since I need to reconstruct the whole map and use two assertions. Is there a correct way to force the first assertion to drop the interface{} and use float64? In other words, what is the correct way to do the original assertion .(map[string]float64)?

Edit:

The actual data I'm parsing looks like this:

[
 {"Type":"pos",
 "Content":{"x":0.5 , y: 0.3}} ,

{"Type":"vel",
"Content":{"vx": 0.1, "vy": -0.2}}
]

In Go I use a struct and encoding/json in the following way.

type data struct {
    Type string
    Content interface{}
}

// I read the JSON from a WebSocket connection
_, event, _ := c.ws.ReadMessage()

j := make([]data,0)
json.Unmarshal(event, &j)

You cannot type assert map[string]interface{} to map[string]float64. You need to manually create new map.

package main

import (
	"encoding/json"
	"fmt"
)

var exampleResponseData = `{
		"Data":[
			{
				"Type":"pos",
				"Content":{
					"x":0.5,
					"y":0.3
				}
			},
			{
				"Type":"vel",
				"Content":{
					"vx":0.1,
					"vy":-0.2
				}
			}
		]
	}`

type response struct {
	Data []struct {
		Type    string
		Content interface{}
	}
}

func main() {
	var response response
	err := json.Unmarshal([]byte(exampleResponseData), &response)
	if err != nil {
		fmt.Println("Cannot process not valid json")
	}

	for i := 0; i < len(response.Data); i++ {
		response.Data[i].Content = convertMap(response.Data[i].Content)
	}
}

func convertMap(originalMap interface{}) map[string]float64 {
	convertedMap := map[string]float64{}
	for key, value := range originalMap.(map[string]interface{}) {
		convertedMap[key] = value.(float64)
	}

	return convertedMap
}

Are you sure you cannot define Content as map[string]float64? See example below. If not, how can you know that you can cast it in the first place?

type response struct {
	Data []struct {
		Type    string
		Content map[string]float64
	}
}

var response response
err := json.Unmarshal([]byte(exampleResponseData), &response)