Composition and Object-Oriented Design

// Package catalog models a library catalogue.
package catalog

import (
	"errors"
	"fmt"
)

// ErrNoTitle reports a book without a title.
var ErrNoTitle = errors.New("catalog: book needs a title")

// Book is a catalogued book. Its fields are unexported, so only this package
// can break its invariants: the title is never empty and Pages is never negative.
type Book struct {
	title string
	pages int
	loans int
}

// NewBook is the only way for other packages to build a valid Book.
func NewBook(title string, pages int) (*Book, error) {
	if title == "" {
		return nil, ErrNoTitle
	}
	return &Book{title: title, pages: max(pages, 0)}, nil
}

// Title is a getter. Go style omits the Get prefix.
func (b *Book) Title() string { return b.title }

// Lend is the only way to change the loan counter.
func (b *Book) Lend() { b.loans++ }

func (b *Book) String() string {
	return fmt.Sprintf("%s (%d pages, lent %d times)", b.title, b.pages, b.loans)
}

package main

import (
	"fmt"

	"example.com/shelf/ex1/catalog"
)

func main() {
	b, err := catalog.NewBook("Dune", 412)
	if err != nil {
		fmt.Println("error:", err)
		return
	}
	b.Lend()
	b.Lend()
	fmt.Println(b)
	fmt.Println(b.Title())

	_, err = catalog.NewBook("", 10)
	fmt.Println("error:", err)
}

Dune (412 pages, lent 2 times)
Dune
error: catalog: book needs a title

package main

import (
	"fmt"

	"example.com/shelf/ex1/catalog"
)

func main() {
	b, _ := catalog.NewBook("Dune", 412)
	b.loans = 100
	fmt.Println(b.title)
}

./main.go:11:4: b.loans undefined (cannot refer to unexported field loans)
./main.go:12:16: b.title undefined (type *catalog.Book has no field or method title, but does have method Title)

package main

import (
	"fmt"
	"sort"
	"sync"
)

// Shelf has a useful zero value: the zero sync.Mutex is an unlocked mutex and
// the map is created on first use, so `var s Shelf` is ready to use.
type Shelf struct {
	mu    sync.Mutex
	books map[string]int // title -> copies
}

func (s *Shelf) Add(title string) {
	s.mu.Lock()
	defer s.mu.Unlock()
	if s.books == nil {
		s.books = make(map[string]int)
	}
	s.books[title]++
}

func (s *Shelf) Titles() []string {
	s.mu.Lock()
	defer s.mu.Unlock()
	titles := make([]string, 0, len(s.books))
	for t := range s.books {
		titles = append(titles, t)
	}
	sort.Strings(titles)
	return titles
}

// Server shows the functional options pattern for a constructor that has
// several optional settings.
type Server struct {
	addr    string
	timeout int
	logger  func(string)
}

type Option func(*Server)

func WithTimeout(seconds int) Option { return func(s *Server) { s.timeout = seconds } }
func WithLogger(f func(string)) Option {
	return func(s *Server) { s.logger = f }
}

// NewServer applies defaults first, then each option.
func NewServer(addr string, opts ...Option) *Server {
	s := &Server{addr: addr, timeout: 30, logger: func(string) {}}
	for _, opt := range opts {
		opt(s)
	}
	return s
}

func main() {
	var s Shelf // no constructor needed
	s.Add("Dune")
	s.Add("Emma")
	s.Add("Dune")
	fmt.Println(s.Titles(), s.books["Dune"])

	a := NewServer(":8080")
	b := NewServer(":9090", WithTimeout(5), WithLogger(func(m string) { fmt.Println("log:", m) }))
	b.logger("started")
	fmt.Println(a.timeout, b.timeout, a.addr, b.addr)
}

[Dune Emma] 2
log: started
30 5 :8080 :9090

package main

import (
	"fmt"
	"slices"
	"sort"
	"strings"
)

// Small interfaces, composed by embedding other interfaces.
type Titled interface{ Title() string }
type Priced interface{ Price() float64 }

// Item is the union of the two method sets.
type Item interface {
	Titled
	Priced
}

type Book struct {
	title string
	cents int
}

func (b Book) Title() string  { return b.title }
func (b Book) Price() float64 { return float64(b.cents) / 100 }

type DVD struct {
	name  string
	cents int
	mins  int
}

func (d DVD) Title() string  { return fmt.Sprintf("%s (%d min)", d.name, d.mins) }
func (d DVD) Price() float64 { return float64(d.cents) / 100 }

