How Can We Effectively Constrain Indexable Types in Go 1.18 Generics?

Indexing Constraints in Go 1.18 Generics

With the introduction of generics in Go 1.18, developers have the opportunity to implement algorithms that work with specific types. One common requirement is to use types that support indexing, such as arrays, slices, maps, and strings.

Indexable Constraint

To restrict a type parameter to indexable types, consider using the following constraint with a union:

<code class="go">type Indexable interface {
    ~[]byte | ~string
}</code>

Limitations of Indexable Constraint

While the above constraint works for indexing bytes and strings, there are limitations to using it with other indexable types, such as maps and arrays:

• Maps: The union must contain only map types with identical key and element types. This restriction makes it impractical for generic algorithms that must handle maps with different keys and values.
• Arrays: The length of an array is part of its type, so a union would need to specify all possible lengths. This can be cumbersome and prone to out-of-bounds errors.

Alternative Approach

Due to these limitations, the only practical union that supports indexing is []byte | string. This union allows for indexing operations but does not support range operations because it lacks a core type.

Example Usage

The following example demonstrates how to use the Indexable constraint:

<code class="go">func GetAt[T Indexable](v T, i int) byte {
    return v[i]
}</code>

This function takes an indexable value and an index and returns the byte at the specified index.

Conclusion

While Go 1.18 provides a way to constrain types to indexable types using a union, the limitations of that constraint mean that it is only practical for a limited set of use cases, namely indexing bytes and strings.

The above is the detailed content of How Can We Effectively Constrain Indexable Types in Go 1.18 Generics?. For more information, please follow other related articles on the PHP Chinese website!