Go Generics and Interfaces

I'm struggling understanding how generics and interfaces interact with each over and to have the ability to say which implementation will be returned from a function that is defined to return an interface.

How can I get the following code to work the way I want.

package main

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

type IntegrationConfig[T interface{}] interface {
}

type NamedJsonSettings[T interface{}] json.RawMessage

func (m *NamedJsonSettings[T]) GetConfig() (T, error) {
	conf := new(T)
	err := json.Unmarshal(*m, conf)
	return *conf, err
}

type NamedConfig struct {
	Username string `json:"username"`
	Password string `json:"password"`
}

func getConfig[T interface{}]() IntegrationConfig[T] {
	serverConfigStr := `{
    "username": "myusername",
    "password": "supersecret"
}`
	sc := NamedJsonSettings[T](serverConfigStr)
	c, err := sc.GetConfig()
	if err != nil {
		fmt.Printf("ERROR: %s", err)
	}
	return c
}

func main() {

	c := getConfig[NamedConfig]()

	fmt.Printf("%+v\n", c)
	fmt.Printf("%s\n", c.Username)
	fmt.Printf("%s\n", c.Password)
	fmt.Printf("%s\n",reflect.TypeOf(c).String())
}

Running this generates the following error:

./scratch_1.go:43:23: c.Username undefined (type IntegrationConfig[NamedConfig] has no field or method Username)
./scratch_1.go:44:23: c.Password undefined (type IntegrationConfig[NamedConfig] has no field or method Password)

If I remove those two lines, I see the following when I run it in the console, which is what I would expect:

{Username:myusername Password:supersecret}
main.NamedConfig

Where am I going wrong here? Also, any links to some good resources in understanding generics better, in particular in the case when working with interfaces in a way like this, would be greatly appreciated.

The function getConfig[NamedConfig]() returns IntegrationConfig[NamedConfig], and we can see the definition for that:

type IntegrationConfig[T interface{}] interface {
}

You can see that this is just interface{} (a.k.a. any) and it has no fields. Any value can be converted to any, so the fact that the actual object returned has fields is irrelevant. We can construct a similar test case like this:

package main

import "fmt"

type t struct {
	field int
}

func a() any {
	return t{field: 12}
}

func main() {
	value := a()
	fmt.Printf("value.field = %d\n", value.field)
}

Even though the actual value stored in value has a field named field, the type any does not expose that field.

If you want to access fields or methods, those fields / methods must be exposed by the variable’s type, and it does not matter if the fields / methods are exposed by the value’s type. (This is different from, say, Python or JavaScript, which allow you to access any field or method on an object, as long as that field or method exists at runtime.)

How To Fix

First of all, it is normal to use any instead of interface{}. They mean the same thing, but any is more typical.

The various intermediate types are not necessary. You can directly return T from your generics. Since T is an ordinary type inside your generics, you do not have to use new(T).

In this code, the variable c has type NamedConfig, rather than IntegrationConfig[NamedConfig] (which is just any). Since it has the type NamedConfig—since the variable itself has that type and not just the value—you can access the fields.

package main

import (
	"encoding/json"
	"fmt"
)

type NamedConfig struct {
    Username string `json:"username"`
    Password string `json:"password"`
}

func getConfig[T any]() T {
    serverConfigStr := `{
    "username": "myusername",
    "password": "supersecret"
}`
	var value T
	if err := json.Unmarshal([]byte(serverConfigStr), &value); err != nil {
		fmt.Printf("ERROR: %v\n", err)
	}
	return value
}

func main() {
    // Here, c has type NamedConfig.
    c := getConfig[NamedConfig]()

    fmt.Printf("%+v\n", c)
    fmt.Printf("%s\n", c.Username)
    fmt.Printf("%s\n", c.Password)
}