How to implement generic interfaces?

by

Types don’t actually implement generic interfaces, they implement instantiations of generic interfaces. You can’t use a generic type (including interfaces) without instantiation. From there, it is just like pre-generics Go, including the difference between methods with pointer receiver.

Therefore it is helpful to think what the methods that use type parameters would look like if you rewrote them with concrete types.

Let’s consider a generic interface and some type:

type Getter[T any] interface {
    Get() T
}

type MyStruct struct {
    Val string
}

There’s a few possible cases

Interface with concrete type argument

Instantiate as Getter[string], implemented by types with method Get() string

// implements Getter[string]
func (m MyStruct) Get() string {
   return m.Val
}

// ok
func foo() Getter[string] {
    return MyStruct{}
}

Interface with type parameter as type argument

Functions that have type parameters may use those to instantiate generic types, e.g. Getter[T]. Implementors must have exactly the Get() T method. For that to be valid, they are also generic and instantiated with the same type parameter:

So this doesn’t compile even if T is string

// Getter[T] literally needs implementors with `Get() T` method
func bar[T any]() Getter[T] {
    return MyStruct{} // doesn't compile, even if T is string
}

Making MyStruct also parametrized works:

type MyStruct[T any] struct {
    Val T
}

func (m MyStruct[T]) Get() T {
    return m.Val
}

func bar[T any]() Getter[T] {
    return MyStruct[T]{} // ok
}

Concrete interface with generic implementor

Let’s reverse the previous cases. We keep the parametrized MyStruct[T any] but now the interface is not parametrized:

type Getter interface {
    Get() string
}

In this case, MyStruct implements Getter only when it is instantiated with the necessary concrete type:

// Getter requires method `Get() string`
func baz() Getter {
    return MyStruct[string]{} // instantiate with string, ok
    // return MyStruct[int]{} // instantiate with something else, doesn't compile
}

Pointer receivers

This follows the same rules as above, but requires instantiating pointer types, as usual:

// pointer receiver, implements Getter[string]
func (m *MyStruct) Get() string {
   return m.Val
}

func foo() Getter[string] {
    return &MyStruct{} // ok
    // return MyStruct{} // doesn't implement
}

and it is the same if MyStruct is generic.

// parametrized pointer receiver
func (m *MyStruct[T]) Get() T {
   return m.Val
}

func foo() Getter[string] {
    return &MyStruct[string]{} // ok
}

So in your case, the mental exercise of replacing the type params with concrete types gives that Dao[ReturnType] has method FindOne(id string) *ReturnType. The type that implements this method is *MyDao (pointer receiver), therefore:

func NewMyDao() Dao[ReturnType] {
    return &MyDao{}
}

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 Functions in Go
  4. Why are interfaces needed in Golang?
  5. generic map value
  6. How can I access a struct field with generics (type T has no field or method)?
  7. How to create generic method in Go? (method must have no type parameters)
  8. Can I construct a slice of a generic type with different type parameters?
  9. How to assign or return generic T that is constrained by union?
  10. Go error: cannot use generic type without instantiation
  11. How can I instantiate a non-nil pointer of type argument with generic Go?
  12. Go Generics – Unions
  13. How to write a generic function that accepts any numerical type?
  14. Difference between any/interface{} as constraint vs. type of argument?
  15. Is there a way to map an array of objects in golang?
  16. How to iterate over a union of slices passed in a generic function? (T has no core type)
  17. Why a generic can’t be assigned to another even if their type arguments can?
  18. Handle maps with same key type but different value type
  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. Go reflection with interface embedded in struct – how to detect “real” functions?
  26. How can I “go run” a project with multiple files in the main package?
  27. Is it possible to have nested templates in Go using the standard library?
  28. Function signature with no function body
  29. Streaming commands output progress
  30. Slice chunking in Go

Leave a Comment