LLD in Go: interfaces, embedding, generics

session · parking_session.py

from session import run, version

version()
run("go run parking/main.go")

# go version go1.27.1 darwin/arm64
$ go run parking/main.go
B2 on level 1 | charger: 7 kW
main.Hourly   T1 pays 12000 paise | still parked: [T2@B2]
main.Flat     T1 pays 10000 paise | still parked: [T2@B2]
leave T9: unknown ticket | is ErrUnknownTicket: true

parking/main.go

// A parking design in Go: structs with methods, an interface declared by the code that uses it,
// a spot type that embeds another, and a generic repository with a Go 1.27 generic method.
package main

import (
	"errors"
	"fmt"
	"slices"
)

type Spot struct {
	ID    string
	Level int
}

func (s Spot) Label() string { return fmt.Sprintf("%s on level %d", s.ID, s.Level) }

// EVSpot embeds Spot: it has Spot's fields and methods, and a field of its own.
type EVSpot struct {
	Spot
	ChargerKW int
}

// Repo keeps values by key, in the order they were first added.
type Repo[K comparable, V any] struct {
	items map[K]V
	order []K
}

func NewRepo[K comparable, V any]() *Repo[K, V] {
	return &Repo[K, V]{items: make(map[K]V)}
}

func (r *Repo[K, V]) Put(key K, value V) {
	if _, ok := r.items[key]; !ok {
		r.order = append(r.order, key)
	}
	r.items[key] = value
}

func (r *Repo[K, V]) Get(key K) (V, bool) {
	value, ok := r.items[key]
	return value, ok
}

func (r *Repo[K, V]) Delete(key K) {
	delete(r.items, key)
	r.order = slices.DeleteFunc(r.order, func(k K) bool { return k == key })
}

// Map is a generic method: it declares a type parameter of its own, R (Go 1.27).
func (r *Repo[K, V]) Map[R any](f func(V) R) []R {
	out := make([]R, 0, len(r.order))
	for _, key := range r.order {
		out = append(out, f(r.items[key]))
	}
	return out
}

// FeePolicy is the only thing a lot needs from a policy. Any type with this method satisfies it.
type FeePolicy interface {
	Fee(minutes int) int // in paise
}

type Hourly struct{ PerHour int }

func (h Hourly) Fee(minutes int) int { return h.PerHour * ((minutes + 59) / 60) }

type Flat struct{ Amount int }

func (f Flat) Fee(int) int { return f.Amount }

type Ticket struct {
	Number, Spot string
	Entered      int
}

var ErrUnknownTicket = errors.New("unknown ticket")

type Lot struct {
	policy  FeePolicy
	tickets *Repo[string, Ticket]
}

func NewLot(policy FeePolicy) *Lot {
	return &Lot{policy: policy, tickets: NewRepo[string, Ticket]()}
}

func (l *Lot) Park(number, spot string, minute int) {
	l.tickets.Put(number, Ticket{Number: number, Spot: spot, Entered: minute})
}

func (l *Lot) Leave(number string, minute int) (int, error) {
	t, ok := l.tickets.Get(number)
	if !ok {
		return 0, fmt.Errorf("leave %s: %w", number, ErrUnknownTicket)
	}
	l.tickets.Delete(number)
	return l.policy.Fee(minute - t.Entered), nil
}

func main() {
	ev := EVSpot{ID: "B2", Level: 1, ChargerKW: 7} // Go 1.27: promoted fields as keys
	fmt.Println(ev.Label(), "| charger:", ev.ChargerKW, "kW")

	for _, policy := range []FeePolicy{Hourly{PerHour: 4000}, Flat{Amount: 10000}} {
		lot := NewLot(policy)
		lot.Park("T1", "A1", 0)
		lot.Park("T2", ev.ID, 30)
		fee, _ := lot.Leave("T1", 130)
		open := lot.tickets.Map(func(t Ticket) string { return t.Number + "@" + t.Spot })
		fmt.Printf("%-13T T1 pays %d paise | still parked: %v\n", policy, fee, open)
	}

	_, err := NewLot(Flat{Amount: 10000}).Leave("T9", 10)
	fmt.Println(err, "| is ErrUnknownTicket:", errors.Is(err, ErrUnknownTicket))
}

session.py

"""Prints a terminal session: "$ " and each command, then everything it printed (standard output and standard
error together), and its exit status when that is not 0.

`go` is Go 1.27.1, the version this lesson pins, from the mise installation that also holds the Python running this
file; go="1.26.8" switches to Go 1.26.8 for the comparisons with the previous release. learn:verify's sandbox may not
read that folder, so these sessions are recorded with LEARN_VERIFY_NETWORK=allow. They read only this folder and the
toolchain, write only inside this folder (Go's build cache included), and never use the network: GOTOOLCHAIN=local
stops Go from downloading another version.

A command that fails makes the session exit with status 1, unless the script lists it in may_fail. For a command
that may fail, `keep` (a regular expression) shows only the lines of its output that matter. Test timings, which
change on every run, are left out.
"""

import os
import re
import subprocess
import sys
from pathlib import Path

# <mise>/installs/python/3.14.8/bin/python3 -> <mise>/installs
INSTALLS = Path(sys.executable).resolve().parents[3]
TIMING = re.compile(r"\s*\(\d+\.\d+s\)|\t\d+\.\d+s$")


def _env(go):
    here = Path.cwd()
    for folder in ("home", "tmp", "gocache", "gopath"):
        (here / folder).mkdir(exist_ok=True)
    env = dict(os.environ)
    env.update(
        PATH=os.pathsep.join([str(INSTALLS / "go" / go / "bin"), "/usr/bin", "/bin"]),
        HOME=str(here / "home"),
        TMPDIR=str(here / "tmp"),
        GOCACHE=str(here / "gocache"),
        GOPATH=str(here / "gopath"),
        GOTOOLCHAIN="local",
        GOTELEMETRY="off",
        GOFLAGS="-trimpath",
        GO111MODULE="auto",
    )
    return env


def _shell(command, go):
    done = subprocess.run(command, shell=True, env=_env(go), stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
    return done.returncode, [TIMING.sub("", line) for line in done.stdout.splitlines()]


def version(go="1.27.1"):
    """Prints `go version` as a comment, so the record says which Go ran."""
    status, lines = _shell("go version", go)
    if status != 0 or not lines:
        sys.exit(f"Go {go} is not installed on this computer")
    print("#", lines[0])


def run(script, go="1.27.1", may_fail=(), keep=None):
    """Runs each line of the script as one shell command, in the examples folder."""
    unexpected = 0
    for command in (line.strip() for line in script.strip().splitlines()):
        print(f"$ {command}")
        status, lines = _shell(command, go)
        if status != 0 and keep:
            lines = [line for line in lines if re.search(keep, line)]
        for line in lines:
            print(line)
        if status != 0:
            print(f"[exit status {status}]")
            if command not in may_fail:
                unexpected += 1
    if unexpected:
        sys.exit(1)