Support for generics was added to Go in version 1.18. Generics, or parametric polymorphism, is a feature that makes it possible to write functions and structures that can work with different data types, without us having to write separate code for each data type.

A World Without Generics

Before generics were introduced, if we needed a function that worked with different data types, we had to repeat the function's code several times, once for each data type.

For example, suppose you want a function that takes two numbers as input parameters and returns the larger of the two. We could have this function for the int and float64 types as follows:

package main

import "fmt"

func main() {
    fmt.Println(maxInt(3, 5)) // 5
    fmt.Println(maxFloat64(3.5, 1.3)) // 3.5
}

func maxInt(a, b int) int {
    if a > b {
        return a
    }
	
    return b
}

func maxFloat64(a, b float64) float64 {
    if a > b {
        return a
    }
	
    return b
}

In the example above, because each of our functions can't accept both the float64 and int types as its input or output parameter, we had to repeat an entirely identical piece of code twice.

To avoid this repetition in the earlier example, there are other solutions too:

• Using reflection
• Using type assertion/interface assertion
• Using code generation 

Each of the approaches above has issues and isn't a clean solution. For example, if we use type assertion / interface assertion, our code will look like this:

package main

import "fmt"

func main() {
    var result int
	
    result = max(3, 5).(int)
	
    fmt.Println(result) // 5
}

func max(a, b any) any {
    switch a.(type) {
        case int:
            x := a.(int)
            y := b.(int)
			
            if x > y {
                return x
            }
			
            return y
		case float64:
            x := a.(float64)
            y := b.(float64)
			
            if x > y {
                return x
            }
			
            return y
		default:
            panic("'a' and 'b' both should be int or float64")
	}
}

The code above works correctly, but it has problems:

• Using any reduces the program's readability: when using the max function, we first need to check its implementation to find out which data types it supports.

• possible errors can't be caught at compile time. If we mistakenly call the function with a data type it doesn't implement, we'll run into a at runtime.