🐹

Go Advanced

A Complete 5-Chapter Course

Topics covered:
Generics: Type Parameters and Constraints
Error Wrapping: errors.Is, errors.As, and %w
context.Context
Testing: the testing Package and go test
JSON and encoding/json

Exercises: 15 hands-on challenges with sample solutions
Format: A4 · Dark-theme code examples · Quick-reference tables

Generics: Type Parameters and Constraints
Error Wrapping: errors.Is, errors.As, and %w
context.Context
Testing: the testing Package and go test
JSON and encoding/json

Chapter 1 of 5

Generics: Type Parameters and Constraints

Course 3 · Ch 1

Generics: Type Parameters and Constraints

Writing one function or type that works correctly across many concrete types, without giving up Go's compile-time type safety

Chapter 5 (Fundamentals) showed that sum(numbers ...int) only works for int — a separate function would be needed for float64, despite the logic being identical. Generics, added to Go relatively recently, solve exactly this: one function definition, usable with multiple types, fully checked at compile time. Unlike Intermediate Chapter 2's interfaces (which work via shared methods), generics work via shared capability — "any type that supports +", for example.

The Problem Without Generics

func sumInts(numbers []int) int {
	total := 0
	for _, n := range numbers {
		total += n
	}
	return total
}

func sumFloats(numbers []float64) float64 {
	total := 0.0
	for _, n := range numbers {
		total += n
	}
	return total
}

These two functions are identical except for one type. Before generics, this duplication was simply accepted, or worked around with any (Intermediate Chapter 2) at the cost of losing type safety and needing manual type assertions.

A Generic Function with a Type Parameter

func Sum[T int | float64](numbers []T) T {
	var total T
	for _, n := range numbers {
		total += n
	}
	return total
}

fmt.Println(Sum([]int{1, 2, 3}))         // 6
fmt.Println(Sum([]float64{1.5, 2.5}))   // 4

[T int | float64] declares T as a type parameter, constrained to either int or float64 — T stands in for whichever concrete type is actually used at the call site. var total T uses Chapter 2's zero-value behaviour generically: it's 0 when T is int, 0.0 when T is float64, decided automatically. Go infers T from the argument — there's no need to write Sum[int](...) explicitly in normal use.

Named Constraints

type Number interface {
	int | float64
}

func Sum[T Number](numbers []T) T {
	var total T
	for _, n := range numbers {
		total += n
	}
	return total
}

Inline constraints like int | float64 get repetitive across several generic functions, so they're usually pulled out into a named constraint interface instead — an interface listing allowed underlying types rather than methods, reusable by name across the whole package.

comparable — a built-in constraint

Go provides a built-in constraint called comparable, satisfied by any type that supports == and != — commonly used for generic functions that need to check for a specific value inside a collection, covered in this chapter's challenges.

A Generic Type — Not Just a Generic Function

type Stack[T any] struct {
	items []T
}

func (s *Stack[T]) Push(item T) {
	s.items = append(s.items, item)
}

func (s *Stack[T]) Pop() T {
	last := s.items[len(s.items)-1]
	s.items = s.items[:len(s.items)-1]
	return last
}

intStack := &Stack[int]{}
intStack.Push(10)
intStack.Push(20)
fmt.Println(intStack.Pop())   // 20

Structs (Intermediate Chapter 1) can be generic too: Stack[T any] declares a stack that works with whatever single type T is chosen at creation time — Stack[int]{} here. Every method automatically carries the same T, so Push and Pop stay perfectly type-safe for whichever type was chosen, with no any-style runtime checking required anywhere inside.

Generics are not the same as any

any (Intermediate Chapter 2) gives up type information entirely — the compiler can't help at all. Generics keep full compile-time type checking; Stack[int] and Stack[string] are still fully separate, type-safe usages, just generated from one shared definition.

Approach	Type safety	Code reuse
Separate function per type	Full	None — duplicated logic
any / interface{}	None at compile time	Full, but unsafe
Generics — func F[T Constraint](...)	Full	Full

Coding Challenges

Challenge 1

Write a generic function Max[T int | float64](a, b T) T that returns the larger of two values. Call it once with two ints and once with two float64s, printing both results.

Tool	Question it answers
fmt.Errorf("...: %w", err)	Add context while preserving the original error
errors.Is(err, sentinel)	"Is this ultimately THIS specific error value?"
errors.As(err, &target)	"Is this (or something it wraps) of THIS type? Give it to me."
err == sentinel	Unsafe once wrapping is involved — avoid

Tool	Purpose
context.Background()	The root context everything else derives from
context.WithTimeout(parent, d)	Auto-cancels after duration d; always defer cancel()
context.WithCancel(parent)	Manual cancellation via the returned cancel function
context.WithValue(parent, key, val)	Attaches request-scoped data, retrieved with ctx.Value(key)
ctx.Done() / ctx.Err()	Channel that closes on cancellation; reports why

Concept	Convention
Test file name	name_test.go
Test function name	func TestXxx(t *testing.T)
Record failure, continue	t.Errorf(...)
Record failure, stop this test	t.Fatalf(...)
Run all tests	go test ./...
Verbose output	go test -v ./...

JavaScript	Go
JSON.stringify(obj)	json.Marshal(value)
JSON.parse(text)	json.Unmarshal(bytes, &target)
No equivalent — keys match property names	`json:"key"` struct tag controls the JSON key name
await response.json()	io.ReadAll(resp.Body) + json.Unmarshal(body, &target)

Go Advanced

Table of Contents

Generics: Type Parameters and Constraints

The Problem Without Generics

A Generic Function with a Type Parameter

Named Constraints

A Generic Type — Not Just a Generic Function

Coding Challenges

Chapter 1 Quick Reference (Advanced)

Error Wrapping: errors.Is, errors.As, and %w

A Sentinel Error — A Known, Comparable Error Value

Wrapping an Error with fmt.Errorf and %w

errors.Is — Checking for a Specific Error Through Any Number of Wraps

Custom Error Types

errors.As — Extracting a Custom Error Type

Coding Challenges

Chapter 2 Quick Reference

context.Context

The Basic Pattern — Pass ctx as the First Parameter

context.WithTimeout — Cancel Automatically After a Duration

context.WithCancel — Manual Cancellation

Passing Request-Scoped Values

Coding Challenges

Chapter 3 Quick Reference

Testing: the testing Package and go test

The File Naming Convention

Running Tests with go test

t.Errorf vs t.Fatalf

Table-Driven Tests — The Idiomatic Go Pattern

Subtests with t.Run

Coding Challenges

Chapter 4 Quick Reference

JSON and encoding/json

Marshaling — Struct to JSON

Struct Tags — Controlling the JSON Output

Unmarshaling — JSON to Struct

Fetching JSON from a Real API

Coding Challenges

Chapter 5 Quick Reference