What is the Use of the Tilde Token (~) in Go Generics?

Understanding the Tilde Token (~) in Go Generics

Go's introduction of the tilde token (~) has brought a new dimension to generic programming. This token allows developers to define types that share a common underlying type.

What is the Tilde Token?

In Go, the tilde token (~) signifies the set of all types with an underlying type T. For instance, ~T indicates all types whose underlying type is T.

Why is it Useful?

The tilde token provides a flexible way to define generic interfaces that can accept types with a specific underlying type. For example, an Ordered interface could be defined as:

type Ordered interface {
  Integer | Float | ~string
}

This interface specifies that a type must be either an Integer, a Float, or a type whose underlying type is a string. This allows custom types with an underlying string type, such as MyString, to satisfy this interface.

Underlying Types

The concept of underlying types is crucial for understanding the tilde token. The underlying type of a type T is usually T itself, except:

• For predeclared numeric, boolean, or string types, the underlying type is the type itself.
• For composite types (structs, slices, etc.), the underlying type is the type to which the composite type refers in its type declaration.

Practical Examples

Using the tilde token, constraints can be created to limit the types that can satisfy a specific interface. For instance, a constraint called ExactSigned could be defined to only allow types that are exactly int, int8, int16, int32, or int64. Such a constraint would not allow custom types like MyInt8.

On the other hand, a constraint called constraints.Signed uses the ~ approximation element to allow types whose underlying type is int8. This allows custom types like MyInt8 to satisfy the constraint.

Syntactic Sugar

The tilde token can be used in unions, anonymous constraints, and even with syntactic sugar. Notably, you can use approximation elements with a single type to simplify writing constraints.

For example, the following anonymous constraints are equivalent:

func echoFixedSize[T interface { ~int8 | ~int32 | ~int64 }](t T) { /* ... */ }

func echoFixedSizeSugar[T ~int8 | ~int32 | ~int64](t T) { /* ... */ }

func echoFixedSizeSugarOne[T ~int8](t T) { /* ... */ }

Common Use Cases

Approximation elements are particularly useful for working with composite types that need to have methods. For instance, to allow a method to be declared for a ByteSeq type, its underlying type must be bound to the identifier:

type ByteSeq []byte

func (b ByteSeq) DoSomething() {}

By specifying ~[]byte in a constraint, it becomes possible to instantiate ByteSeq as a valid type.

Limitations

It is important to note that the tilde token cannot be used with type parameters. For instance, the following code is invalid:

type AnyApprox[T any] interface {
  ~T
}

The above is the detailed content of What is the Use of the Tilde Token (~) in Go Generics?. For more information, please follow other related articles on the PHP Chinese website!