Go error: cannot use generic type without instantiation

by

Whenever you use a parametrized type, including anywhere a type argument is required, like in the built-in make, you must replace the type parameters in its definition with actual types. This is called instantiation.

t := make(opStack[int], 0)
t = append(t, 0)

A generic type must be instantiated also if you use it as a type argument to another generic type:

type Data[T any] struct {
    data T
}

d := Data[opStack[int]]{ data: []int{0, 1, 2} }

You can instantiate with a type parameter, for example in function signatures, fields and type definitions:

type FooBar[T any] struct {
    ops opStack[T]
}

type OpsMap[T any] map[string]opStack[T]

func echo[T any](ops opStack[T]) opStack[T] { return ops }

The relevant quotes from the language specs are (currently) in two different places, Type definitions:

If the type definition specifies type parameters, the type name denotes a generic type. Generic types must be instantiated when they are used.

and Instantiations

A generic function or type is instantiated by substituting type arguments for the type parameters. […]

In other programming languages, “instantiation” may refer to creating an instance of an object — in Go the term specifically refers to replacing type params with concrete types. In my view, the usage of the term is still consistent, although in Go it doesn’t necessarily imply allocation.

Note that you may call generic functions without explicit type arguments. Instantiation happens there too, simply the type arguments might all be inferred from the function arguments:

func Print[T, U any](v T, w U) { /* ... */ }

Print("foo", 4.5) // T is inferred from "foo", U from 4.5

Inference used to work also in generic types, with the restriction that the type parameter list had to be non-empty. However this feature has been disabled, so you must supply all type params explicitly.

type Vector[T any] []T 
// v := Vector[int]{} -> must supply T

type Matrix[T any, U ~[]T] []U 
// m := Matrix[int, []int]{} -> must supply T and U

More Related Contents:

  1. Generic Structs with Go
  2. In Go generics, how to use a common method for types in a union constraint?
  3. generic map value
  4. How can I access a struct field with generics (type T has no field or method)?
  5. How to create generic method in Go? (method must have no type parameters)
  6. Can I construct a slice of a generic type with different type parameters?
  7. How to assign or return generic T that is constrained by union?
  8. How to implement generic interfaces?
  9. How can I instantiate a non-nil pointer of type argument with generic Go?
  10. Go Generics – Unions
  11. How to write a generic function that accepts any numerical type?
  12. Difference between any/interface{} as constraint vs. type of argument?
  13. Is there a way to map an array of objects in golang?
  14. How to iterate over a union of slices passed in a generic function? (T has no core type)
  15. Why a generic can’t be assigned to another even if their type arguments can?
  16. Handle maps with same key type but different value type
  17. What should be the values of GOPATH and GOROOT?
  18. Access struct property by name
  19. package’s type cannot be used as the vendored package’s type
  20. Instance new Type (Golang)
  21. go 1.8 plugin use custom interface
  22. Is this casting in golang?
  23. Type func with interface parameter incompatible error
  24. protoc-gen-go-grpc: program not found or is not executable
  25. Passing an arbitrary function as a parameter in Go
  26. When is the init() function run?
  27. Is there a queue implementation?
  28. Go gin framework CORS
  29. Why doesn’t my Makefile interpolate an expression in a command
  30. What does a function without body mean?

Leave a Comment