Inserting values into `type abc [][]interface{}`

I am trying to insert values into type abc [][] interface{}

I tried this:

insert := &abc{{0, {"abc", "def"}}}

This throws the error: Invalid composite literal type: interface{}

I also tried this:

insert, _ := json.Marshal([][]interface{}{{0, {"abc", "def"}}})

But this also throws the error Invalid composite literal type: interface{}

I want the output to look like:

[ [ 0, [ "abc", "def" ] ] ]

Could you let me know where I am going wrong and how to solve this?

The type of abc allows for any types however the types of the things you're putting into it need to be defined. You're not defining what the type of {"abc", "def"} is and you can't instantiate an interface literal (interfaces don't tell the compiler anything about fields). You can have anonymous structs, but they still need to be defined.

Let's step through examples towards what you have:

x := &abc{}

Creates the outer array with zero entries.

x := &abc{{}, {}, {}}

Creates the outer array with 3 empty, inner arrays.

x := &abc{{0, "abc"}}

An outer array, with a single inner array, with 2 values: 0 and "abc".

x := &abc{{0, {"abc", "def"}}

An outer array, with a single inner array, with 2 values: 0 and ... something? This is an object literal, but without an explicit type and without a syntactically correct implicit type (implicity it's expecting a interface{} which cannot be directly instantiated) it is an error.

type PairOfStrings struct {
  A string
  B string
}

x := &abc{{0, PairOfStrings{"abc", "def"}}}

You've now typed the problematic struct.

x := &abc{{0, struct {
  A string
  B string
}{"abc", "def"}}}

Anonymous structs are an ugly but valid approach as well.

x := &abc{{0, []string{"abc", "def"}}}

Seems to be the closest thing to what you want though.

The rule is that interface{} can hold any defined thing. It's not equivalent to something like C#'s dynamic objects.

You resolve too with "make", example:

type abc [][]interface{}

v := make([][]interface{}, 0)
v2 := make([]interface{}, 0)

v2 = append(v2, 5)
v = append(v, v2)
a := abc(v)
fmt.Println(a)