Constraints

In the example on the previous page we tried to sum a series of 64-bit integers with the generic Sum[T int](...T) T function (Go playground):

  1. package main
  3. import (
  4.     "fmt"
  5. )
  7. // Sum returns the sum of the provided arguments.
  8. func Sum[T int](args ...T) T {
  9.     var sum T
  10.     for i := 0; i < len(args); i++ {
  11.         sum += args[i]
  12.     }
  13.     return sum
  14. }
  16. func main() {
  17.     fmt.Println(Sum([]int64{1, 2, 3}...))
  18. }

However, when trying to run this example the compiler balks with the following error:

  1. ./prog.go:17:17: int64 does not implement int

This occurs because while the function Sum[T int](...T) T is written generically, the type of T is constrained to be only an int. The function needs to be rewritten so it can accept an int or an int64:

  1. func Sum[T int | int64](args ...T) T {
  2.     var sum T
  3.     for i := 0; i < len(args); i++ {
  4.         sum += args[i]
  5.     }
  6.     return sum
  7. }
  9. func main() {
  10.     fmt.Println(Sum([]int{1, 2, 3}...))
  11.     fmt.Println(Sum([]int64{1, 2, 3}...))
  12. }

Using the | operator, the constraints for T can be expressed such that T can be satisfied by an int or int64. Now when the example is run, it produces the expected output (Golang playground):

  1. 6
  2. 6

:sparkles: Wait a minute, isn’t the | operator in Go supposed to be the bitwise OR operation and || the conditional OR?

You are not wrong. However, it seems that the type parameter proposal elected to follow the lead of languages like PHP, Python, and TypeScript, which all use the | operator to express a union type. Indeed T | K is referred to as a union constraint in the type parameter proposal.

But what about wanting a Sum function that can handle any numeric value? While it is possible to just list them all in Sum[T int | int32 | int64 |..., this would result in difficult-to-read code. Luckily there is a better way…

Next: The any constraint