3. Constraints

Sometimes you need your generic function to know something about the types it operates on. The example we used in the first exercise didn't need to know anything about the types in the slice, so we used the built-in any constraint:

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

Constraints are just interfaces that allow us to write generics that only operate within the constraints of a given interface type. In the example above, the any constraint is the same as the empty interface because it means the type in question can be anything.

Creating a Custom Constraint

Let's take a look at the example of a concat function. It takes a slice of values and concatenates the values into a string. This should work with any type that can represent itself as a string, even if it's not a string under the hood. For example, a user struct can have a .String() that returns a string with the user's name and age.

type stringer interface {
    String() string
}

func concat[T stringer](vals []T) string {
    result := ""
    for _, val := range vals {
        // this is where the .String() method
        // is used. That's why we need a more specific
        // constraint instead of the any constraint
        result += val.String()
    }
    return result
}

What Are Constraints?

Constraints are interfaces that restrict what types can be used with generic functions.

The any Constraint

any means "any type" - no restrictions:

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

• T any = T can be any type

• any = same as empty interface interface{}

• Works with: int, string, struct, anything!

Why Use Custom Constraints?

When your function needs to call methods or perform operations on the type:

// ❌ Won't work - `any` doesn't guarantee .String() method
func concat[T any](vals []T) string {
    result := ""
    for _, val := range vals {
        result += val.String()  // Error! T might not have String()
    }
    return result
}

Creating a Custom Constraint

Define an interface with required methods:

type stringer interface {
    String() string
}

func concat[T stringer](vals []T) string {
    result := ""
    for _, val := range vals {
        result += val.String()  // ✓ Works! T must have String()
    }
    return result
}

How it works:

• T stringer = T must implement the stringer interface

• stringer requires a String() string method

• Any type with String() can be used

Complete Example

package main

import "fmt"

// Define constraint
type stringer interface {
    String() string
}

// Generic function using constraint
func concat[T stringer](vals []T) string {
    result := ""
    for _, val := range vals {
        result += val.String()
    }
    return result
}

// Type that implements stringer
type user struct {
    name string
    age  int
}

func (u user) String() string {
    return fmt.Sprintf("%s (%d)", u.name, u.age)
}

func main() {
    users := []user{
        {name: "Alice", age: 30},
        {name: "Bob", age: 25},
    }
    
    result := concat(users)
    fmt.Println(result)
    // Output: Alice (30)Bob (25)
}

Constraint Syntax Breakdown

func concat[T stringer](vals []T) string
           ^  ^^^^^^^^
           |     |
           |     └─ Constraint (interface)
           └─ Type parameter

Reads as: "concat is a function with type parameter T, where T must satisfy the stringer interface"

Built-in Constraints

Go provides some built-in constraints:

// any - any type
func doSomething[T any](val T) { }

// comparable - types that support == and !=
func contains[T comparable](slice []T, item T) bool {
    for _, v := range slice {
        if v == item {  // Requires comparable
            return true
        }
    }
    return false
}

Multiple Constraints

You can require multiple interfaces:

type stringer interface {
    String() string
}

type printer interface {
    Print()
}

// T must implement both interfaces
func process[T interface{ stringer; printer }](val T) {
    val.String()
    val.Print()
}

Numeric Constraints

For math operations, use constraint package:

import "golang.org/x/exp/constraints"

func add[T constraints.Integer](a, b T) T {
    return a + b
}

// Works with: int, int8, int16, int32, int64, uint, etc.

Common Constraint Patterns

Pattern 1: Method Requirement

type hasLength interface {
    Len() int
}

func getLengths[T hasLength](items []T) []int {
    lengths := []int{}
    for _, item := range items {
        lengths = append(lengths, item.Len())
    }
    return lengths
}

Pattern 2: Comparable

func findDuplicates[T comparable](items []T) []T {
    seen := make(map[T]bool)
    duplicates := []T{}
    
    for _, item := range items {
        if seen[item] {
            duplicates = append(duplicates, item)
        }
        seen[item] = true
    }
    return duplicates
}

Pattern 3: Ordered (for sorting)

