How Does Go's New Tilde (~) Token Affect Type Constraints in Generics?

In Go, Understanding the New Tilde Token ~

Go has introduced a new token, the tilde ~, which holds significance in the context of generics. It symbolizes the set of all types with an underlying type T.

In the example provided:

type Ordered interface {
      Integer | Float | ~string
}

The ~string denotes a set of types whose underlying type is string. This could include user-defined types like MyString that wraps the string type, providing additional functionality.

Underlying Types

The tilde token hinges on the concept of underlying types. The Go language specification explicitly defines each type's underlying type. This concept becomes crucial in understanding the usefulness of ~.

Consider the following:

type Foo struct {
    n int
}

type MyInt8 int8

Here, Foo defines a struct with an underlying type of struct { n int }, while MyInt8 is an alias for int8, giving it an underlying type of int8.

Practical Applications

The practical implication of the ~ token emerges in interface constraints. An interface constraint with only exact elements (without any approximation elements) would not permit user-defined types like MyInt8.

For example, if we define an interface:

type ExactSigned interface {
    int | int8 | int16 | int32 | int64
}

And a function:

func echoExact[T ExactSigned](t T) T { return t }

We cannot instantiate echoExact with MyInt8. However, using constraint elements, we can modify the constraint to allow approximation elements, such as ~int8.

Additional Features

In addition to using approximation elements in unions, Go also allows them in anonymous constraints with or without syntactic sugar. For instance, the following constraint is valid:

type Signed interface {
    ~int8 | ~int32 | ~int64
}

One common use case for approximation elements is composite types like slices and structs that require methods. In such cases, binding the identifier is necessary to declare methods, and the approximation element allows for instantiation with custom types.

The above is the detailed content of How Does Go's New Tilde (~) Token Affect Type Constraints in Generics?. For more information, please follow other related articles on the PHP Chinese website!