Generic Slice Arguments: Understanding the Distinction

In Go, generic programming introduces type parameters that allow functions to operate on different types. One area of interest is the distinction between slice arguments constrained to slice types and generic slice arguments.

Slice Argument Constrained to Slice Types

Consider the slices.Grow function with the first argument constrained by ~[]E. This means that the type of this argument must be a slice type with an element type of E.

Generic Slice Argument

In contrast, consider the slices.Contains function with the first argument simply typed as []E. This allows for any slice type with an element type of E.

Practical Differences

Initially, it may seem that these two types of slice arguments behave similarly, as they both allow the functions to access slice operations like append and range. However, there is a subtle but important difference when it comes to returning a slice.

Returning a Slice

If the function requires returning a slice of the same type as the input slice, you must use a slice argument constrained to slice types (~[]E). This ensures that the returned slice has the correct underlying type.

Example

Let's compare two Grow() implementations: one using ~[]E and the other using []E.

func Grow[S ~[]E, E any](s S, n int) S {
    // ...
}

func Grow2[E any](s []E, n int) []E {
    // ...
}

If we pass a slice of a custom type (e.g., []MyInt), Grow() can return a value of that same type. However, Grow2() can only return a generic slice type ([]E).

Conclusion

In summary, if you need to return a slice of the same type as the input slice, you must use a slice argument constrained to slice types (~[]E). Otherwise, using a generic slice argument is sufficient.