import "golang.org/x/exp/constraints"

func max[T constraints.Ordered](a, b T) T {
    if a > b {
        return a
    }
    return b
}

Why Constraints Matter

Without constraints:

func process[T any](val T) {
    val.DoSomething()  // ❌ Error: T might not have DoSomething()
}

With constraints:

type doer interface {
    DoSomething()
}

func process[T doer](val T) {
    val.DoSomething()  // ✓ Works: T guaranteed to have DoSomething()
}

Constraint Hierarchy

any (most permissive)
  ↓
comparable (can use ==, !=)
  ↓
Custom interfaces (specific methods required)
  ↓
Specific type (most restrictive)

Key Takeaways

1. Constraints = interfaces that restrict generic types

2. any = no restrictions, any type works

3. Custom constraints = require specific methods

4. comparable = built-in for types supporting ==

5. Define constraint = create interface with required methods

6. Type must satisfy = implement all methods in constraint

Quick Reference

Constraint	Syntax	Allows
Any type	[T any]	Everything
Comparable	[T comparable]	Types with == and !=
Custom	[T myInterface]	Types implementing interface
Multiple	[T interface{A; B}]	Types implementing A and B

Remember: Constraints tell Go what operations your generic function needs to perform on the type!

Generic Function Syntax Breakdown

Let me break down each part of this generic function signature:

func splitAnySlice[T any](s []T) ([]T, []T)

Part-by-Part Explanation

Part 1: func splitAnySlice

func splitAnySlice

• func = function keyword

• splitAnySlice = name of the function

Part 2: [T any]

[T any]
 ^  ^^^
 |   |
 |   └─ Constraint (T can be any type)
 └─ Type parameter name

This is the generic part:

• [T any] = type parameter declaration

• T = placeholder for a type (like a variable, but for types)

• any = constraint (T can be any type)

• Square brackets [] indicate this is a generic function

Think of it like:

• Regular parameter: (x int) - x is a value

• Type parameter: [T any] - T is a type

Part 3: (s []T)

(s []T)
 ^  ^^^
 |   |
 |   └─ Type: slice of T
 └─ Parameter name

Regular function parameter:

• s = parameter name

• []T = slice of type T (whatever T is)

Examples of what []T could be:

• If T is int → []int

• If T is string → []string

• If T is user → []user

Part 4: ([]T, []T)

([]T, []T)
 ^^^  ^^^
  |    |
  |    └─ Second return value: slice of T
  └─ First return value: slice of T

Return types:

• Returns two values

• Both are slices of type T

Complete Breakdown

func splitAnySlice[T any](s []T) ([]T, []T)
     └────┬─────┘ └─┬──┘ └──┬──┘ └───┬───┘
          |         |       |        |
    Function   Type     Input    Return
      name    parameter  param    types

How It Works in Practice

Call with integers:

nums := []int{1, 2, 3, 4}
first, second := splitAnySlice(nums)
// T = int
// s = []int{1, 2, 3, 4}
// Returns: ([]int, []int)

Call with strings:

words := []string{"a", "b", "c"}
first, second := splitAnySlice(words)
// T = string
// s = []string{"a", "b", "c"}
// Returns: ([]string, []string)

Comparison: Generic vs Non-Generic

Non-Generic (separate function for each type)

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

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

Generic (one function for all types)

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

Much cleaner!

Type Parameter T Explained

T is like a variable that holds a type instead of a value:

[T any]

• T = name (could be anything: T, Type, Element, etc.)

• any = what types are allowed (constraint)

Common type parameter names:

• T = generic Type

• K = Key (for maps)

• V = Value (for maps)

• E = Element

The Square Brackets []

Square brackets mean different things in different contexts:

[T any]     // Type parameters (generics)
[]int       // Slice type
arr[0]      // Array/slice indexing
[5]int      // Array type (fixed size 5)

In [T any], the brackets indicate type parameters.

Visual Flow

Function call: splitAnySlice([]int{1,2,3,4})
                              ^^^^^^
                                |
                    Go infers T = int
                                |
