Go generics: invalid compound literal

php Editor Xigua brings you the latest information - "Go Generics: Invalid Compound Literal". In the Go language community, generics have always been a topic of great concern. With the release of Go 1.18, generics will be officially included in the standard library of the Go language. However, this decision was not accepted by everyone. This article will discuss the implementation of generics in the Go language and related controversies and discussions to help readers better understand this technology and provide a reference for its application in actual development.

Question content

The following code will cause the error "Invalid compound literal type t".

package main

import "fmt"

func main() {
    fmt.Println(createThing[foo]())
}

type thing interface {
    foo | bar
}

type foo struct {
    id int
    a  string
}

type bar struct {
    id int
    b  int
}

func createThing[T thing, P *T]() P {
    return &T{}
}

If I only include thing in interface thing, or remove a string and b int, then foo and bar are exactly the same and the code will run without errors. However, does this defeat the purpose of generics? Why can't I instantiate a generic type like this, especially when I don't even have access to any fields?

Might be related to https://github.com/golang/go/issues/48522

Workaround

Most generic types are not valid types for compound literals. But that's not a problem because there are other ways to create values ​​of generic types.

Create a pointer to the new zero value:

func creatething[t thing]() *t {
    return new(t)
}

Or create a non-pointer zero value:

func createThing[T thing]() T {
    var value T
    return value
}

As for why the error occurs in this way, here is the explanation from the specification, modified to solve your specific problem.

For compound literals:

The core type t of literaltype must be a structure, array, slice or map type

What is the core type?

Interface t has a core type if [...] a single type u exists, which is the underlying type for all types in t's type set

No other interface has core types.

What is the underlying type?

Every type t has an underlying type: if t is one of the predeclared boolean, numeric, or string types, or a type literal, the corresponding underlying type is t itself. Otherwise, the underlying type of t is the underlying type of the type referenced by t in its declaration.

"Type literal" can refer to a literal structure type, such as struct{int id}. Therefore, when foo and bar both have an underlying type of struct{int id}, then thing Has a core type of struct{int id}, so compound literals are possible. When foo and bar do not have the same underlying type, then thing has no core type and compound literals are not possible, hence your error.

The formal definition may seem complex, but the result and practical point is simple: generic code can only express common behavior of possible types. Literal values ​​are not common behavior except in the special case where all underlying types are the same.

The above is the detailed content of Go generics: invalid compound literal. For more information, please follow other related articles on the PHP Chinese website!