// total is polymorphic: it works with any Priced value, present or future.
func total(items []Item) (sum float64) {
	for _, it := range items {
		sum += it.Price()
	}
	return sum
}

type byTitle []Item

func (s byTitle) Len() int           { return len(s) }
func (s byTitle) Less(i, j int) bool { return s[i].Title() < s[j].Title() }
func (s byTitle) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }

func main() {
	items := []Item{
		Book{"Emma", 899},
		DVD{"Dune", 1500, 155},
		Book{"Dune", 1099},
	}
	fmt.Printf("total: %.2f\n", total(items))

	// sort.Reverse is a decorator: it embeds sort.Interface and overrides Less.
	sort.Sort(sort.Reverse(byTitle(items)))
	for _, it := range items {
		fmt.Println(it.Title())
	}

	// The modern equivalent with generics and a comparison function.
	slices.SortFunc(items, func(a, b Item) int { return strings.Compare(a.Title(), b.Title()) })
	for _, it := range items {
		fmt.Println(it.Title())
	}

	// A type switch recovers the concrete type when you really need it.
	for _, it := range items {
		switch v := it.(type) {
		case DVD:
			fmt.Println("DVD, minutes:", v.mins)
		case Book:
			fmt.Println("book, cents:", v.cents)
		}
	}
}

total: 34.98
Emma
Dune (155 min)
Dune
Dune
Dune (155 min)
Emma
book, cents: 1099
DVD, minutes: 155
book, cents: 899

package main

import "fmt"

type Titled interface{ Title() string }

type Book struct{ title string }

// Pointer receiver: only *Book has Title in its method set.
func (b *Book) Title() string { return b.title }

func show(t Titled) { fmt.Println(t.Title()) }

func main() {
	b := Book{"Dune"}
	show(&b) // fine
	show(b)  // compile error
}

./main.go:17:7: cannot use b (variable of struct type Book) as Titled value in argument to show: Book does not implement Titled (method Title has pointer receiver)

package main

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

type ISBN string

type Book struct {
	ISBN  ISBN
	Title string
}

var ErrNotFound = errors.New("book not found")

// Store is declared by its consumer (the lending service) and is as small as
// the service needs: two methods, not the whole catalogue API.
type Store interface {
	Find(isbn ISBN) (Book, error)
	SaveLoan(isbn ISBN, until time.Time) error
}

// Clock is a function type: the simplest possible dependency.
type Clock func() time.Time

// Service receives its collaborators through the constructor.
type Service struct {
	store Store
	now   Clock
}

func NewService(store Store, now Clock) *Service {
	return &Service{store: store, now: now}
}

func (s *Service) Lend(isbn ISBN) (time.Time, error) {
	b, err := s.store.Find(isbn)
	if err != nil {
		return time.Time{}, fmt.Errorf("lend %q: %w", isbn, err)
	}
	due := s.now().AddDate(0, 0, 14)
	if err := s.store.SaveLoan(b.ISBN, due); err != nil {
		return time.Time{}, err
	}
	return due, nil
}

// memStore is a concrete implementation. It never mentions Store.
type memStore struct {
	books map[ISBN]Book
	loans map[ISBN]time.Time
}

func (m *memStore) Find(isbn ISBN) (Book, error) {
	b, ok := m.books[isbn]
	if !ok {
		return Book{}, ErrNotFound
	}
	return b, nil
}

func (m *memStore) SaveLoan(isbn ISBN, until time.Time) error {
	m.loans[isbn] = until
	return nil
}

// Compile-time assertion: *memStore must implement Store.
var _ Store = (*memStore)(nil)

func main() {
	store := &memStore{
		books: map[ISBN]Book{"9780441172719": {"9780441172719", "Dune"}},
		loans: map[ISBN]time.Time{},
	}
	// The production code would pass time.Now; the test passes a fixed clock.
	fixed := func() time.Time { return time.Date(2026, 10, 18, 9, 0, 0, 0, time.UTC) }
	svc := NewService(store, fixed)

	due, err := svc.Lend("9780441172719")
	fmt.Println(due.Format(time.DateOnly), err)

	_, err = svc.Lend("0000000000000")
	fmt.Println(err, errors.Is(err, ErrNotFound))
}

2026-11-01 <nil>
lend "0000000000000": book not found true

package main

import (
	"errors"
	"testing"
	"time"
)

