Difference between any/interface{} as constraint vs. type of argument?

by

Beside any and interface{} being type aliases — hence, equivalent in usage —, there is a practical difference between any as type parameter and any as regular function argument, as in your example.

The difference is that in printAny[T any](foo T) the type of foo is not any/interface{}, but it’s T. And T after instantiation is a concrete type, that may or may not be an interface itself. You can then only pass arguments to an instantiated printAny that can be assigned to that concrete type.

How this impacts your code is most evident with multiple arguments. If we change the function signatures a bit:

func printInterface(foo, bar any) {
    fmt.Println(foo, bar)
}

func printAny[T any](foo, bar T) {
    fmt.Println(foo, bar)
}

After instantiation:

  • the function printAny accepts any two arguments of the same type — whichever is used to instantiate T
  • printInterface, which is equivalent to printInterface(foo, bar interface{}) can still accept two arguments of different types, since both would be individually assignable to any/interface{}.
printInterface(12.5, 0.1)    // ok
printInterface(12.5, "blah") // ok, int and string individually assignable to any

printAny(10, 20)             // ok, T inferred to int, 20 assignable to int
printAny(10, "k")            // compiler error, T inferred to int, "k" not assignable to int
printAny[any](10, "k")       // ok, T explicitly instantiated to any, int and string assignable to any

printAny(nil, nil)           // compiler error, no way to infer T
printAny[any](nil, nil)      // ok, T explicitly instantiated to any, nil assignable to any

A playground: https://go.dev/play/p/pDjP986cj96

Note: the generic version cannot be called with nil without explicit type arguments simply because nil alone doesn’t carry type information, so the compiler can’t infer T. However nil can be normally assigned to variables of interface type.

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. Go error: cannot use generic type without instantiation
  9. How to implement generic interfaces?
  10. How can I instantiate a non-nil pointer of type argument with generic Go?
  11. Go Generics – Unions
  12. How to write a generic function that accepts any numerical type?
  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. Golang ascending order
  18. What are the use(s) for tags in Go?
  19. is there a way to create an instance of a struct from a string?
  20. How to avoid annoying error “declared and not used”
  21. Splitting client/server code
  22. How safe are Golang maps for concurrent Read/Write operations?
  23. In Go is naming the receiver variable ‘self’ misleading or good practice?
  24. Struct in for loop initializer
  25. How can I “go run” a project with multiple files in the main package?
  26. Is it possible to have nested templates in Go using the standard library?
  27. What is channel buffer size?
  28. Get exit code – Go
  29. Terminating a Process Started with os/exec in Golang
  30. Golang mixed assignment and declaration

Leave a Comment