1. Generics in Go

As we've mentioned, Go does not support classes. For a long time, that meant that Go code couldn't easily be reused in many cases. For example, imagine some code that splits a slice into 2 equal parts. The code that splits the slice doesn't care about the types of values stored in the slice. Before generics, we needed to write the same code for each type, which is a very un-DRY thing to do.

splitIntSlice.go

func splitIntSlice(s []int) ([]int, []int) {
    mid := len(s)/2
    return s[:mid], s[mid:]
}

splitStringSlice.go

func splitStringSlice(s []string) ([]string, []string) {
    mid := len(s)/2
    return s[:mid], s[mid:]
}

In Go 1.18 however, support for generics was released, effectively solving this problem!

Type Parameters

Put simply, generics allow us to use variables to refer to specific types. This is an amazing feature because it allows us to write abstract functions that drastically reduce code duplication.

splitAnySlice.go

func splitAnySlice[T any](s []T) ([]T, []T) {
    mid := len(s)/2
    return s[:mid], s[mid:]
}

In the example above, T is the name of the type parameter for the splitAnySlice function, and we've said that it must match the any constraint, which means it can be anything. This makes sense because the body of the function doesn't care about the types of things stored in the slice.

firstInts, secondInts := splitAnySlice([]int{0, 1, 2, 3})
fmt.Println(firstInts, secondInts)

Assignment

At Textio we store all the emails for a campaign in memory as a slice. We store payments for a single user in the same way.

Complete the getLast() function. It should be a generic function that returns the last element from a slice, no matter the types stored in the slice. If the slice is empty, it should return the zero value of the type.

Tip: Creating a variable that's the zero value of a type is easy:

var myZeroInt int

It's the same with generics, we just have a variable that represents the type:

var myZero T

Solution

main.go

package main

func getLast[T any](s []T) T {
	if len(s) == 0{
		var myZero T
		return myZero
	}
	return s[len(s)-1]
}

🤔 The Problem Generics Solve

Before Generics: Code Duplication Hell

Imagine you want to get the last item from a slice. Without generics, you need a separate function for each type:

getLast variants.go

// For integers
func getLastInt(s []int) int {
    return s[len(s)-1]
}

// For strings
func getLastString(s []string) string {
    return s[len(s)-1]
}

// For booleans
func getLastBool(s []bool) bool {
    return s[len(s)-1]
}

// For User structs
func getLastUser(s []User) User {
    return s[len(s)-1]
}

This is the EXACT same logic, just different types! 😤

---

✨ The Solution: Generics

With generics, you write one function that works for ALL types:

getLast generic.go

func getLast[T any](s []T) T {
    return s[len(s)-1]
}

Now you can use it with any type:

lastInt := getLast([]int{1, 2, 3})           // returns 3
lastString := getLast([]string{"a", "b"})     // returns "b"
lastBool := getLast([]bool{true, false})      // returns false
lastUser := getLast([]User{user1, user2})     // returns user2

One function, infinite types! 🎉

---

🔍 Breaking Down the Syntax

Let's dissect this line:

func getLast[T any](s []T) T

Part 1: [T any] - Type Parameter

• T is a variable that represents a type (you can name it anything: T, K, ElementType, etc.)

• any is a constraint meaning "this can be literally any type"

Part 2: (s []T) - Function Parameter

• []T means "a slice of type T"

• If T is int, then []T is []int

• If T is string, then []T is []string

Part 3: T - Return Type

• The function returns the same type as the slice contains

• If you pass []int, it returns int

• If you pass []string, it returns string

---

🧪 How Go Figures Out the Type

When you call a generic function, Go automatically infers the type:

// You write this:
result := getLast([]int{1, 2, 3})

// Go sees: "Oh, you passed []int, so T must be int"

You can also be explicit if you want:

result := getLast[int]([]int{1, 2, 3})
                 ↑
                 └─ Explicitly saying T is int

But this is rarely needed because Go is smart enough to figure it out.

---

🎯 Complete Example with Explanation

getLast full example.go

func getLast[T any](s []T) T {
    if len(s) == 0 {
        var myZero T  // Zero value of type T
        return myZero
    }
    return s[len(s)-1]
}

// Usage examples:
numbers := []int{10, 20, 30}
lastNum := getLast(numbers)  // T = int, returns 30

words := []string{"hello", "world"}
lastWord := getLast(words)   // T = string, returns "world"

empty := []float64{}
lastFloat := getLast(empty)  // T = float64, returns 0.0 (zero value)

---

🧠 Understanding var myZero T

This is how you create a zero value of a generic type:

var myZero T

What is a zero value?

• For int: 0

• For string: ""

• For bool: false

• For pointers: nil

• For structs: all fields set to their zero values

Why do we need it?

If the slice is empty, we need to return something. Since we don't know what type T is at compile time, we return the zero value:

func getLast[T any](s []T) T {
    if len(s) == 0 {
        var myZero T  // If T is int, this is 0
                      // If T is string, this is ""
        return myZero
    }
    return s[len(s)-1]
}

---

🔄 More Examples to Solidify Understanding

Example 1: Split Slice (from your lesson)

splitAnySlice example.go

func splitAnySlice[T any](s []T) ([]T, []T) {
    mid := len(s)/2
    return s[:mid], s[mid:]
}

// Works with ints
first, second := splitAnySlice([]int{1, 2, 3, 4})
// first = [1, 2], second = [3, 4]

// Works with strings
first, second := splitAnySlice([]string{"a", "b", "c", "d"})
// first = ["a", "b"], second = ["c", "d"]

Example 2: Find Maximum

max generic.go

func max[T comparable](a, b T) T {
    if a > b {
        return a
    }
    return b
}

fmt.Println(max(5, 10))        // T = int, returns 10
fmt.Println(max(3.14, 2.71))   // T = float64, returns 3.14

---

📚 Constraints Explained

The any in [T any] is a constraint. There are other constraints:

1. any - No restrictions

func print[T any](val T) {
    fmt.Println(val)
}

1. comparable - Can use == and !=

func contains[T comparable](slice []T, item T) bool {
    for _, v := range slice {
        if v == item {  // Only works if T is comparable
            return true
        }
    }
    return false
}

1. Custom constraints

Number constraint.go

type Number interface {
    int | int64 | float64
}

func sum[T Number](nums []T) T {
    var total T
    for _, n := range nums {
        total += n  // Can add because T is a number
    }
    return total
}

---

🎓 Mental Model

Think of generics as mad libs for types:

func getLast[____](s []____) ____ {
              T         T      T

When you call the function, Go fills in the blank with the actual type:

getLast([]int{1,2,3})
// Becomes:
func getLast[int](s []int) int {

---

✅ Key Takeaways

1. Generics eliminate code duplication by letting you write one function for many types

2. [T any] means "T is a placeholder for any type"

3. []T means "a slice of whatever type T is"

4. Go infers the type from what you pass to the function

5. var myZero T creates the zero value of type T

---

🚀 Your Solution Explained

getLast explained.go

func getLast[T any](s []T) T {
    if len(s) == 0 {
        var myZero T    // Create zero value of type T
        return myZero   // Return it
    }
    return s[len(s)-1]  // Return last element
}

This works because:

• T can be any type (int, string, User, etc.)

• If slice is empty, return the zero value of that type

• If not empty, return the last element