Instantiating Interfaces

I am newbie in Go. One thing I don't understand is why I get compile error when I want to instantiate interfaces alone but when I use array form of that interface, then no compiler error.

type Flag interface {
  fmt.Stringer
}

func TestCheckRequiredFlag(t *testing.T) {
	testdata := []struct {
		st []Flag
	}{
		{
			st: []Flag{//allowed
				&StringFlag{Name: ""},
			},
		},
	}

	st := struct {
		st Flag
	}{
		st: Flag{// is not allowed
			&StringFlag{Name: ""},
		},
	}
}

This composite literal allocates a new struct instance with the given values.

An interface is an abstract type that cannot be instantiated. We can only create a concrete type that implements the interface and then create an instance of that concrete type. But when you use the array form of the Flag interface, you are actually creating a slice of concrete types that implement the Flag interface, which is acceptable.

Braces {} are used for literal values of slices, structs, arrays and maps. They are not used for interface values. If you want a literal value of an interface type, you have to use the () syntax, which invokes a "type conversion".

For example:

x := MyInterface(&MyStruct{})

x will be of type MyInterface.

To correct your code:

    st := struct {
        st Flag
    }{
        st: Flag(
            &StringFlag{Name: ""},
        ),
    }

You can also remove the type conversion altogether, as Go allows direct assignment to interface values, with the conversion being implicit. More explicitly, the assignability rule says (edited for clarity):

> A value x of type V is assignable to a variable of type T if T is an interface type and x implements T.

So, this code will also work:

	st := struct {
		st Flag
	}{
		st: &StringFlag{Name: ""},
	}

Note that in composite literals such as slices, structs and maps, the values given are considered to be assigned to their respective index, field or key, as if they were variables, so the assignability rules apply.