How Can I Access Shared Methods in Go Generics' Union Constraints?

Accessing Shared Methods in Union Constraints with Go Generics

In Go generics (v1.18), type union constraints allow defining interfaces that accept values from multiple types. However, the question arises as to how to access shared methods between these types.

Consider the following example:

type A struct {}
type B struct {}

type AB interface {
    *A | *B
}

func (a *A) some() bool {...}
func (b *B) some() bool {...}

func some[T AB](x T) bool {
    return x.some()  // error
}

In this code, while A and B share the some method, the error occurs when trying to access it from some[T AB]. This is because the compiler only recognizes methods explicitly declared in the constraint interface.

To resolve this issue, one can add the shared method to the interface constraint, as seen below:

type AB interface {
    *A | *B
    some() bool
}

func some[T AB](x T) bool {
    return x.some()  // Works
}

This approach restricts T to types of A or B that implement the some method.

However, this solution is a workaround for a limitation in Go 1.18 generics. The language specification suggests that this should be possible, but the compiler does not support it. This limitation has been acknowledged in the Go 1.18 release notes and is documented in issue #51183. The hope is for this restriction to be removed in Go 1.19.

The above is the detailed content of How Can I Access Shared Methods in Go Generics' Union Constraints?. For more information, please follow other related articles on the PHP Chinese website!