// fakeStore is a hand-written test double; no mocking framework is needed.
type fakeStore struct {
	findErr error
	saved   map[ISBN]time.Time
}

func (f *fakeStore) Find(isbn ISBN) (Book, error) {
	if f.findErr != nil {
		return Book{}, f.findErr
	}
	return Book{ISBN: isbn, Title: "Dune"}, nil
}

func (f *fakeStore) SaveLoan(isbn ISBN, until time.Time) error {
	f.saved[isbn] = until
	return nil
}

func TestServiceLend(t *testing.T) {
	fixed := func() time.Time { return time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC) }

	t.Run("saves a two-week loan", func(t *testing.T) {
		store := &fakeStore{saved: map[ISBN]time.Time{}}
		due, err := NewService(store, fixed).Lend("978")
		if err != nil {
			t.Fatal(err)
		}
		if want := time.Date(2026, 1, 15, 0, 0, 0, 0, time.UTC); !due.Equal(want) || !store.saved["978"].Equal(want) {
			t.Errorf("due = %v, saved = %v, want %v", due, store.saved["978"], want)
		}
	})

	t.Run("propagates not found", func(t *testing.T) {
		store := &fakeStore{findErr: ErrNotFound}
		_, err := NewService(store, fixed).Lend("978")
		if !errors.Is(err, ErrNotFound) {
			t.Errorf("err = %v, want ErrNotFound", err)
		}
	})
}

go test -v

=== RUN   TestServiceLend
=== RUN   TestServiceLend/saves_a_two-week_loan
=== RUN   TestServiceLend/propagates_not_found
--- PASS: TestServiceLend (0.00s)
    --- PASS: TestServiceLend/saves_a_two-week_loan (0.00s)
    --- PASS: TestServiceLend/propagates_not_found (0.00s)
PASS
ok  	example.com/shelf/ex3	0.075s

package main

import (
	"fmt"
	"net/http"
	"net/http/httptest"
	"strings"
)

// Policy is an interface with one method.
type Policy interface {
	Allow(copies, loans int) bool
}

// PolicyFunc adapts an ordinary function to Policy, exactly as
// http.HandlerFunc adapts a function to http.Handler.
type PolicyFunc func(copies, loans int) bool

func (f PolicyFunc) Allow(copies, loans int) bool { return f(copies, loans) }

func lendable(p Policy, copies, loans int) string {
	if p.Allow(copies, loans) {
		return "yes"
	}
	return "no"
}

// logging is a decorator: it takes a Handler and returns a Handler.
func logging(next http.Handler, out *strings.Builder) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintf(out, "%s %s\n", r.Method, r.URL.Path)
		next.ServeHTTP(w, r)
	})
}

func main() {
	maxTwo := PolicyFunc(func(copies, loans int) bool { return loans < copies && loans < 2 })
	fmt.Println(lendable(maxTwo, 3, 1), lendable(maxTwo, 3, 2))

	var log strings.Builder
	hello := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintln(w, "hello from", r.URL.Path)
	})
	srv := logging(hello, &log)

	rec := httptest.NewRecorder()
	srv.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/books", nil))
	fmt.Print(rec.Body.String())
	fmt.Print(log.String())
}

yes no
hello from /books
GET /books

package main

import (
	"fmt"
	"strings"
)

type Book struct{ ISBN, Title string }

// Store is the interface being decorated.
type Store interface {
	Find(isbn string) (Book, bool)
	Add(b Book)
	Len() int
}

type memStore struct{ books map[string]Book }

func newMemStore() *memStore { return &memStore{books: map[string]Book{}} }

func (m *memStore) Find(isbn string) (Book, bool) { b, ok := m.books[isbn]; return b, ok }
func (m *memStore) Add(b Book)                    { m.books[b.ISBN] = b }
func (m *memStore) Len() int                      { return len(m.books) }

// loggingStore embeds the Store *interface*. Every method of Store is promoted
// and forwarded to the wrapped value; only Add is overridden.
type loggingStore struct {
	Store
	log *strings.Builder
}

func (l loggingStore) Add(b Book) {
	fmt.Fprintf(l.log, "add %s\n", b.ISBN)
	l.Store.Add(b) // call the wrapped implementation explicitly
}

func use(s Store) {
	s.Add(Book{"1", "Dune"})
	s.Add(Book{"2", "Emma"})
	_, ok := s.Find("1")
	fmt.Println("found 1:", ok, "len:", s.Len())
}

