How Can I Define a Recursive Type Constraint in Go 2 Generics?

How to Define a Recursive Type Constraint Using a Custom Interface

In Go2 generics, you can use an interface to constrain a generic type, ensuring it implements a specific method. However, enforcing the implementation of a method with an argument of the generic type was not allowed in the current draft.

Introducing a Solution:

The new draft allows for defining the Lesser interface and IsLess function as:

type Lesser[T any] interface {
    Less(T) bool
}

func IsLess[T Lesser[T]](x, y T) bool {
    return x.Less(y)
}

This solution enforces that T must be of a type that implements the Lesser interface, which requires a Less method taking an argument of type T. By defining the constraint T Lesser[T], we create a recursive type constraint.

Practical Example:

type Apple int

func (a Apple) Less(other Apple) bool {
    return a < other
}

type Orange int

func (o Orange) Less(other Orange) bool {
    return o < other
}

func main() {
    fmt.Println(IsLess(Apple(10), Apple(20)))   // true
    fmt.Println(IsLess(Orange(30), Orange(15))) // false
}

In this example, the custom types Apple and Orange both fulfill the Lesser requirement and can be passed to IsLess. However, passing an int or mixing types (e.g., Apple and Orange) will result in compilation errors due to type constraints.

Conclusion:

This solution allows for recursive type constraints using a defined interface in the new Go2 generics draft, allowing you to enforce complex relationships between generic types and their methods.

The above is the detailed content of How Can I Define a Recursive Type Constraint in Go 2 Generics?. For more information, please follow other related articles on the PHP Chinese website!