Embedding structured data in Go (golang)

I'm working on an AI game engine in golang, and I need to store some precomputed data to be accessible as fast as possible.

The structure of the data is like this:

{
    'type1': {
        0: {
            0: { 1, 2, 3, 4, 5, 6, 7 },
            1: { 2, 3, 4 },
        },
        1: {
            0: { 2, 3, 4, 5, 6 },
        },
    },
    "type2": {
        0: {
            { 63, 23, 42, 12 },
        },
    },
}

What is the best way to embed this data into the compiled binary? The data will never change and represents the rules of the game.

I am aware that I can create a function that allocates the map on the heap, but I think it is more natural that the data is accessed directly where it is.

Turns out it is quite easy to embed data. To declare a variable in a package scope:

var someVar = map[string][][][]uint8 {
    'type1': [][][]uint8 {
        0: [][]uint8 {
            0: []uint8 { 1, 2, 3, 4, 5, 6, 7, },
        },
    },
}

Declaring it in the package scope makes it accessible, at least for functions in the package scope.

The only annoying thing about this markup is that you initially have to declare the format of the entire structure. Then you need to "pop off" the first part of the structure as you go deeper into your hierarchy. Example:

var someVar = map[string][][][]uint8 {}

Here, map[string]uint8 declares a map with string keys and uint8 values. map[string][]uint8 declares a map with string keys and array of uint8 values.

For every level you go deeper into the structure, you pop off the start of the format definition.

var someVar map[string][][][]uint8 {
                    0: [][][]uint8 {
                      0: [][]uint8 {
                        0: []uint8 {
                          1, 2, 3, 4, 5,
                        },
                      },
                    },
}

The weird indentation is intended to illustrate what's been popped off