func main() {
	var log strings.Builder
	use(loggingStore{Store: newMemStore(), log: &log})
	fmt.Print(log.String())

	// A nil embedded interface compiles but fails at run time.
	defer func() { fmt.Println("recovered:", recover()) }()
	var broken loggingStore
	broken.Len()
}

found 1: true len: 2
add 1
add 2
recovered: runtime error: invalid memory address or nil pointer dereference

package main

import (
	"fmt"
	"time"
)

// Audit is reusable behaviour: a timestamp and who changed the record last.
type Audit struct {
	UpdatedAt time.Time
	UpdatedBy string
}

func (a *Audit) Touch(by string, at time.Time) { a.UpdatedBy, a.UpdatedAt = by, at }

// Toucher is what callers need. Any type that embeds Audit satisfies it,
// because Touch is promoted into its method set.
type Toucher interface {
	Touch(by string, at time.Time)
}

type Book struct {
	Audit
	Title string
}

type Member struct {
	Audit
	Name string
}

// Loan reuses Audit through a named field and forwards explicitly, so
// Touch is *not* part of Loan's API.
type Loan struct {
	audit Audit
	ISBN  string
}

func (l *Loan) Renew(by string, at time.Time) { l.audit.Touch(by, at) }

func main() {
	at := time.Date(2026, 10, 18, 12, 0, 0, 0, time.UTC)
	b := &Book{Title: "Dune"}
	m := &Member{Name: "Ann"}
	for _, t := range []Toucher{b, m} {
		t.Touch("librarian", at)
	}
	fmt.Println(b.UpdatedBy, b.UpdatedAt.Format(time.DateOnly))
	fmt.Println(m.UpdatedBy, m.Audit.UpdatedAt.Format(time.DateOnly))

	l := &Loan{ISBN: "978"}
	l.Renew("ann", at)
	fmt.Println(l.audit.UpdatedBy)

	_, isToucher := any(l).(Toucher)
	fmt.Println("Loan is a Toucher:", isToucher)
}

librarian 2026-10-18
librarian 2026-10-18
ann
Loan is a Toucher: false

package main

import "fmt"

// Animal-style "base class" with a method that calls another method.
type Report struct{}

func (Report) Title() string { return "generic report" }
func (r Report) Render() string {
	// r is a Report. It can never be a LoanReport, so this always calls Report.Title.
	return "== " + r.Title() + " =="
}

type LoanReport struct {
	Report
}

// Title "overrides" the promoted method for callers that use LoanReport directly...
func (LoanReport) Title() string { return "loan report" }

// ...but Render, promoted from Report, still calls Report.Title.
func main() {
	l := LoanReport{}
	fmt.Println(l.Title())
	fmt.Println(l.Render())

	// The fix: pass the varying behaviour in explicitly, via an interface or function.
	fmt.Println(render(l))
}

type Titler interface{ Title() string }

func render(t Titler) string { return "== " + t.Title() + " ==" }

loan report
== generic report ==
== loan report ==

package main

import (
	"fmt"
	"sync"
)

type Counter struct {
	sync.Mutex
	n int
}

func report(c Counter) { fmt.Println(c.n) }

func main() {
	var c Counter
	report(c)
}

./main.go:13:15: report passes lock by value: example.com/shelf/bad3.Counter
./main.go:17:9: call of report copies lock value: example.com/shelf/bad3.Counter

package main

import (
	"encoding/json"
	"fmt"
	"sync"
)

// Counter embeds sync.Mutex to save typing, which exports Lock and Unlock.
type Counter struct {
	sync.Mutex
	n int
}

func (c *Counter) Inc() { c.Lock(); c.n++; c.Unlock() }

// SafeCounter keeps the mutex in a named, unexported field instead.
type SafeCounter struct {
	mu sync.Mutex
	n  int
}

func (c *SafeCounter) Inc() { c.mu.Lock(); c.n++; c.mu.Unlock() }

type Audit struct {
	CreatedBy string
}

func (a Audit) MarshalJSON() ([]byte, error) {
	return []byte(`"audit-only"`), nil
}

type Book struct {
	Audit // promotes MarshalJSON to Book!
	Title string
}

func main() {
	var c Counter
	c.Lock() // part of the public API of Counter, probably unintended
	c.Unlock()

	// Embedding promotes MarshalJSON, so encoding/json uses it for the whole Book.
	out, _ := json.Marshal(Book{Audit{"ann"}, "Dune"})
	fmt.Println(string(out))
}

"audit-only"