Function becomes: func splitAnySlice(s []int) ([]int, []int)
                                        ^^^^     ^^^^  ^^^^
                              All T's replaced with int

Complete Example with Types Shown

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

// When called with []int:
nums := []int{1, 2, 3, 4}
a, b := splitAnySlice(nums)
// T = int
// s = []int{1, 2, 3, 4}
// a = []int{1, 2}
// b = []int{3, 4}

// When called with []string:
words := []string{"hello", "world", "foo", "bar"}
x, y := splitAnySlice(words)
// T = string
// s = []string{"hello", "world", "foo", "bar"}
// x = []string{"hello", "world"}
// y = []string{"foo", "bar"}

Key Takeaways

Part	Meaning	Example
[T any]	Type parameter T, any type allowed	T could be int, string, etc.
(s []T)	Input: slice of type T	If T=int, then []int
([]T, []T)	Returns: two slices of type T	If T=int, returns ([]int, []int)

Summary

func splitAnySlice[T any](s []T) ([]T, []T)

Reads as: "splitAnySlice is a generic function with type parameter T (which can be any type), that takes a slice of T, and returns two slices of T"

The beauty of generics: write once, use with any type!

Assignment

We have different kinds of "line items" that we charge our customer's credit cards for. Line items can be things like "subscriptions" or "one-time payments" for email usage.

Complete the chargeForLineItem function.

1

Check if the user has a balance with enough funds to be able to pay for the cost of the newItem.

2

If they don't, then return an "insufficient funds" error and zero values for the other return values.

3

If they do have enough funds:

• Add the line item to the user's history by appending the newItem to the slice of oldItems. This new slice is your first return value.

• Calculate the user's new balance by subtracting the cost of the new item from their balance. This is your second return value.

package main

import (
	"errors"
	"fmt"
	"time"
)

func chargeForLineItem[T lineItem](newItem T, oldItems []T, balance float64) ([]T, float64, error) {
	// ?
}

// don't edit below this line

type lineItem interface {
	GetCost() float64
	GetName() string
}

type subscription struct {
	userEmail string
	startDate time.Time
	interval  string
}

func (s subscription) GetName() string {
	return fmt.Sprintf("%s subscription", s.interval)
}

func (s subscription) GetCost() float64 {
	if s.interval == "monthly" {
		return 25.00
	}
	if s.interval == "yearly" {
		return 250.00
	}
	return 0.0
}

type oneTimeUsagePlan struct {
	userEmail        string
	numEmailsAllowed int
}

func (otup oneTimeUsagePlan) GetName() string {
	return fmt.Sprintf("one time usage plan with %v emails", otup.numEmailsAllowed)
}

func (otup oneTimeUsagePlan) GetCost() float64 {
	const costPerEmail = 0.03
	return float64(otup.numEmailsAllowed) * costPerEmail
}

Solution

package main

import (
	"errors"
	"fmt"
	"time"
)

func chargeForLineItem[T lineItem](newItem T, oldItems []T, balance float64) ([]T, float64, error) {

	var err error = errors.New("insufficient funds")
	cost := newItem.GetCost()
	
	if balance < cost{
		return nil, 0 , err
	}
	newItems := append(oldItems, newItem)
	newBalance := balance - cost

	return newItems, newBalance, nil

	
	
}

// don't edit below this line

type lineItem interface {
	GetCost() float64
	GetName() string
}

type subscription struct {
	userEmail string
	startDate time.Time
	interval  string
}

func (s subscription) GetName() string {
	return fmt.Sprintf("%s subscription", s.interval)
}

func (s subscription) GetCost() float64 {
	if s.interval == "monthly" {
		return 25.00
	}
	if s.interval == "yearly" {
		return 250.00
	}
	return 0.0
}

type oneTimeUsagePlan struct {
	userEmail        string
	numEmailsAllowed int
}

func (otup oneTimeUsagePlan) GetName() string {
	return fmt.Sprintf("one time usage plan with %v emails", otup.numEmailsAllowed)
}

func (otup oneTimeUsagePlan) GetCost() float64 {
	const costPerEmail = 0.03
	return float64(otup.numEmailsAllowed) * costPerEmail
}