Design Patterns#

from dataclasses import dataclass
from decimal import Decimal


# Before: finance, design and the DBA all edit this one class.
#
# class Invoice:
#     def total(self) -> Decimal: ...        # finance's tax rules
#     def to_pdf(self) -> bytes: ...         # the design team's layout
#     def save(self, conn) -> None: ...      # the DBA's schema


@dataclass(frozen=True)
class InvoiceLine:
    description: str
    amount: Decimal


@dataclass(frozen=True)
class Invoice:  # finance: the business rules, and nothing else
    number: str
    lines: tuple[InvoiceLine, ...]
    vat_rate: Decimal = Decimal("0.20")

    def net(self) -> Decimal:
        return sum((line.amount for line in self.lines), Decimal("0"))

    def total(self) -> Decimal:
        return (self.net() * (1 + self.vat_rate)).quantize(Decimal("0.01"))


class InvoiceRenderer:  # design: layout changes land here
    def to_text(self, invoice: Invoice) -> str:
        rows = [f"{l.description:<30}{l.amount:>10}" for l in invoice.lines]
        return "\n".join([f"Invoice {invoice.number}", *rows, f"{'Total':<30}{invoice.total():>10}"])


class InvoiceRepository:  # the DBA: schema changes land here
    def __init__(self, conn) -> None:
        self._conn = conn

    def save(self, invoice: Invoice) -> None:
        self._conn.execute(
            "insert into invoices (number, total) values (?, ?)",
            (invoice.number, str(invoice.total())),
        )

// Before: finance, design and the DBA all edit this one class.
//
// class Invoice {
//   total(): number { ... }        // finance's tax rules
//   toPdf(): Uint8Array { ... }    // the design team's layout
//   save(db: Db): void { ... }     // the DBA's schema
// }

interface InvoiceLine {
  readonly description: string;
  readonly amountPence: number;
}

class Invoice {
  // Finance: the business rules, and nothing else.
  constructor(
    readonly number: string,
    readonly lines: readonly InvoiceLine[],
    readonly vatRate = 0.2,
  ) {}

  net(): number {
    return this.lines.reduce((sum, l) => sum + l.amountPence, 0);
  }

  total(): number {
    return Math.round(this.net() * (1 + this.vatRate));
  }
}

class InvoiceRenderer {
  // Design: layout changes land here.
  toText(invoice: Invoice): string {
    const rows = invoice.lines.map((l) => `${l.description.padEnd(30)}${String(l.amountPence).padStart(10)}`);
    return [`Invoice ${invoice.number}`, ...rows, `${"Total".padEnd(30)}${String(invoice.total()).padStart(10)}`].join("\n");
  }
}

class InvoiceRepository {
  // The DBA: schema changes land here.
  constructor(private readonly db: { run(sql: string, params: unknown[]): Promise<void> }) {}

  save(invoice: Invoice): Promise<void> {
    return this.db.run("insert into invoices (number, total) values (?, ?)", [invoice.number, invoice.total()]);
  }
}

from dataclasses import dataclass
from decimal import Decimal
from typing import Iterable, Protocol


@dataclass(frozen=True)
class Order:
    subtotal: Decimal
    items: int
    first_order: bool


class DiscountRule(Protocol):
    def amount(self, order: Order) -> Decimal: ...


@dataclass(frozen=True)
class PercentOver:
    threshold: Decimal
    percent: Decimal

    def amount(self, order: Order) -> Decimal:
        return order.subtotal * self.percent / 100 if order.subtotal >= self.threshold else Decimal("0")


@dataclass(frozen=True)
class FirstOrder:
    flat: Decimal

    def amount(self, order: Order) -> Decimal:
        return self.flat if order.first_order else Decimal("0")


class PricingEngine:
    """Closed: this loop never changes. Open: pass in more rules."""

    def __init__(self, rules: Iterable[DiscountRule]) -> None:
        self._rules = tuple(rules)

    def price(self, order: Order) -> Decimal:
        best = max((rule.amount(order) for rule in self._rules), default=Decimal("0"))
        return max(order.subtotal - best, Decimal("0"))


engine = PricingEngine([PercentOver(Decimal("100"), Decimal("10")), FirstOrder(Decimal("15"))])
print(engine.price(Order(subtotal=Decimal("120"), items=3, first_order=True)))  # 120 - max(12, 15) = 105

interface Order {
  subtotalPence: number;
  items: number;
  firstOrder: boolean;
}

interface DiscountRule {
  amount(order: Order): number;
}

class PercentOver implements DiscountRule {
  constructor(private readonly thresholdPence: number, private readonly percent: number) {}
  amount(order: Order): number {
    return order.subtotalPence >= this.thresholdPence ? Math.round((order.subtotalPence * this.percent) / 100) : 0;
  }
}

class FirstOrder implements DiscountRule {
  constructor(private readonly flatPence: number) {}
  amount(order: Order): number {
    return order.firstOrder ? this.flatPence : 0;
  }
}

class PricingEngine {
  // Closed: this loop never changes. Open: pass in more rules.
  constructor(private readonly rules: readonly DiscountRule[]) {}

  price(order: Order): number {
    const best = Math.max(0, ...this.rules.map((r) => r.amount(order)));
    return Math.max(order.subtotalPence - best, 0);
  }
}

const engine = new PricingEngine([new PercentOver(10_000, 10), new FirstOrder(1500)]);
console.log(engine.price({ subtotalPence: 12_000, items: 3, firstOrder: true })); // 12000 - max(1200, 1500) = 10500

# domain/reports.py -- imports nothing from infrastructure.
from dataclasses import dataclass
from datetime import date
from decimal import Decimal
from typing import Protocol


@dataclass(frozen=True)
class Sale:
    day: date
    amount: Decimal


class ReportStore(Protocol):  # the port: shaped by what the policy needs
    def sales_between(self, start: date, end: date) -> list[Sale]: ...


class ReportService:  # high-level policy
    def __init__(self, store: ReportStore) -> None:
        self._store = store

    def weekly_total(self, week_start: date, week_end: date) -> Decimal:
        return sum((s.amount for s in self._store.sales_between(week_start, week_end)), Decimal("0"))


# adapters/postgres.py -- depends on the domain, never the other way round.
class PostgresReportStore:
    def __init__(self, conn) -> None:
        self._conn = conn

    def sales_between(self, start: date, end: date) -> list[Sale]:
        rows = self._conn.execute("select day, amount from sales where day between %s and %s", (start, end))
        return [Sale(day, Decimal(amount)) for day, amount in rows]


class InMemoryReportStore:  # a second adapter: tests and local runs
    def __init__(self, sales: list[Sale]) -> None:
        self._sales = sales

    def sales_between(self, start: date, end: date) -> list[Sale]:
        return [s for s in self._sales if start <= s.day <= end]

// domain/reports.ts -- imports nothing from infrastructure.
export interface Sale {
  readonly day: string; // ISO date
  readonly amountPence: number;
}

export interface ReportStore {
  // The port: shaped by what the policy needs.
  salesBetween(start: string, end: string): Promise<Sale[]>;
}

export class ReportService {
  // High-level policy.
  constructor(private readonly store: ReportStore) {}

  async weeklyTotal(weekStart: string, weekEnd: string): Promise<number> {
    const sales = await this.store.salesBetween(weekStart, weekEnd);
    return sales.reduce((sum, s) => sum + s.amountPence, 0);
  }
}

// adapters/postgres.ts -- depends on the domain, never the other way round.
type Pool = { query(sql: string, params: unknown[]): Promise<{ rows: { day: string; amount: number }[] }> };

export class PostgresReportStore implements ReportStore {
  constructor(private readonly pool: Pool) {}

  async salesBetween(start: string, end: string): Promise<Sale[]> {
    const { rows } = await this.pool.query("select day, amount from sales where day between $1 and $2", [start, end]);
    return rows.map((r) => ({ day: r.day, amountPence: r.amount }));
  }
}

export class InMemoryReportStore implements ReportStore {
  // A second adapter: tests and local runs.
  constructor(private readonly sales: Sale[]) {}

  async salesBetween(start: string, end: string): Promise<Sale[]> {
    return this.sales.filter((s) => s.day >= start && s.day <= end);
  }
}

class Collection:
    def __init__(self) -> None:
        self._items: list = []

    def add(self, item) -> None:
        self._items.append(item)

    def add_all(self, items) -> None:
        for item in items:
            self.add(item)  # an implementation detail...

    def __len__(self) -> int:
        return len(self._items)


class CountingCollection(Collection):  # inheritance: depends on that detail
    def __init__(self) -> None:
        super().__init__()
        self.added = 0

    def add(self, item) -> None:
        self.added += 1
        super().add(item)

    def add_all(self, items) -> None:
        items = list(items)
        self.added += len(items)
        super().add_all(items)  # ...which calls our add() again


broken = CountingCollection()
broken.add_all(["a", "b", "c"])
print(broken.added)  # 6, not 3


class CountingWrapper:  # composition: depends only on the public interface
    def __init__(self, inner: Collection) -> None:
        self._inner = inner
        self.added = 0

    def add(self, item) -> None:
        self.added += 1
        self._inner.add(item)

    def add_all(self, items) -> None:
        items = list(items)
        self.added += len(items)
        self._inner.add_all(items)  # the inner add() is the inner object's business

    def __len__(self) -> int:
        return len(self._inner)


fixed = CountingWrapper(Collection())
fixed.add_all(["a", "b", "c"])
print(fixed.added)  # 3, whatever Collection.add_all does inside

class Collection<T> {
  protected items: T[] = [];

  add(item: T): void {
    this.items.push(item);
  }

  addAll(items: Iterable<T>): void {
    for (const item of items) this.add(item); // an implementation detail...
  }

  get size(): number {
    return this.items.length;
  }
}

class CountingCollection<T> extends Collection<T> {
  // Inheritance: depends on that detail.
  added = 0;

  override add(item: T): void {
    this.added++;
    super.add(item);
  }

  override addAll(items: Iterable<T>): void {
    const list = [...items];
    this.added += list.length;
    super.addAll(list); // ...which calls our add() again
  }
}

const broken = new CountingCollection<string>();
broken.addAll(["a", "b", "c"]);
console.log(broken.added); // 6, not 3

class CountingWrapper<T> {
  // Composition: depends only on the public interface.
  added = 0;

  constructor(private readonly inner: Collection<T>) {}

  add(item: T): void {
    this.added++;
    this.inner.add(item);
  }

  addAll(items: Iterable<T>): void {
    const list = [...items];
    this.added += list.length;
    this.inner.addAll(list); // the inner add() is the inner object's business
  }

  get size(): number {
    return this.inner.size;
  }
}

const fixed = new CountingWrapper(new Collection<string>());
fixed.addAll(["a", "b", "c"]);
console.log(fixed.added); // 3, whatever Collection.addAll does inside

import csv
import io
import json
from abc import ABC, abstractmethod
from typing import Iterable


class RowWriter(ABC):
    @abstractmethod
    def write(self, row: dict) -> None: ...

    @abstractmethod
    def getvalue(self) -> bytes: ...


class CsvWriter(RowWriter):
    def __init__(self) -> None:
        self._buffer = io.StringIO()
        self._writer: csv.DictWriter | None = None

    def write(self, row: dict) -> None:
        if self._writer is None:  # the header comes from the first row
            self._writer = csv.DictWriter(self._buffer, fieldnames=list(row))
            self._writer.writeheader()
        self._writer.writerow(row)

    def getvalue(self) -> bytes:
        return self._buffer.getvalue().encode()


class JsonLinesWriter(RowWriter):
    def __init__(self) -> None:
        self._lines: list[str] = []

    def write(self, row: dict) -> None:
        self._lines.append(json.dumps(row, default=str))

    def getvalue(self) -> bytes:
        return ("\n".join(self._lines) + "\n").encode()


class ReportJob(ABC):
    def run(self, rows: Iterable[dict]) -> bytes:
        writer = self.create_writer()  # the factory method
        for row in rows:
            writer.write(self.transform(row))
        return writer.getvalue()

    @abstractmethod
    def create_writer(self) -> RowWriter: ...

    def transform(self, row: dict) -> dict:  # a second, optional hook
        return row


class CsvReportJob(ReportJob):
    def create_writer(self) -> RowWriter:
        return CsvWriter()


class JsonLinesReportJob(ReportJob):
    def create_writer(self) -> RowWriter:
        return JsonLinesWriter()

    def transform(self, row: dict) -> dict:
        return {**row, "exported": True}


rows = [{"sku": "A-17", "qty": 2}, {"sku": "B-02", "qty": 1}]
print(CsvReportJob().run(rows).decode())
print(JsonLinesReportJob().run(rows).decode())

interface RowWriter {
  write(row: Record<string, unknown>): void;
  getValue(): string;
}

class CsvWriter implements RowWriter {
  private columns?: string[];
  private readonly lines: string[] = [];

  write(row: Record<string, unknown>): void {
    if (!this.columns) {
      // The header comes from the first row.
      this.columns = Object.keys(row);
      this.lines.push(this.columns.join(","));
    }
    this.lines.push(this.columns.map((c) => `"${String(row[c]).replaceAll('"', '""')}"`).join(","));
  }

  getValue(): string {
    return this.lines.join("\n");
  }
}

class JsonLinesWriter implements RowWriter {
  private readonly lines: string[] = [];

  write(row: Record<string, unknown>): void {
    this.lines.push(JSON.stringify(row));
  }

  getValue(): string {
    return this.lines.join("\n") + "\n";
  }
}

abstract class ReportJob {
  run(rows: Iterable<Record<string, unknown>>): string {
    const writer = this.createWriter(); // the factory method
    for (const row of rows) writer.write(this.transform(row));
    return writer.getValue();
  }

  protected abstract createWriter(): RowWriter;

  protected transform(row: Record<string, unknown>): Record<string, unknown> {
    return row; // a second, optional hook
  }
}

class CsvReportJob extends ReportJob {
  protected createWriter(): RowWriter {
    return new CsvWriter();
  }
}

class JsonLinesReportJob extends ReportJob {
  protected createWriter(): RowWriter {
    return new JsonLinesWriter();
  }

  protected override transform(row: Record<string, unknown>) {
    return { ...row, exported: true };
  }
}

const rows = [{ sku: "A-17", qty: 2 }, { sku: "B-02", qty: 1 }];
console.log(new CsvReportJob().run(rows));
console.log(new JsonLinesReportJob().run(rows));

import os
from collections import defaultdict, deque
from typing import Protocol


class BlobStore(Protocol):
    def put(self, key: str, data: bytes) -> None: ...
    def get(self, key: str) -> bytes: ...


class Queue(Protocol):
    def send(self, body: str) -> None: ...
    def receive(self) -> str | None: ...


class SecretStore(Protocol):
    def get(self, name: str) -> str: ...


class CloudFactory(Protocol):
    def blob_store(self) -> BlobStore: ...
    def queue(self, name: str) -> Queue: ...
    def secrets(self) -> SecretStore: ...


# --- the local family: in memory, for tests and laptops -----------------------
class InMemoryBlobStore:
    def __init__(self) -> None:
        self._data: dict[str, bytes] = {}

    def put(self, key: str, data: bytes) -> None:
        self._data[key] = data

    def get(self, key: str) -> bytes:
        return self._data[key]


class InMemoryQueue:
    def __init__(self) -> None:
        self._messages: deque[str] = deque()

    def send(self, body: str) -> None:
        self._messages.append(body)

    def receive(self) -> str | None:
        return self._messages.popleft() if self._messages else None


class EnvSecretStore:
    def get(self, name: str) -> str:
        return os.environ[name]


class LocalFactory:
    def __init__(self) -> None:
        self._blobs = InMemoryBlobStore()
        self._queues: dict[str, InMemoryQueue] = defaultdict(InMemoryQueue)

    def blob_store(self) -> BlobStore:
        return self._blobs

    def queue(self, name: str) -> Queue:
        return self._queues[name]  # the same name gives the same queue

    def secrets(self) -> SecretStore:
        return EnvSecretStore()


# --- the AWS family: every product talks to the same account and region -------
class S3BlobStore:
    def __init__(self, s3, bucket: str) -> None:
        self._s3, self._bucket = s3, bucket

    def put(self, key: str, data: bytes) -> None:
        self._s3.put_object(Bucket=self._bucket, Key=key, Body=data)

    def get(self, key: str) -> bytes:
        return self._s3.get_object(Bucket=self._bucket, Key=key)["Body"].read()


class SqsQueue:
    def __init__(self, sqs, url: str) -> None:
        self._sqs, self._url = sqs, url

    def send(self, body: str) -> None:
        self._sqs.send_message(QueueUrl=self._url, MessageBody=body)

    def receive(self) -> str | None:
        messages = self._sqs.receive_message(QueueUrl=self._url, MaxNumberOfMessages=1).get("Messages", [])
        if not messages:
            return None
        self._sqs.delete_message(QueueUrl=self._url, ReceiptHandle=messages[0]["ReceiptHandle"])
        return messages[0]["Body"]


class SecretsManagerStore:
    def __init__(self, client) -> None:
        self._client = client

    def get(self, name: str) -> str:
        return self._client.get_secret_value(SecretId=name)["SecretString"]


class AwsFactory:
    def __init__(self, session, bucket: str, queue_urls: dict[str, str]) -> None:
        self._session, self._bucket, self._urls = session, bucket, queue_urls

    def blob_store(self) -> BlobStore:
        return S3BlobStore(self._session.client("s3"), self._bucket)

    def queue(self, name: str) -> Queue:
        return SqsQueue(self._session.client("sqs"), self._urls[name])

    def secrets(self) -> SecretStore:
        return SecretsManagerStore(self._session.client("secretsmanager"))

import { GetObjectCommand, PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
import { DeleteMessageCommand, ReceiveMessageCommand, SendMessageCommand, SQSClient } from "@aws-sdk/client-sqs";
import { GetSecretValueCommand, SecretsManagerClient } from "@aws-sdk/client-secrets-manager";

export interface BlobStore {
  put(key: string, data: Uint8Array): Promise<void>;
  get(key: string): Promise<Uint8Array>;
}
export interface Queue {
  send(body: string): Promise<void>;
  receive(): Promise<string | undefined>;
}
export interface SecretStore {
  get(name: string): Promise<string>;
}
export interface CloudFactory {
  blobStore(): BlobStore;
  queue(name: string): Queue;
  secrets(): SecretStore;
}

// --- the local family: in memory, for tests and laptops ---------------------
class InMemoryBlobStore implements BlobStore {
  private readonly data = new Map<string, Uint8Array>();
  async put(key: string, data: Uint8Array) {
    this.data.set(key, data);
  }
  async get(key: string) {
    const value = this.data.get(key);
    if (!value) throw new Error(`no such key: ${key}`);
    return value;
  }
}

class InMemoryQueue implements Queue {
  private readonly messages: string[] = [];
  async send(body: string) {
    this.messages.push(body);
  }
  async receive() {
    return this.messages.shift();
  }
}

class EnvSecretStore implements SecretStore {
  async get(name: string) {
    const value = process.env[name];
    if (value === undefined) throw new Error(`missing secret ${name}`);
    return value;
  }
}

export class LocalFactory implements CloudFactory {
  private readonly blobs = new InMemoryBlobStore();
  private readonly queues = new Map<string, InMemoryQueue>();

  blobStore() {
    return this.blobs;
  }
  queue(name: string) {
    if (!this.queues.has(name)) this.queues.set(name, new InMemoryQueue()); // same name, same queue
    return this.queues.get(name)!;
  }
  secrets() {
    return new EnvSecretStore();
  }
}

// --- the AWS family: every product talks to the same account and region -----
class S3BlobStore implements BlobStore {
  constructor(private readonly s3: S3Client, private readonly bucket: string) {}
  async put(key: string, data: Uint8Array) {
    await this.s3.send(new PutObjectCommand({ Bucket: this.bucket, Key: key, Body: data }));
  }
  async get(key: string) {
    const out = await this.s3.send(new GetObjectCommand({ Bucket: this.bucket, Key: key }));
    return out.Body!.transformToByteArray();
  }
}

class SqsQueue implements Queue {
  constructor(private readonly sqs: SQSClient, private readonly url: string) {}
  async send(body: string) {
    await this.sqs.send(new SendMessageCommand({ QueueUrl: this.url, MessageBody: body }));
  }
  async receive() {
    const out = await this.sqs.send(new ReceiveMessageCommand({ QueueUrl: this.url, MaxNumberOfMessages: 1 }));
    const message = out.Messages?.[0];
    if (!message) return undefined;
    await this.sqs.send(new DeleteMessageCommand({ QueueUrl: this.url, ReceiptHandle: message.ReceiptHandle }));
    return message.Body;
  }
}

class SecretsManagerStore implements SecretStore {
  constructor(private readonly client: SecretsManagerClient) {}
  async get(name: string) {
    const out = await this.client.send(new GetSecretValueCommand({ SecretId: name }));
    return out.SecretString!;
  }
}

export class AwsFactory implements CloudFactory {
  constructor(
    private readonly region: string,
    private readonly bucket: string,
    private readonly queueUrls: Record<string, string>,
  ) {}

  blobStore() {
    return new S3BlobStore(new S3Client({ region: this.region }), this.bucket);
  }
  queue(name: string) {
    return new SqsQueue(new SQSClient({ region: this.region }), this.queueUrls[name]);
  }
  secrets() {
    return new SecretsManagerStore(new SecretsManagerClient({ region: this.region }));
  }
}

import html
from typing import Protocol


class ReportBuilder(Protocol):
    def title(self, text: str) -> None: ...
    def section(self, heading: str) -> None: ...
    def table(self, rows: list[dict]) -> None: ...
    def note(self, text: str) -> None: ...
    def result(self) -> str: ...


class MarkdownBuilder:
    def __init__(self) -> None:
        self._parts: list[str] = []

    def title(self, text: str) -> None:
        self._parts.append(f"# {text}\n")

    def section(self, heading: str) -> None:
        self._parts.append(f"\n## {heading}\n")

    def table(self, rows: list[dict]) -> None:
        cols = list(rows[0])
        self._parts.append("| " + " | ".join(cols) + " |")
        self._parts.append("| " + " | ".join("---" for _ in cols) + " |")
        self._parts += ["| " + " | ".join(str(r[c]) for c in cols) + " |" for r in rows]

    def note(self, text: str) -> None:
        self._parts.append(f"\n> {text}")

    def result(self) -> str:
        return "\n".join(self._parts)


class HtmlBuilder:
    def __init__(self) -> None:
        self._parts: list[str] = []

    def title(self, text: str) -> None:
        self._parts.append(f"<h1>{html.escape(text)}</h1>")  # data is untrusted: always escape

    def section(self, heading: str) -> None:
        self._parts.append(f"<h2>{html.escape(heading)}</h2>")

    def table(self, rows: list[dict]) -> None:
        cols = list(rows[0])
        head = "".join(f"<th>{html.escape(c)}</th>" for c in cols)
        body = "".join("<tr>" + "".join(f"<td>{html.escape(str(r[c]))}</td>" for c in cols) + "</tr>" for r in rows)
        self._parts.append(f"<table><tr>{head}</tr>{body}</table>")

    def note(self, text: str) -> None:
        self._parts.append(f"<p class='note'>{html.escape(text)}</p>")

    def result(self) -> str:
        return "\n".join(self._parts)


class ReportDirector:
    """Knows the order of the steps; knows nothing about any format."""

    def build(self, builder: ReportBuilder, sales: list[dict]) -> str:
        builder.title("Weekly sales")
        builder.section("By region")
        builder.table(sales)
        builder.note(f"{len(sales)} regions reported")
        return builder.result()


sales = [{"region": "EU", "total": 1200}, {"region": "US <West>", "total": 900}]
print(ReportDirector().build(MarkdownBuilder(), sales))
print(ReportDirector().build(HtmlBuilder(), sales))  # "<West>" comes out escaped

interface ReportBuilder {
  title(text: string): void;
  section(heading: string): void;
  table(rows: Record<string, unknown>[]): void;
  note(text: string): void;
  result(): string;
}

const escapeHtml = (s: string) =>
  s.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]!);

class MarkdownBuilder implements ReportBuilder {
  private readonly parts: string[] = [];
  title(text: string) {
    this.parts.push(`# ${text}\n`);
  }
  section(heading: string) {
    this.parts.push(`\n## ${heading}\n`);
  }
  table(rows: Record<string, unknown>[]) {
    const cols = Object.keys(rows[0]);
    this.parts.push(`| ${cols.join(" | ")} |`, `| ${cols.map(() => "---").join(" | ")} |`);
    for (const r of rows) this.parts.push(`| ${cols.map((c) => String(r[c])).join(" | ")} |`);
  }
  note(text: string) {
    this.parts.push(`\n> ${text}`);
  }
  result() {
    return this.parts.join("\n");
  }
}

class HtmlBuilder implements ReportBuilder {
  private readonly parts: string[] = [];
  title(text: string) {
    this.parts.push(`<h1>${escapeHtml(text)}</h1>`); // data is untrusted: always escape
  }
  section(heading: string) {
    this.parts.push(`<h2>${escapeHtml(heading)}</h2>`);
  }
  table(rows: Record<string, unknown>[]) {
    const cols = Object.keys(rows[0]);
    const head = cols.map((c) => `<th>${escapeHtml(c)}</th>`).join("");
    const body = rows.map((r) => `<tr>${cols.map((c) => `<td>${escapeHtml(String(r[c]))}</td>`).join("")}</tr>`).join("");
    this.parts.push(`<table><tr>${head}</tr>${body}</table>`);
  }
  note(text: string) {
    this.parts.push(`<p class="note">${escapeHtml(text)}</p>`);
  }
  result() {
    return this.parts.join("\n");
  }
}

class ReportDirector {
  // Knows the order of the steps; knows nothing about any format.
  build(builder: ReportBuilder, sales: Record<string, unknown>[]): string {
    builder.title("Weekly sales");
    builder.section("By region");
    builder.table(sales);
    builder.note(`${sales.length} regions reported`);
    return builder.result();
  }
}

const sales = [{ region: "EU", total: 1200 }, { region: "US <West>", total: 900 }];
console.log(new ReportDirector().build(new MarkdownBuilder(), sales));
console.log(new ReportDirector().build(new HtmlBuilder(), sales)); // "<West>" comes out escaped

import copy
from dataclasses import dataclass, field
from typing import ClassVar


class TemplateCache:
    """Expensive to build, read-only once built: safe to share between clones."""

    def __init__(self, names: list[str]) -> None:
        self.templates = {n: f"<template {n}>" for n in names}


@dataclass
class TenantConfig:
    name: str
    features: dict[str, bool] = field(default_factory=dict)
    limits: dict[str, int] = field(default_factory=dict)
    regions: list[str] = field(default_factory=list)
    templates: TemplateCache | None = None

    _shared: ClassVar[frozenset[str]] = frozenset({"templates"})

    def __deepcopy__(self, memo: dict) -> "TenantConfig":
        cls = type(self)
        clone = cls.__new__(cls)
        memo[id(self)] = clone  # register first, so cycles resolve to this copy
        for name, value in vars(self).items():
            setattr(clone, name, value if name in self._shared else copy.deepcopy(value, memo))
        return clone


class PrototypeRegistry:
    def __init__(self) -> None:
        self._prototypes: dict[str, TenantConfig] = {}

    def register(self, key: str, prototype: TenantConfig) -> None:
        self._prototypes[key] = prototype

    def create(self, key: str, **overrides) -> TenantConfig:
        clone = copy.deepcopy(self._prototypes[key])
        for attr, value in overrides.items():
            setattr(clone, attr, value)
        return clone


shared = TemplateCache(["welcome", "invoice", "reset-password"])
registry = PrototypeRegistry()
registry.register("starter", TenantConfig("starter", {"sso": False, "beta": False}, {"seats": 5}, ["eu-west-1"], shared))
registry.register("enterprise", TenantConfig("enterprise", {"sso": True, "beta": False}, {"seats": 500}, ["eu-west-1", "us-east-1"], shared))

acme = registry.create("enterprise", name="acme")
acme.features["beta"] = True                                     # changes acme only
assert registry.create("enterprise").features["beta"] is False   # the prototype is untouched
assert acme.templates is shared                                  # the expensive part is shared on purpose

class TemplateCache {
  // Expensive to build, read-only once built: safe to share between clones.
  readonly templates: ReadonlyMap<string, string>;
  constructor(names: string[]) {
    this.templates = new Map(names.map((n) => [n, `<template ${n}>`]));
  }
}

class TenantConfig {
  constructor(
    public name: string,
    public features: Record<string, boolean>,
    public limits: Record<string, number>,
    public regions: string[],
    readonly templates: TemplateCache, // shared on purpose
  ) {}

  // structuredClone(this) would return a plain object and lose the class and its
  // methods, so clone deliberately: deep-copy data, share the read-only cache.
  clone(): TenantConfig {
    return new TenantConfig(
      this.name,
      structuredClone(this.features),
      structuredClone(this.limits),
      [...this.regions],
      this.templates,
    );
  }
}

class PrototypeRegistry {
  private readonly prototypes = new Map<string, TenantConfig>();

  register(key: string, prototype: TenantConfig): void {
    this.prototypes.set(key, prototype);
  }

  create(key: string, overrides: Partial<Pick<TenantConfig, "name">> = {}): TenantConfig {
    const prototype = this.prototypes.get(key);
    if (!prototype) throw new Error(`no prototype "${key}"`);
    return Object.assign(prototype.clone(), overrides);
  }
}

const shared = new TemplateCache(["welcome", "invoice", "reset-password"]);
const registry = new PrototypeRegistry();
registry.register("starter", new TenantConfig("starter", { sso: false, beta: false }, { seats: 5 }, ["eu-west-1"], shared));
registry.register("enterprise", new TenantConfig("enterprise", { sso: true, beta: false }, { seats: 500 }, ["eu-west-1", "us-east-1"], shared));

const acme = registry.create("enterprise", { name: "acme" });
acme.features.beta = true; // changes acme only
console.assert(registry.create("enterprise").features.beta === false); // the prototype is untouched
console.assert(acme.templates === shared); // the expensive part is shared on purpose

import os
import threading
from typing import ClassVar


def load_settings() -> dict[str, str]:
    return {"region": os.environ.get("REGION", "eu-west-1")}


class Settings:
    _instance: ClassVar["Settings | None"] = None
    _lock: ClassVar[threading.Lock] = threading.Lock()

    def __init__(self, values: dict[str, str]) -> None:
        self.values = values

    @classmethod
    def instance(cls) -> "Settings":
        if cls._instance is None:  # fast path: no lock once created
            with cls._lock:
                if cls._instance is None:  # re-check: another thread may have won the race
                    cls._instance = cls(load_settings())
        return cls._instance

    @classmethod
    def reset_for_tests(cls) -> None:
        with cls._lock:
            cls._instance = None


# The idiomatic alternative: the module itself is the singleton.
# settings.py
#     values = load_settings()          # runs once, on first import
# anywhere.py
#     from settings import values

function loadSettings(): Record<string, string> {
  return { region: process.env.REGION ?? "eu-west-1" };
}

export class Settings {
  private static instance?: Settings;

  private constructor(readonly values: Readonly<Record<string, string>>) {}

  static get(): Settings {
    // JavaScript runs one thread per isolate, so synchronous creation can't race.
    return (Settings.instance ??= new Settings(Object.freeze(loadSettings())));
  }

  static resetForTests(): void {
    Settings.instance = undefined;
  }
}

// The idiomatic alternative: the module itself is the singleton.
// settings.ts
//   export const values = Object.freeze(loadSettings());   // runs once, on first import

import time
from enum import Enum
from typing import Any, Callable, TypeVar

T = TypeVar("T")


class Lifetime(Enum):
    SINGLETON = "singleton"
    SCOPED = "scoped"
    TRANSIENT = "transient"


class Container:
    def __init__(self) -> None:
        self.providers: dict[type, tuple[Callable[["Scope"], Any], Lifetime]] = {}
        self.singletons: dict[type, Any] = {}

    def register(self, token: type[T], factory: Callable[["Scope"], T], lifetime: Lifetime) -> None:
        self.providers[token] = (factory, lifetime)

    def scope(self) -> "Scope":
        return Scope(self)


class Scope:
    """One per request. Scoped instances live here; singletons live on the container."""

    def __init__(self, container: Container) -> None:
        self._container = container
        self._scoped: dict[type, Any] = {}
        self._resolving: list[type] = []  # the current chain, for cycle and lifetime checks

    def resolve(self, token: type[T]) -> T:
        if token not in self._container.providers:
            raise LookupError(f"nothing registered for {token.__name__}")
        if token in self._resolving:
            chain = " -> ".join(t.__name__ for t in [*self._resolving, token])
            raise RuntimeError(f"dependency cycle: {chain}")
        factory, lifetime = self._container.providers[token]
        if lifetime is Lifetime.SCOPED:
            for parent in self._resolving:
                if self._container.providers[parent][1] is Lifetime.SINGLETON:
                    raise RuntimeError(f"captive dependency: singleton {parent.__name__} "
                                       f"would keep scoped {token.__name__} alive forever")
        cache = {Lifetime.SINGLETON: self._container.singletons, Lifetime.SCOPED: self._scoped}.get(lifetime)
        if cache is not None and token in cache:
            return cache[token]
        self._resolving.append(token)
        try:
            instance = factory(self)
        finally:
            self._resolving.pop()
        if cache is not None:
            cache[token] = instance
        return instance


# --- wiring an application -----------------------------------------------------
class Database:
    def __init__(self, url: str) -> None:
        self.url = url


class Clock:
    def now(self) -> float:
        return time.time()


class UnitOfWork:
    def __init__(self, db: Database) -> None:
        self.db = db


class OrderService:
    def __init__(self, uow: UnitOfWork, clock: Clock) -> None:
        self.uow, self.clock = uow, clock


container = Container()
container.register(Database, lambda s: Database("postgres://orders"), Lifetime.SINGLETON)
container.register(Clock, lambda s: Clock(), Lifetime.SINGLETON)
container.register(UnitOfWork, lambda s: UnitOfWork(s.resolve(Database)), Lifetime.SCOPED)
container.register(OrderService, lambda s: OrderService(s.resolve(UnitOfWork), s.resolve(Clock)), Lifetime.TRANSIENT)

request_1, request_2 = container.scope(), container.scope()
a, b = request_1.resolve(OrderService), request_1.resolve(OrderService)
c = request_2.resolve(OrderService)
assert a is not b                 # transient: new every time
assert a.uow is b.uow             # scoped: shared within one request
assert a.uow is not c.uow         # ...but not across requests
assert a.uow.db is c.uow.db       # singleton: shared by everyone

type Ctor<T> = abstract new (...args: never[]) => T;
type Lifetime = "singleton" | "scoped" | "transient";
type Factory<T> = (scope: Scope) => T;

export class Container {
  readonly providers = new Map<Ctor<unknown>, { factory: Factory<unknown>; lifetime: Lifetime }>();
  readonly singletons = new Map<Ctor<unknown>, unknown>();

  register<T>(token: Ctor<T>, factory: Factory<T>, lifetime: Lifetime): this {
    this.providers.set(token, { factory, lifetime });
    return this;
  }

  scope(): Scope {
    return new Scope(this);
  }
}

export class Scope {
  // One per request. Scoped instances live here; singletons live on the container.
  private readonly scoped = new Map<Ctor<unknown>, unknown>();
  private readonly resolving: Ctor<unknown>[] = []; // the current chain, for cycle and lifetime checks

  constructor(private readonly container: Container) {}

  resolve<T>(token: Ctor<T>): T {
    const provider = this.container.providers.get(token);
    if (!provider) throw new Error(`nothing registered for ${token.name}`);
    if (this.resolving.includes(token)) {
      throw new Error(`dependency cycle: ${[...this.resolving, token].map((t) => t.name).join(" -> ")}`);
    }
    if (provider.lifetime === "scoped") {
      const owner = this.resolving.find((t) => this.container.providers.get(t)?.lifetime === "singleton");
      if (owner) throw new Error(`captive dependency: singleton ${owner.name} would keep scoped ${token.name} alive forever`);
    }
    const cache =
      provider.lifetime === "singleton" ? this.container.singletons : provider.lifetime === "scoped" ? this.scoped : undefined;
    if (cache?.has(token)) return cache.get(token) as T;
    this.resolving.push(token);
    try {
      const instance = provider.factory(this) as T;
      cache?.set(token, instance);
      return instance;
    } finally {
      this.resolving.pop();
    }
  }
}

// --- wiring an application ---------------------------------------------------
class Database {
  constructor(readonly url: string) {}
}
class Clock {
  now(): number {
    return Date.now();
  }
}
class UnitOfWork {
  constructor(readonly db: Database) {}
}
class OrderService {
  constructor(readonly uow: UnitOfWork, readonly clock: Clock) {}
}

const container = new Container()
  .register(Database, () => new Database("postgres://orders"), "singleton")
  .register(Clock, () => new Clock(), "singleton")
  .register(UnitOfWork, (s) => new UnitOfWork(s.resolve(Database)), "scoped")
  .register(OrderService, (s) => new OrderService(s.resolve(UnitOfWork), s.resolve(Clock)), "transient");

const request1 = container.scope();
const request2 = container.scope();
const [a, b, c] = [request1.resolve(OrderService), request1.resolve(OrderService), request2.resolve(OrderService)];
console.assert(a !== b); // transient: new every time
console.assert(a.uow === b.uow); // scoped: shared within one request
console.assert(a.uow !== c.uow); // ...but not across requests
console.assert(a.uow.db === c.uow.db); // singleton: shared by everyone

from dataclasses import dataclass
from decimal import Decimal
from typing import Protocol


# --- the Target: our interface, our units (integer cents), our errors ----------
class CardDeclined(Exception):
    pass


@dataclass(frozen=True)
class Charge:
    reference: str
    amount_cents: int


class PaymentGateway(Protocol):
    def charge(self, amount_cents: int, currency: str) -> Charge: ...


# --- the Adaptee: a legacy client with a different shape ------------------------
class LegacyPayClient:
    def make_payment(self, amount: float, curr: str) -> dict:
        """Takes dollars as a float and a lower-case currency; returns a status dict."""
        if amount > 10_000:
            return {"status": "DECLINED", "why": "limit"}
        return {"status": "OK", "ref": f"LP-{int(amount * 100)}"}


# --- object adapter: holds the adaptee (the default choice) --------------------
class LegacyPayAdapter:
    def __init__(self, client: LegacyPayClient) -> None:
        self._client = client

    def charge(self, amount_cents: int, currency: str) -> Charge:
        dollars = Decimal(amount_cents) / 100  # units: cents -> dollars, exactly
        result = self._client.make_payment(float(dollars), currency.lower())
        if result["status"] != "OK":  # errors: status strings -> our exception
            raise CardDeclined(result.get("why", "unknown"))
        return Charge(reference=result["ref"], amount_cents=amount_cents)


# --- class adapter: inherits from the adaptee (Python only) --------------------
class LegacyPayClassAdapter(LegacyPayClient):
    def charge(self, amount_cents: int, currency: str) -> Charge:
        result = self.make_payment(float(Decimal(amount_cents) / 100), currency.lower())
        if result["status"] != "OK":
            raise CardDeclined(result.get("why", "unknown"))
        return Charge(result["ref"], amount_cents)


gateway: PaymentGateway = LegacyPayAdapter(LegacyPayClient())
print(gateway.charge(4_250, "USD"))  # Charge(reference='LP-4250', amount_cents=4250)

// --- the Target: our interface, our units (integer cents), our errors --------
export class CardDeclined extends Error {}

export interface Charge {
  readonly reference: string;
  readonly amountCents: number;
}

export interface PaymentGateway {
  charge(amountCents: number, currency: string): Promise<Charge>;
}

// --- the Adaptee: a legacy client with a different shape ----------------------
type LegacyResult = { status: "OK"; ref: string } | { status: "DECLINED"; why: string };

class LegacyPayClient {
  // Takes dollars as a number and a lower-case currency; returns a status object.
  async makePayment(amount: number, curr: string): Promise<LegacyResult> {
    return amount > 10_000 ? { status: "DECLINED", why: "limit" } : { status: "OK", ref: `LP-${Math.round(amount * 100)}` };
  }
}

// --- object adapter: the only form TypeScript supports -------------------------
export class LegacyPayAdapter implements PaymentGateway {
  constructor(private readonly client: LegacyPayClient) {}

  async charge(amountCents: number, currency: string): Promise<Charge> {
    const result = await this.client.makePayment(amountCents / 100, currency.toLowerCase()); // units
    if (result.status !== "OK") throw new CardDeclined(result.why); // errors
    return { reference: result.ref, amountCents };
  }
}

const gateway: PaymentGateway = new LegacyPayAdapter(new LegacyPayClient());
console.log(await gateway.charge(4250, "USD")); // { reference: 'LP-4250', amountCents: 4250 }

from abc import ABC, abstractmethod
from dataclasses import dataclass


# --- implementor: the platform's primitive operations ---------------------------
class Channel(ABC):
    max_length: int = 10_000

    @abstractmethod
    def send(self, to: str, subject: str, body: str) -> None: ...


class EmailChannel(Channel):
    def send(self, to: str, subject: str, body: str) -> None:
        print(f"[email] to={to} subject={subject!r}\n{body}")


class SmsChannel(Channel):
    max_length = 160

    def send(self, to: str, subject: str, body: str) -> None:
        print(f"[sms] to={to}: {body}")  # SMS has no subject line


class SlackChannel(Channel):
    max_length = 4_000

    def send(self, to: str, subject: str, body: str) -> None:
        print(f"[slack] {to}: *{subject}* {body}")


# --- abstraction: high-level operations built from the primitives ---------------
class Notification(ABC):
    def __init__(self, channel: Channel) -> None:
        self.channel = channel  # the bridge

    def fit(self, text: str) -> str:
        limit = self.channel.max_length
        return text if len(text) <= limit else text[: limit - 1] + "…"

    @abstractmethod
    def notify(self, to: str) -> None: ...


@dataclass
class Incident:
    service: str
    summary: str


class Alert(Notification):
    def __init__(self, channel: Channel, incident: Incident) -> None:
        super().__init__(channel)
        self.incident = incident

    def notify(self, to: str) -> None:
        subject = f"ALERT {self.incident.service}"
        self.channel.send(to, subject, self.fit(f"{subject}: {self.incident.summary}"))


class Digest(Notification):
    def __init__(self, channel: Channel, items: list[str]) -> None:
        super().__init__(channel)
        self.items = items

    def notify(self, to: str) -> None:
        body = "\n".join(f"- {item}" for item in self.items)
        self.channel.send(to, f"Your digest ({len(self.items)} items)", self.fit(body))


Alert(SmsChannel(), Incident("payments", "p99 latency above 2s for 5 minutes")).notify("+44 7700 900123")
Digest(EmailChannel(), ["3 new orders", "1 refund"]).notify("ops@example.com")

// --- implementor: the platform's primitive operations -------------------------
interface Channel {
  readonly maxLength: number;
  send(to: string, subject: string, body: string): void;
}

class EmailChannel implements Channel {
  readonly maxLength = 10_000;
  send(to: string, subject: string, body: string) {
    console.log(`[email] to=${to} subject=${JSON.stringify(subject)}\n${body}`);
  }
}

class SmsChannel implements Channel {
  readonly maxLength = 160;
  send(to: string, _subject: string, body: string) {
    console.log(`[sms] to=${to}: ${body}`); // SMS has no subject line
  }
}

class SlackChannel implements Channel {
  readonly maxLength = 4_000;
  send(to: string, subject: string, body: string) {
    console.log(`[slack] ${to}: *${subject}* ${body}`);
  }
}

// --- abstraction: high-level operations built from the primitives -------------
abstract class Notification {
  constructor(protected readonly channel: Channel) {} // the bridge

  protected fit(text: string): string {
    const limit = this.channel.maxLength;
    return text.length <= limit ? text : text.slice(0, limit - 1) + "…";
  }

  abstract notify(to: string): void;
}

class Alert extends Notification {
  constructor(channel: Channel, private readonly incident: { service: string; summary: string }) {
    super(channel);
  }
  notify(to: string) {
    const subject = `ALERT ${this.incident.service}`;
    this.channel.send(to, subject, this.fit(`${subject}: ${this.incident.summary}`));
  }
}

class Digest extends Notification {
  constructor(channel: Channel, private readonly items: string[]) {
    super(channel);
  }
  notify(to: string) {
    const body = this.items.map((item) => `- ${item}`).join("\n");
    this.channel.send(to, `Your digest (${this.items.length} items)`, this.fit(body));
  }
}

new Alert(new SmsChannel(), { service: "payments", summary: "p99 latency above 2s for 5 minutes" }).notify("+44 7700 900123");
new Digest(new EmailChannel(), ["3 new orders", "1 refund"]).notify("ops@example.com");

from __future__ import annotations

from abc import ABC, abstractmethod
from decimal import ROUND_HALF_UP, Decimal
from typing import Iterator

CENT = Decimal("0.01")


class Item(ABC):
    def __init__(self, name: str) -> None:
        self.name = name

    @abstractmethod
    def price(self) -> Decimal: ...

    @abstractmethod
    def leaves(self) -> Iterator[Product]: ...


class Product(Item):  # leaf
    def __init__(self, name: str, price: str) -> None:
        super().__init__(name)
        self._price = Decimal(price)

    def price(self) -> Decimal:
        return self._price

    def leaves(self) -> Iterator[Product]:
        yield self


class Bundle(Item):  # composite: "safe" design, children only here
    def __init__(self, name: str, discount_percent: int = 0) -> None:
        super().__init__(name)
        self.discount = Decimal(discount_percent) / 100
        self.children: list[Item] = []

    def add(self, *items: Item) -> Bundle:
        for item in items:
            if item is self or (isinstance(item, Bundle) and item.contains(self)):
                raise ValueError(f"adding {item.name!r} would create a cycle")
            self.children.append(item)
        return self

    def contains(self, target: Item) -> bool:
        return any(child is target or (isinstance(child, Bundle) and child.contains(target)) for child in self.children)

    def price(self) -> Decimal:  # post-order: children first, then this node
        subtotal = sum((child.price() for child in self.children), Decimal("0"))
        return (subtotal * (1 - self.discount)).quantize(CENT, ROUND_HALF_UP)

    def leaves(self) -> Iterator[Product]:
        for child in self.children:
            yield from child.leaves()


audio = Bundle("Audio", discount_percent=5).add(Product("Headset", "30.00"), Product("Stand", "13.20"))
kit = Bundle("Starter kit", discount_percent=10).add(Product("Keyboard", "25.00"), audio)
print(kit.price())                          # 59.44
print([p.name for p in kit.leaves()])       # ['Keyboard', 'Headset', 'Stand']

interface Item {
  readonly name: string;
  pricePence(): number;
  leaves(): Generator<Product>;
}

class Product implements Item {
  // Leaf.
  constructor(readonly name: string, private readonly pence: number) {}

  pricePence(): number {
    return this.pence;
  }

  *leaves(): Generator<Product> {
    yield this;
  }
}

class Bundle implements Item {
  // Composite: "safe" design, children only here.
  private readonly children: Item[] = [];

  constructor(readonly name: string, private readonly discountPercent = 0) {}

  add(...items: Item[]): this {
    for (const item of items) {
      if (item === this || (item instanceof Bundle && item.contains(this))) {
        throw new Error(`adding "${item.name}" would create a cycle`);
      }
      this.children.push(item);
    }
    return this;
  }

  contains(target: Item): boolean {
    return this.children.some((c) => c === target || (c instanceof Bundle && c.contains(target)));
  }

  pricePence(): number {
    // Post-order: children first, then this node.
    const subtotal = this.children.reduce((sum, c) => sum + c.pricePence(), 0);
    return Math.round(subtotal * (1 - this.discountPercent / 100));
  }

  *leaves(): Generator<Product> {
    for (const child of this.children) yield* child.leaves();
  }
}

const audio = new Bundle("Audio", 5).add(new Product("Headset", 3000), new Product("Stand", 1320));
const kit = new Bundle("Starter kit", 10).add(new Product("Keyboard", 2500), audio);
console.log(kit.pricePence()); // 5944
console.log([...kit.leaves()].map((p) => p.name)); // ['Keyboard', 'Headset', 'Stand']

import hashlib
import zlib
from typing import Protocol


class Sink(Protocol):  # Component
    def write(self, data: bytes) -> None: ...
    def close(self) -> None: ...


class FileSink:  # ConcreteComponent: the real work
    def __init__(self, path: str) -> None:
        self._file = open(path, "wb")

    def write(self, data: bytes) -> None:
        self._file.write(data)

    def close(self) -> None:
        self._file.close()


class SinkDecorator:  # Decorator base: forwards everything by default
    def __init__(self, inner: Sink) -> None:
        self._inner = inner

    def write(self, data: bytes) -> None:
        self._inner.write(data)

    def close(self) -> None:
        self._inner.close()


class GzipSink(SinkDecorator):
    def __init__(self, inner: Sink) -> None:
        super().__init__(inner)
        self._zip = zlib.compressobj(wbits=31)  # 31 = gzip container format

    def write(self, data: bytes) -> None:
        self._inner.write(self._zip.compress(data))

    def close(self) -> None:
        self._inner.write(self._zip.flush())  # emit the trailer before closing
        super().close()


class ChecksumSink(SinkDecorator):
    def __init__(self, inner: Sink) -> None:
        super().__init__(inner)
        self.sha256 = hashlib.sha256()

    def write(self, data: bytes) -> None:
        self.sha256.update(data)
        super().write(data)


# Checksum OUTSIDE gzip: hashes the uncompressed CSV the reader will see.
sink = ChecksumSink(GzipSink(FileSink("orders.csv.gz")))
sink.write(b"id,total\n1,42.00\n2,13.50\n")
sink.close()
print("csv sha256:", sink.sha256.hexdigest())

# Checksum INSIDE gzip: hashes the compressed file as stored on disk.
inner = ChecksumSink(FileSink("orders2.csv.gz"))
sink2 = GzipSink(inner)
sink2.write(b"id,total\n1,42.00\n2,13.50\n")
sink2.close()
print("file sha256:", inner.sha256.hexdigest())

import { createHash, type Hash } from "node:crypto";
import { closeSync, openSync, writeSync } from "node:fs";
import { gzipSync } from "node:zlib";

interface Sink {
  // Component
  write(data: Uint8Array): void;
  close(): void;
}

class FileSink implements Sink {
  // ConcreteComponent: the real work.
  private readonly fd: number;
  constructor(path: string) {
    this.fd = openSync(path, "w");
  }
  write(data: Uint8Array) {
    writeSync(this.fd, data);
  }
  close() {
    closeSync(this.fd);
  }
}

abstract class SinkDecorator implements Sink {
  // Decorator base: forwards everything by default.
  constructor(protected readonly inner: Sink) {}
  write(data: Uint8Array) {
    this.inner.write(data);
  }
  close() {
    this.inner.close();
  }
}

class GzipSink extends SinkDecorator {
  private readonly chunks: Uint8Array[] = [];
  override write(data: Uint8Array) {
    this.chunks.push(data); // buffered: gzipSync needs the whole payload
  }
  override close() {
    this.inner.write(gzipSync(Buffer.concat(this.chunks)));
    super.close();
  }
}

class ChecksumSink extends SinkDecorator {
  readonly sha256: Hash = createHash("sha256");
  override write(data: Uint8Array) {
    this.sha256.update(data);
    super.write(data);
  }
}

// Checksum OUTSIDE gzip: hashes the uncompressed CSV the reader will see.
const sink = new ChecksumSink(new GzipSink(new FileSink("orders.csv.gz")));
sink.write(new TextEncoder().encode("id,total\n1,42.00\n2,13.50\n"));
sink.close();
console.log("csv sha256:", sink.sha256.digest("hex"));

import logging
from dataclasses import dataclass

log = logging.getLogger(__name__)


# --- the subsystem: useful parts, each with its own interface -----------------
class ObjectStore:
    def __init__(self) -> None:
        self.objects: dict[str, bytes] = {}

    def put(self, key: str, data: bytes) -> str:
        self.objects[key] = data
        return key

    def delete(self, key: str) -> None:
        self.objects.pop(key, None)


class Transcoder:
    def to_renditions(self, data: bytes) -> dict[str, bytes]:
        return {"720p": data[: len(data) // 2], "1080p": data}


class Thumbnailer:
    def frame_at(self, data: bytes, seconds: float) -> bytes:
        return data[:16]


class Cdn:
    def publish(self, keys: list[str]) -> str:
        return f"https://cdn.example.com/{keys[0].split('/')[1]}"


class Notifier:
    def followers(self, channel_id: str, url: str) -> None:
        log.info("notify followers of %s: %s", channel_id, url)


@dataclass(frozen=True)
class Published:
    video_id: str
    url: str


# --- the facade: one call that owns the order of the steps --------------------
class VideoPublishing:
    def __init__(self, store: ObjectStore, transcoder: Transcoder, thumbs: Thumbnailer, cdn: Cdn, notifier: Notifier) -> None:
        self._store, self._transcoder, self._thumbs = store, transcoder, thumbs
        self._cdn, self._notifier = cdn, notifier

    def publish(self, channel_id: str, video_id: str, raw: bytes) -> Published:
        written: list[str] = []
        try:
            written.append(self._store.put(f"videos/{video_id}/original", raw))
            for name, data in self._transcoder.to_renditions(raw).items():
                written.append(self._store.put(f"videos/{video_id}/{name}", data))
            thumb = self._thumbs.frame_at(raw, seconds=3.0)
            written.append(self._store.put(f"videos/{video_id}/thumb.jpg", thumb))
            url = self._cdn.publish(written)
        except Exception:
            for key in reversed(written):  # clean up what we created, newest first
                self._store.delete(key)
            raise  # never swallow the failure
        self._notifier.followers(channel_id, url)  # only after everything succeeded
        return Published(video_id, url)


facade = VideoPublishing(ObjectStore(), Transcoder(), Thumbnailer(), Cdn(), Notifier())
print(facade.publish("chan-9", "v-123", b"\x00" * 64))

// --- the subsystem: useful parts, each with its own interface ---------------
class ObjectStore {
  readonly objects = new Map<string, Uint8Array>();
  async put(key: string, data: Uint8Array): Promise<string> {
    this.objects.set(key, data);
    return key;
  }
  async delete(key: string): Promise<void> {
    this.objects.delete(key);
  }
}

class Transcoder {
  async toRenditions(data: Uint8Array): Promise<Record<string, Uint8Array>> {
    return { "720p": data.slice(0, data.length / 2), "1080p": data };
  }
}

class Thumbnailer {
  async frameAt(data: Uint8Array, _seconds: number): Promise<Uint8Array> {
    return data.slice(0, 16);
  }
}

class Cdn {
  async publish(keys: string[]): Promise<string> {
    return `https://cdn.example.com/${keys[0].split("/")[1]}`;
  }
}

class Notifier {
  async followers(channelId: string, url: string): Promise<void> {
    console.log(`notify followers of ${channelId}: ${url}`);
  }
}

// --- the facade: one call that owns the order of the steps ------------------
export class VideoPublishing {
  constructor(
    private readonly store: ObjectStore,
    private readonly transcoder: Transcoder,
    private readonly thumbs: Thumbnailer,
    private readonly cdn: Cdn,
    private readonly notifier: Notifier,
  ) {}

  async publish(channelId: string, videoId: string, raw: Uint8Array): Promise<{ videoId: string; url: string }> {
    const written: string[] = [];
    let url: string;
    try {
      written.push(await this.store.put(`videos/${videoId}/original`, raw));
      for (const [name, data] of Object.entries(await this.transcoder.toRenditions(raw))) {
        written.push(await this.store.put(`videos/${videoId}/${name}`, data));
      }
      written.push(await this.store.put(`videos/${videoId}/thumb.jpg`, await this.thumbs.frameAt(raw, 3)));
      url = await this.cdn.publish(written);
    } catch (err) {
      for (const key of written.reverse()) await this.store.delete(key); // clean up, newest first
      throw err; // never swallow the failure
    }
    await this.notifier.followers(channelId, url); // only after everything succeeded
    return { videoId, url };
  }
}

const facade = new VideoPublishing(new ObjectStore(), new Transcoder(), new Thumbnailer(), new Cdn(), new Notifier());
console.log(await facade.publish("chan-9", "v-123", new Uint8Array(64)));

from dataclasses import dataclass
from functools import cache


@dataclass(frozen=True, slots=True)
class MarkerStyle:  # flyweight: intrinsic, immutable, shared
    icon: str
    colour: str
    font: str
    icon_bytes: bytes  # the expensive part, loaded once per style

    def draw(self, lat: float, lon: float, label: str) -> str:  # extrinsic state passed in
        return f"{self.icon}@({lat:.4f},{lon:.4f}) {label} [{self.colour}]"


@cache  # the flyweight factory: one object per distinct intrinsic state
def marker_style(icon: str, colour: str, font: str = "Inter") -> MarkerStyle:
    return MarkerStyle(icon, colour, font, icon_bytes=b"\x89PNG" + b"\x00" * 24_000)


@dataclass(slots=True)  # extrinsic state: small, one per marker
class Marker:
    lat: float
    lon: float
    label: str
    style: MarkerStyle  # a reference, not a copy


markers = [
    Marker(51.5 + i * 1e-5, -0.12, f"store {i}", marker_style("pin", "red" if i % 2 else "blue"))
    for i in range(100_000)
]
styles = {id(m.style) for m in markers}
print(len(markers), "markers share", len(styles), "style objects")  # 100000 markers share 2 style objects
print(markers[7].style.draw(markers[7].lat, markers[7].lon, markers[7].label))

interface MarkerStyle {
  // Flyweight: intrinsic, immutable, shared.
  readonly icon: string;
  readonly colour: string;
  readonly font: string;
  readonly iconBytes: Uint8Array; // the expensive part, loaded once per style
}

const styles = new Map<string, MarkerStyle>();

// The flyweight factory: one object per distinct intrinsic state.
export function markerStyle(icon: string, colour: string, font = "Inter"): MarkerStyle {
  const key = `${icon}|${colour}|${font}`;
  let style = styles.get(key);
  if (!style) {
    style = Object.freeze({ icon, colour, font, iconBytes: new Uint8Array(24_000) });
    styles.set(key, style);
  }
  return style;
}

export function draw(style: MarkerStyle, lat: number, lon: number, label: string): string {
  return `${style.icon}@(${lat.toFixed(4)},${lon.toFixed(4)}) ${label} [${style.colour}]`; // extrinsic state passed in
}

interface Marker {
  // Extrinsic state: small, one per marker.
  lat: number;
  lon: number;
  label: string;
  style: MarkerStyle; // a reference, not a copy
}

const markers: Marker[] = Array.from({ length: 100_000 }, (_, i) => ({
  lat: 51.5 + i * 1e-5,
  lon: -0.12,
  label: `store ${i}`,
  style: markerStyle("pin", i % 2 ? "red" : "blue"),
}));
console.log(markers.length, "markers share", new Set(markers.map((m) => m.style)).size, "style objects");
console.log(draw(markers[7].style, markers[7].lat, markers[7].lon, markers[7].label));

from typing import Callable, Generic, TypeVar

T = TypeVar("T")


class Report:
    def __init__(self, report_id: str) -> None:
        print(f"loading 40 MB for {report_id}...")  # expensive
        self.report_id = report_id

    def export_pdf(self) -> bytes:
        return f"%PDF {self.report_id}".encode()


class LazyProxy(Generic[T]):
    """Virtual proxy: creates the real object on first attribute access."""

    def __init__(self, factory: Callable[[], T]) -> None:
        self._factory = factory
        self._target: T | None = None

    def _real(self) -> T:
        if self._target is None:
            self._target = self._factory()
        return self._target

    def __getattr__(self, name: str):  # called only for attributes the proxy lacks
        return getattr(self._real(), name)

    @property
    def __class__(self):  # isinstance() also consults __class__, so the proxy passes type checks
        return type(self._real())


class ReportAccessProxy:
    """Protection proxy: same interface, checks permission first."""

    def __init__(self, report: Report, permissions: set[str]) -> None:
        self._report, self._permissions = report, permissions

    def export_pdf(self) -> bytes:
        if "reports:export" not in self._permissions:
            raise PermissionError("missing permission reports:export")
        return self._report.export_pdf()


lazy = LazyProxy(lambda: Report("q3-sales"))  # nothing loaded yet
print(isinstance(lazy, Report))  # loads now, then True
print(ReportAccessProxy(lazy, {"reports:export"}).export_pdf())

class Report {
  constructor(readonly reportId: string) {
    console.log(`loading 40 MB for ${reportId}...`); // expensive
  }
  exportPdf(): string {
    return `%PDF ${this.reportId}`;
  }
}

// Virtual proxy with the built-in Proxy: creates the real object on first use.
export function lazy<T extends object>(factory: () => T): T {
  let target: T | undefined;
  const real = () => (target ??= factory());
  return new Proxy({} as T, {
    get(_shell, prop) {
      const value = Reflect.get(real(), prop);
      return typeof value === "function" ? value.bind(real()) : value; // bind: built-ins need their real `this`
    },
    set: (_shell, prop, value) => Reflect.set(real(), prop, value),
    has: (_shell, prop) => Reflect.has(real(), prop),
    getPrototypeOf: () => Reflect.getPrototypeOf(real()), // keeps instanceof working
  });
}

// Protection proxy, written as a class: same interface, checks permission first.
export class ReportAccessProxy {
  constructor(private readonly report: Pick<Report, "exportPdf">, private readonly permissions: Set<string>) {}

  exportPdf(): string {
    if (!this.permissions.has("reports:export")) throw new Error("missing permission reports:export");
    return this.report.exportPdf();
  }
}

// A generic read-only view: every nested object comes back wrapped too.
export function readonlyView<T extends object>(target: T): Readonly<T> {
  return new Proxy(target, {
    get(t, prop, receiver) {
      const value = Reflect.get(t, prop, receiver);
      return typeof value === "object" && value !== null ? readonlyView(value) : value;
    },
    set() {
      throw new TypeError("read-only");
    },
    deleteProperty() {
      throw new TypeError("read-only");
    },
  });
}

const report = lazy(() => new Report("q3-sales")); // nothing loaded yet
console.log(report instanceof Report); // loads now, then true
console.log(new ReportAccessProxy(report, new Set(["reports:export"])).exportPdf());

import gzip
import zlib
from dataclasses import dataclass
from typing import Callable, Protocol


class Compressor(Protocol):  # the Strategy interface
    name: str
    def compress(self, data: bytes) -> bytes: ...


@dataclass(frozen=True)
class Gzip:  # configured strategy: a class earns its keep here
    level: int = 6
    name: str = "gzip"

    def compress(self, data: bytes) -> bytes:
        return gzip.compress(data, compresslevel=self.level)


@dataclass(frozen=True)
class Identity:
    name: str = "identity"

    def compress(self, data: bytes) -> bytes:
        return data


# Selection lives in one table, not in the context.
BY_CONTENT_TYPE: dict[str, Compressor] = {
    "text/html": Gzip(level=9),
    "application/json": Gzip(level=6),
    "image/png": Identity(),  # already compressed: don't waste CPU
}


class ResponseWriter:  # the Context
    def __init__(self, choose: Callable[[str], Compressor]) -> None:
        self._choose = choose

    def encode(self, body: bytes, content_type: str) -> tuple[str, bytes]:
        strategy = self._choose(content_type)
        return strategy.name, strategy.compress(body)


writer = ResponseWriter(lambda ct: BY_CONTENT_TYPE.get(ct, Identity()))
encoding, payload = writer.encode(b"<p>hello</p>" * 100, "text/html")
print(encoding, len(payload))

# The same idea with a plain function as the strategy:
deflate: Callable[[bytes], bytes] = lambda data: zlib.compress(data, 6)

import { gzipSync } from "node:zlib";

interface Compressor {
  // The Strategy interface.
  readonly name: string;
  compress(data: Uint8Array): Uint8Array;
}

class Gzip implements Compressor {
  // Configured strategy: a class earns its keep here.
  readonly name = "gzip";
  constructor(private readonly level = 6) {}
  compress(data: Uint8Array) {
    return gzipSync(data, { level: this.level });
  }
}

const identity: Compressor = { name: "identity", compress: (data) => data }; // a plain object works too

// Selection lives in one table, not in the context.
const BY_CONTENT_TYPE: Record<string, Compressor> = {
  "text/html": new Gzip(9),
  "application/json": new Gzip(6),
  "image/png": identity, // already compressed: don't waste CPU
};

class ResponseWriter {
  // The Context.
  constructor(private readonly choose: (contentType: string) => Compressor) {}

  encode(body: Uint8Array, contentType: string): [string, Uint8Array] {
    const strategy = this.choose(contentType);
    return [strategy.name, strategy.compress(body)];
  }
}

const writer = new ResponseWriter((ct) => BY_CONTENT_TYPE[ct] ?? identity);
const [encoding, payload] = writer.encode(new TextEncoder().encode("<p>hello</p>".repeat(100)), "text/html");
console.log(encoding, payload.length);

import time
from abc import ABC, abstractmethod
from typing import Any, Iterable, final


class BatchJob(ABC):
    """The skeleton: timing, per-item error isolation and reporting are fixed here."""

    @final
    def run(self) -> dict[str, int]:
        started = time.perf_counter()
        ok = failed = 0
        self.before()                          # hook
        for item in self.fetch():              # abstract step
            try:
                self.process(item)             # abstract step
                ok += 1
            except Exception as exc:
                failed += 1
                self.on_error(item, exc)       # hook
        self.after(ok, failed)                 # hook
        return {"ok": ok, "failed": failed, "ms": round((time.perf_counter() - started) * 1000)}

    @abstractmethod
    def fetch(self) -> Iterable[Any]: ...

    @abstractmethod
    def process(self, item: Any) -> None: ...

    def before(self) -> None:  # hooks: safe defaults, override if needed
        pass

    def on_error(self, item: Any, exc: Exception) -> None:
        print(f"skipped {item!r}: {exc}")

    def after(self, ok: int, failed: int) -> None:
        pass


class PriceImport(BatchJob):
    def __init__(self, rows: list[str]) -> None:
        self.rows, self.prices = rows, {}

    def fetch(self) -> Iterable[str]:
        return self.rows

    def process(self, row: str) -> None:
        sku, price = row.split(",")
        self.prices[sku] = round(float(price) * 100)

    def after(self, ok: int, failed: int) -> None:
        print(f"imported {ok} prices, {failed} rejected")


print(PriceImport(["A-1,9.99", "bad row", "B-2,4.50"]).run())

export abstract class BatchJob<T> {
  // The skeleton: timing, per-item error isolation and reporting are fixed here.
  // TypeScript has no `final`; by convention, subclasses don't override run().
  async run(): Promise<{ ok: number; failed: number; ms: number }> {
    const started = performance.now();
    let ok = 0;
    let failed = 0;
    await this.before(); // hook
    for await (const item of this.fetch()) {
      // abstract step
      try {
        await this.process(item); // abstract step
        ok++;
      } catch (err) {
        failed++;
        this.onError(item, err as Error); // hook
      }
    }
    await this.after(ok, failed); // hook
    return { ok, failed, ms: Math.round(performance.now() - started) };
  }

  protected abstract fetch(): AsyncIterable<T> | Iterable<T>;
  protected abstract process(item: T): Promise<void> | void;

  // Hooks: safe defaults, override if needed.
  protected async before(): Promise<void> {}
  protected onError(item: T, err: Error): void {
    console.log(`skipped ${JSON.stringify(item)}: ${err.message}`);
  }
  protected async after(_ok: number, _failed: number): Promise<void> {}
}

class PriceImport extends BatchJob<string> {
  readonly prices = new Map<string, number>();
  constructor(private readonly rows: string[]) {
    super();
  }
  protected fetch() {
    return this.rows;
  }
  protected process(row: string) {
    const [sku, price] = row.split(",");
    if (price === undefined) throw new Error("expected sku,price");
    this.prices.set(sku, Math.round(Number(price) * 100));
  }
  protected override async after(ok: number, failed: number) {
    console.log(`imported ${ok} prices, ${failed} rejected`);
  }
}

console.log(await new PriceImport(["A-1,9.99", "bad row", "B-2,4.50"]).run());

import weakref
from typing import Callable, Generic, TypeVar

T = TypeVar("T")


class Observable(Generic[T]):
    """Holds a value; notifies observers (push model) when it changes."""

    def __init__(self, value: T) -> None:
        self._value = value
        self._functions: list[Callable[[T, T], None]] = []
        self._methods: list[weakref.WeakMethod] = []  # don't keep observer objects alive

    @property
    def value(self) -> T:
        return self._value

    def set(self, new: T) -> None:
        old, self._value = self._value, new
        if old == new:
            return  # no change, no notification
        self._methods = [ref for ref in self._methods if ref() is not None]  # drop dead observers
        for fn in [*self._functions, *(ref() for ref in self._methods)]:
            if fn is not None:
                fn(old, new)

    def subscribe(self, fn: Callable[[T, T], None]) -> Callable[[], None]:
        if hasattr(fn, "__self__"):  # a bound method: hold it weakly
            ref = weakref.WeakMethod(fn)
            self._methods.append(ref)
            return lambda: ref in self._methods and self._methods.remove(ref)
        self._functions.append(fn)
        return lambda: fn in self._functions and self._functions.remove(fn)


class PriceBadge:
    def __init__(self, price: Observable[int]) -> None:
        price.subscribe(self.render)  # weakly held: the badge can be garbage-collected

    def render(self, old: int, new: int) -> None:
        print(f"badge: {old} -> {new}")


price = Observable(999)
badge = PriceBadge(price)
stop_log = price.subscribe(lambda old, new: print(f"log: price changed by {new - old}"))
price.set(899)  # badge and log both notified
del badge  # no unsubscribe needed for the weakly held method
stop_log()
price.set(799)  # nobody is listening any more

type Listener<T> = (oldValue: T, newValue: T) => void;

export class Observable<T> {
  private readonly target = new EventTarget();

  constructor(private current: T) {}

  get value(): T {
    return this.current;
  }

  set(next: T): void {
    const previous = this.current;
    if (Object.is(previous, next)) return; // no change, no notification
    this.current = next;
    this.target.dispatchEvent(new CustomEvent("change", { detail: [previous, next] }));
  }

  // Unsubscribe by aborting the signal: one AbortController can end many subscriptions at once.
  subscribe(listener: Listener<T>, signal?: AbortSignal): void {
    this.target.addEventListener(
      "change",
      (event) => {
        const [previous, next] = (event as CustomEvent<[T, T]>).detail;
        listener(previous, next);
      },
      { signal },
    );
  }
}

const price = new Observable(999);
const widgetLifetime = new AbortController(); // tied to a UI component's lifetime

price.subscribe((old, next) => console.log(`badge: ${old} -> ${next}`), widgetLifetime.signal);
price.subscribe((old, next) => console.log(`log: price changed by ${next - old}`), widgetLifetime.signal);
price.set(899); // both notified
widgetLifetime.abort(); // the component unmounts: every subscription it made ends
price.set(799); // nobody is listening any more

from typing import Protocol


class Command(Protocol):
    def execute(self) -> None: ...
    def undo(self) -> None: ...


class Wallet:  # receiver
    def __init__(self, balance: int) -> None:
        self.balance = balance

    def debit(self, amount: int) -> None:
        if amount > self.balance:
            raise ValueError("insufficient funds")
        self.balance -= amount

    def credit(self, amount: int) -> None:
        self.balance += amount


class Inventory:  # receiver
    def __init__(self, stock: dict[str, int]) -> None:
        self.stock = stock

    def take(self, sku: str, qty: int) -> None:
        if self.stock.get(sku, 0) < qty:
            raise ValueError(f"out of stock: {sku}")
        self.stock[sku] -= qty

    def put_back(self, sku: str, qty: int) -> None:
        self.stock[sku] += qty


class Debit:
    def __init__(self, wallet: Wallet, amount: int) -> None:
        self.wallet, self.amount = wallet, amount

    def execute(self) -> None:
        self.wallet.debit(self.amount)

    def undo(self) -> None:
        self.wallet.credit(self.amount)  # the exact inverse


class Reserve:
    def __init__(self, inventory: Inventory, sku: str, qty: int) -> None:
        self.inventory, self.sku, self.qty = inventory, sku, qty

    def execute(self) -> None:
        self.inventory.take(self.sku, self.qty)

    def undo(self) -> None:
        self.inventory.put_back(self.sku, self.qty)


class Macro:
    """A command made of commands: all of them happen, or none do."""

    def __init__(self, *steps: Command) -> None:
        self.steps = steps
        self._done: list[Command] = []

    def execute(self) -> None:
        self._done = []
        try:
            for step in self.steps:
                step.execute()
                self._done.append(step)
        except Exception:
            self.undo()  # roll back the completed steps
            raise

    def undo(self) -> None:
        for step in reversed(self._done):
            step.undo()
        self._done = []


wallet, inventory = Wallet(50), Inventory({"A-17": 1})
purchase = Macro(Debit(wallet, 30), Reserve(inventory, "A-17", 2))  # asks for 2, only 1 in stock
try:
    purchase.execute()
except ValueError as err:
    print(err, "| balance restored to", wallet.balance)  # out of stock: A-17 | balance restored to 50

interface Command {
  execute(): void;
  undo(): void;
}

class Wallet {
  // Receiver.
  constructor(public balance: number) {}
  debit(amount: number) {
    if (amount > this.balance) throw new Error("insufficient funds");
    this.balance -= amount;
  }
  credit(amount: number) {
    this.balance += amount;
  }
}

class Inventory {
  // Receiver.
  constructor(private readonly stock: Map<string, number>) {}
  take(sku: string, qty: number) {
    if ((this.stock.get(sku) ?? 0) < qty) throw new Error(`out of stock: ${sku}`);
    this.stock.set(sku, this.stock.get(sku)! - qty);
  }
  putBack(sku: string, qty: number) {
    this.stock.set(sku, (this.stock.get(sku) ?? 0) + qty);
  }
}

const debit = (wallet: Wallet, amount: number): Command => ({
  execute: () => wallet.debit(amount),
  undo: () => wallet.credit(amount), // the exact inverse
});

const reserve = (inventory: Inventory, sku: string, qty: number): Command => ({
  execute: () => inventory.take(sku, qty),
  undo: () => inventory.putBack(sku, qty),
});

class Macro implements Command {
  // A command made of commands: all of them happen, or none do.
  private done: Command[] = [];
  constructor(private readonly steps: Command[]) {}

  execute(): void {
    this.done = [];
    try {
      for (const step of this.steps) {
        step.execute();
        this.done.push(step);
      }
    } catch (err) {
      this.undo(); // roll back the completed steps
      throw err;
    }
  }

  undo(): void {
    for (const step of this.done.reverse()) step.undo();
    this.done = [];
  }
}

const wallet = new Wallet(50);
const inventory = new Inventory(new Map([["A-17", 1]]));
try {
  new Macro([debit(wallet, 30), reserve(inventory, "A-17", 2)]).execute(); // asks for 2, only 1 in stock
} catch (err) {
  console.log((err as Error).message, "| balance restored to", wallet.balance); // out of stock: A-17 | ... 50
}

from dataclasses import dataclass, field
from enum import Enum
from typing import Callable


class S(Enum):
    TRIALING = "trialing"
    ACTIVE = "active"
    PAST_DUE = "past_due"
    CANCELLED = "cancelled"


class E(Enum):
    CONVERT = "convert"
    PAYMENT_FAILED = "payment_failed"
    PAYMENT_SUCCEEDED = "payment_succeeded"
    CANCEL = "cancel"


@dataclass
class Subscription:
    id: str
    state: S = S.TRIALING
    has_card: bool = False
    log: list[str] = field(default_factory=list)


Guard = Callable[[Subscription], bool]
Action = Callable[[Subscription], None]


@dataclass(frozen=True)
class Transition:
    target: S
    guard: Guard = lambda sub: True
    action: Action = lambda sub: None


TABLE: dict[tuple[S, E], Transition] = {
    (S.TRIALING, E.CONVERT): Transition(S.ACTIVE, guard=lambda s: s.has_card, action=lambda s: s.log.append("welcome email")),
    (S.TRIALING, E.CANCEL): Transition(S.CANCELLED),
    (S.ACTIVE, E.PAYMENT_FAILED): Transition(S.PAST_DUE, action=lambda s: s.log.append("dunning email")),
    (S.ACTIVE, E.CANCEL): Transition(S.CANCELLED, action=lambda s: s.log.append("exit survey")),
    (S.PAST_DUE, E.PAYMENT_SUCCEEDED): Transition(S.ACTIVE),
    (S.PAST_DUE, E.CANCEL): Transition(S.CANCELLED),
}


class InvalidTransition(Exception):
    pass


def fire(sub: Subscription, event: E) -> None:
    transition = TABLE.get((sub.state, event))
    if transition is None:
        raise InvalidTransition(f"{event.value} is not allowed from {sub.state.value}")
    if not transition.guard(sub):
        raise InvalidTransition(f"guard failed for {event.value} from {sub.state.value}")
    transition.action(sub)
    sub.state = transition.target


sub = Subscription("sub-1", has_card=True)
for event in (E.CONVERT, E.PAYMENT_FAILED, E.PAYMENT_SUCCEEDED, E.CANCEL):
    fire(sub, event)
print(sub.state, sub.log)  # S.CANCELLED ['welcome email', 'dunning email', 'exit survey']

type State = "trialing" | "active" | "past_due" | "cancelled";
type Event = "convert" | "payment_failed" | "payment_succeeded" | "cancel";

interface Subscription {
  id: string;
  state: State;
  hasCard: boolean;
  log: string[];
}

interface Transition {
  target: State;
  guard?: (sub: Subscription) => boolean;
  action?: (sub: Subscription) => void;
}

// Partial: only the legal (state, event) pairs appear. Anything missing is illegal.
const TABLE: Partial<Record<State, Partial<Record<Event, Transition>>>> = {
  trialing: {
    convert: { target: "active", guard: (s) => s.hasCard, action: (s) => s.log.push("welcome email") },
    cancel: { target: "cancelled" },
  },
  active: {
    payment_failed: { target: "past_due", action: (s) => s.log.push("dunning email") },
    cancel: { target: "cancelled", action: (s) => s.log.push("exit survey") },
  },
  past_due: {
    payment_succeeded: { target: "active" },
    cancel: { target: "cancelled" },
  },
};

export class InvalidTransition extends Error {}

export function fire(sub: Subscription, event: Event): void {
  const transition = TABLE[sub.state]?.[event];
  if (!transition) throw new InvalidTransition(`${event} is not allowed from ${sub.state}`);
  if (transition.guard && !transition.guard(sub)) throw new InvalidTransition(`guard failed for ${event} from ${sub.state}`);
  transition.action?.(sub);
  sub.state = transition.target;
}

const sub: Subscription = { id: "sub-1", state: "trialing", hasCard: true, log: [] };
for (const event of ["convert", "payment_failed", "payment_succeeded", "cancel"] as const) fire(sub, event);
console.log(sub.state, sub.log); // cancelled ['welcome email', 'dunning email', 'exit survey']

from __future__ import annotations

from dataclasses import dataclass
from decimal import Decimal


@dataclass(frozen=True)
class Expense:
    employee: str
    amount: Decimal
    category: str


class Approver:
    def __init__(self, name: str, limit: Decimal, successor: Approver | None = None) -> None:
        self.name, self.limit, self.successor = name, limit, successor

    def handle(self, expense: Expense) -> str:
        if self.can_approve(expense):
            return f"approved by {self.name}"
        if self.successor is None:  # the end of the chain must decide something
            return f"rejected: nobody may approve {expense.amount}"
        return self.successor.handle(expense)

    def can_approve(self, expense: Expense) -> bool:
        return expense.amount <= self.limit


class FinanceDirector(Approver):
    def can_approve(self, expense: Expense) -> bool:  # handlers can apply their own rules
        return expense.category != "gifts" and super().can_approve(expense)


def build_chain() -> Approver:
    board = Approver("the board", Decimal("1_000_000"))
    director = FinanceDirector("finance director", Decimal("50_000"), board)
    manager = Approver("manager", Decimal("5_000"), director)
    return Approver("team lead", Decimal("500"), manager)


chain = build_chain()
print(chain.handle(Expense("ana", Decimal("120"), "travel")))      # approved by team lead
print(chain.handle(Expense("ana", Decimal("12_000"), "travel")))   # approved by finance director
print(chain.handle(Expense("ana", Decimal("12_000"), "gifts")))    # approved by the board

interface Expense {
  employee: string;
  amountPence: number;
  category: string;
}

class Approver {
  constructor(
    readonly name: string,
    protected readonly limitPence: number,
    private readonly successor?: Approver,
  ) {}

  handle(expense: Expense): string {
    if (this.canApprove(expense)) return `approved by ${this.name}`;
    if (!this.successor) return `rejected: nobody may approve ${expense.amountPence}`; // the end must decide
    return this.successor.handle(expense);
  }

  protected canApprove(expense: Expense): boolean {
    return expense.amountPence <= this.limitPence;
  }
}

class FinanceDirector extends Approver {
  protected override canApprove(expense: Expense): boolean {
    return expense.category !== "gifts" && super.canApprove(expense); // handlers can apply their own rules
  }
}

function buildChain(): Approver {
  const board = new Approver("the board", 100_000_000);
  const director = new FinanceDirector("finance director", 5_000_000, board);
  const manager = new Approver("manager", 500_000, director);
  return new Approver("team lead", 50_000, manager);
}

const chain = buildChain();
console.log(chain.handle({ employee: "ana", amountPence: 12_000, category: "travel" })); // approved by team lead
console.log(chain.handle({ employee: "ana", amountPence: 1_200_000, category: "travel" })); // approved by finance director
console.log(chain.handle({ employee: "ana", amountPence: 1_200_000, category: "gifts" })); // approved by the board

from __future__ import annotations

from dataclasses import dataclass
from typing import Iterator


@dataclass
class Node:
    key: int
    left: Node | None = None
    right: Node | None = None


class InOrderIterator:
    """An external iterator written by hand: the state is an explicit stack."""

    def __init__(self, root: Node | None) -> None:
        self._stack: list[Node] = []
        self._push_left(root)

    def _push_left(self, node: Node | None) -> None:
        while node is not None:
            self._stack.append(node)
            node = node.left

    def __iter__(self) -> InOrderIterator:
        return self

    def __next__(self) -> int:
        if not self._stack:
            raise StopIteration
        node = self._stack.pop()
        self._push_left(node.right)
        return node.key


def in_order(node: Node | None) -> Iterator[int]:
    """The same traversal as a generator: the paused frame keeps the state."""
    if node is not None:
        yield from in_order(node.left)
        yield node.key
        yield from in_order(node.right)


class Tree:  # the aggregate: callers iterate without seeing nodes at all
    def __init__(self, root: Node | None) -> None:
        self.root = root

    def __iter__(self) -> Iterator[int]:
        return InOrderIterator(self.root)


tree = Tree(Node(8, Node(3, Node(1), Node(6)), Node(10, None, Node(14))))
print(list(tree))                       # [1, 3, 6, 8, 10, 14]
print(list(in_order(tree.root)))        # the same, from the generator
print(next(k for k in tree if k > 5))   # 6: stops early, the rest is never visited

interface TreeNode {
  key: number;
  left?: TreeNode;
  right?: TreeNode;
}

class InOrderIterator implements Iterator<number> {
  // An external iterator written by hand: the state is an explicit stack.
  private readonly stack: TreeNode[] = [];

  constructor(root?: TreeNode) {
    this.pushLeft(root);
  }

  private pushLeft(node?: TreeNode): void {
    for (; node; node = node.left) this.stack.push(node);
  }

  next(): IteratorResult<number> {
    const node = this.stack.pop();
    if (!node) return { done: true, value: undefined };
    this.pushLeft(node.right);
    return { done: false, value: node.key };
  }
}

// The same traversal as a generator: the paused frame keeps the state.
function* inOrder(node?: TreeNode): Generator<number> {
  if (!node) return;
  yield* inOrder(node.left);
  yield node.key;
  yield* inOrder(node.right);
}

class Tree implements Iterable<number> {
  // The aggregate: callers iterate without seeing nodes at all.
  constructor(private readonly root?: TreeNode) {}
  [Symbol.iterator](): Iterator<number> {
    return new InOrderIterator(this.root);
  }
}

const tree = new Tree({ key: 8, left: { key: 3, left: { key: 1 }, right: { key: 6 } }, right: { key: 10, right: { key: 14 } } });
console.log([...tree]); // [1, 3, 6, 8, 10, 14]
console.log([...inOrder({ key: 2, left: { key: 1 }, right: { key: 3 } })]); // [1, 2, 3]
for (const key of tree) {
  if (key > 5) {
    console.log(key); // 6: stops early, the rest is never visited
    break;
  }
}

from __future__ import annotations

from typing import Protocol


class Mediator(Protocol):
    def changed(self, sender: Field, event: str) -> None: ...


class Field:
    def __init__(self, mediator: Mediator, name: str, value: str = "") -> None:
        self._mediator, self.name, self.value = mediator, name, value
        self.error = ""

    def set(self, value: str) -> None:
        self.value = value
        self._mediator.changed(self, "changed")  # the only thing a field knows


class CheckoutForm:  # the mediator: all the "who reacts to what" lives here
    RATES = {"GB": 0.20, "DE": 0.19, "US": 0.0}
    SHIPPING = {"GB": ["standard", "express"], "DE": ["standard"], "US": ["standard", "express", "overnight"]}

    def __init__(self) -> None:
        self.country = Field(self, "country", "GB")
        self.postcode = Field(self, "postcode")
        self.shipping = Field(self, "shipping", "standard")
        self.options: list[str] = self.SHIPPING["GB"]
        self.tax_rate = self.RATES["GB"]

    def changed(self, sender: Field, event: str) -> None:
        if sender is self.country:
            self.options = self.SHIPPING.get(sender.value, ["standard"])
            if self.shipping.value not in self.options:
                self.shipping.value = self.options[0]  # set quietly: no event loop
            self.tax_rate = self.RATES.get(sender.value, 0.0)
            self._validate_postcode()
        elif sender is self.postcode:
            self._validate_postcode()

    def _validate_postcode(self) -> None:
        rules = {"GB": lambda p: 5 <= len(p.replace(" ", "")) <= 7, "US": lambda p: p.isdigit() and len(p) == 5}
        valid = rules.get(self.country.value, lambda p: bool(p))(self.postcode.value)
        self.postcode.error = "" if valid else f"not a valid {self.country.value} postcode"


form = CheckoutForm()
form.shipping.set("express")
form.country.set("DE")  # express isn't offered in DE: shipping falls back, tax changes
print(form.shipping.value, form.tax_rate, form.options)  # standard 0.19 ['standard']
form.country.set("US")
form.postcode.set("SW1A 1AA")
print(form.postcode.error)  # not a valid US postcode

interface Mediator {
  changed(sender: Field, event: string): void;
}

class Field {
  error = "";
  constructor(private readonly mediator: Mediator, readonly name: string, public value = "") {}

  set(value: string): void {
    this.value = value;
    this.mediator.changed(this, "changed"); // the only thing a field knows
  }
}

const RATES: Record<string, number> = { GB: 0.2, DE: 0.19, US: 0 };
const SHIPPING: Record<string, string[]> = { GB: ["standard", "express"], DE: ["standard"], US: ["standard", "express", "overnight"] };
const POSTCODE_RULES: Record<string, (p: string) => boolean> = {
  GB: (p) => p.replace(/ /g, "").length >= 5 && p.replace(/ /g, "").length <= 7,
  US: (p) => /^\d{5}$/.test(p),
};

class CheckoutForm implements Mediator {
  // The mediator: all the "who reacts to what" lives here.
  readonly country = new Field(this, "country", "GB");
  readonly postcode = new Field(this, "postcode");
  readonly shipping = new Field(this, "shipping", "standard");
  options = SHIPPING.GB;
  taxRate = RATES.GB;

  changed(sender: Field): void {
    if (sender === this.country) {
      this.options = SHIPPING[sender.value] ?? ["standard"];
      if (!this.options.includes(this.shipping.value)) this.shipping.value = this.options[0]; // set quietly: no event loop
      this.taxRate = RATES[sender.value] ?? 0;
      this.validatePostcode();
    } else if (sender === this.postcode) {
      this.validatePostcode();
    }
  }

  private validatePostcode(): void {
    const valid = (POSTCODE_RULES[this.country.value] ?? ((p: string) => p.length > 0))(this.postcode.value);
    this.postcode.error = valid ? "" : `not a valid ${this.country.value} postcode`;
  }
}

const form = new CheckoutForm();
form.shipping.set("express");
form.country.set("DE"); // express isn't offered in DE: shipping falls back, tax changes
console.log(form.shipping.value, form.taxRate, form.options); // standard 0.19 ['standard']
form.country.set("US");
form.postcode.set("SW1A 1AA");
console.log(form.postcode.error); // not a valid US postcode

from __future__ import annotations

from collections import deque
from dataclasses import dataclass


@dataclass(frozen=True, slots=True)
class _EditorSnapshot:  # the memento: frozen, and private by convention
    text: str
    cursor: int
    selection: tuple[int, int] | None


class Editor:  # the originator
    def __init__(self) -> None:
        self._text, self._cursor = "", 0
        self._selection: tuple[int, int] | None = None

    def type(self, s: str) -> None:
        self._text = self._text[: self._cursor] + s + self._text[self._cursor :]
        self._cursor += len(s)

    def select(self, start: int, end: int) -> None:
        self._selection = (start, end)

    def save(self) -> object:  # callers get an opaque object
        return _EditorSnapshot(self._text, self._cursor, self._selection)

    def restore(self, memento: object) -> None:
        if not isinstance(memento, _EditorSnapshot):
            raise TypeError("not a snapshot from this editor")
        self._text, self._cursor, self._selection = memento.text, memento.cursor, memento.selection

    def __repr__(self) -> str:
        return f"Editor({self._text!r}, cursor={self._cursor})"


class History:  # the caretaker: stores snapshots, never looks inside
    def __init__(self, editor: Editor, limit: int = 100) -> None:
        self._editor = editor
        self._undo: deque[object] = deque(maxlen=limit)  # oldest snapshots fall off the end

    def checkpoint(self) -> None:
        self._undo.append(self._editor.save())

    def undo(self) -> None:
        if self._undo:
            self._editor.restore(self._undo.pop())


editor = Editor()
history = History(editor, limit=50)
history.checkpoint()
editor.type("Hello")
history.checkpoint()
editor.type(", world")
print(editor)  # Editor('Hello, world', cursor=12)
history.undo()
print(editor)  # Editor('Hello', cursor=5)

class EditorSnapshot {
  // The memento: fields are #private, so only code in this file can read them.
  readonly #text: string;
  readonly #cursor: number;
  constructor(text: string, cursor: number) {
    this.#text = text;
    this.#cursor = cursor;
  }
  static read(s: EditorSnapshot): { text: string; cursor: number } {
    return { text: s.#text, cursor: s.#cursor };
  }
}

export type Memento = { readonly __brand: "EditorMemento" }; // what callers see: nothing usable

export class Editor {
  // The originator.
  private text = "";
  private cursor = 0;

  type(s: string): void {
    this.text = this.text.slice(0, this.cursor) + s + this.text.slice(this.cursor);
    this.cursor += s.length;
  }

  save(): Memento {
    return new EditorSnapshot(this.text, this.cursor) as unknown as Memento;
  }

  restore(memento: Memento): void {
    if (!(memento instanceof EditorSnapshot)) throw new TypeError("not a snapshot from this editor");
    ({ text: this.text, cursor: this.cursor } = EditorSnapshot.read(memento));
  }

  toString(): string {
    return `Editor(${JSON.stringify(this.text)}, cursor=${this.cursor})`;
  }
}

export class History {
  // The caretaker: stores snapshots, never looks inside.
  private readonly undoStack: Memento[] = [];
  constructor(private readonly editor: Editor, private readonly limit = 100) {}

  checkpoint(): void {
    this.undoStack.push(this.editor.save());
    if (this.undoStack.length > this.limit) this.undoStack.shift(); // oldest snapshots fall off
  }

  undo(): void {
    const memento = this.undoStack.pop();
    if (memento) this.editor.restore(memento);
  }
}

const editor = new Editor();
const history = new History(editor, 50);
history.checkpoint();
editor.type("Hello");
history.checkpoint();
editor.type(", world");
console.log(String(editor)); // Editor("Hello, world", cursor=12)
history.undo();
console.log(String(editor)); // Editor("Hello", cursor=5)

from __future__ import annotations

from abc import ABC, abstractmethod
from dataclasses import dataclass
from typing import Generic, TypeVar

R = TypeVar("R")


class Visitor(ABC, Generic[R]):
    @abstractmethod
    def visit_num(self, node: Num) -> R: ...
    @abstractmethod
    def visit_var(self, node: Var) -> R: ...
    @abstractmethod
    def visit_add(self, node: Add) -> R: ...
    @abstractmethod
    def visit_mul(self, node: Mul) -> R: ...


class Expr(ABC):
    @abstractmethod
    def accept(self, visitor: Visitor[R]) -> R: ...


@dataclass(frozen=True)
class Num(Expr):
    value: float
    def accept(self, v: Visitor[R]) -> R:
        return v.visit_num(self)  # second dispatch: on the visitor


@dataclass(frozen=True)
class Var(Expr):
    name: str
    def accept(self, v: Visitor[R]) -> R:
        return v.visit_var(self)


@dataclass(frozen=True)
class Add(Expr):
    left: Expr
    right: Expr
    def accept(self, v: Visitor[R]) -> R:
        return v.visit_add(self)


@dataclass(frozen=True)
class Mul(Expr):
    left: Expr
    right: Expr
    def accept(self, v: Visitor[R]) -> R:
        return v.visit_mul(self)


class Evaluate(Visitor[float]):  # operation 1: no node class was edited to add it
    def __init__(self, env: dict[str, float]) -> None:
        self.env = env
    def visit_num(self, n: Num) -> float:
        return n.value
    def visit_var(self, n: Var) -> float:
        return self.env[n.name]
    def visit_add(self, n: Add) -> float:
        return n.left.accept(self) + n.right.accept(self)
    def visit_mul(self, n: Mul) -> float:
        return n.left.accept(self) * n.right.accept(self)


class Show(Visitor[str]):  # operation 2
    def visit_num(self, n: Num) -> str:
        return f"{n.value:g}"
    def visit_var(self, n: Var) -> str:
        return n.name
    def visit_add(self, n: Add) -> str:
        return f"({n.left.accept(self)} + {n.right.accept(self)})"
    def visit_mul(self, n: Mul) -> str:
        return f"{n.left.accept(self)} * {n.right.accept(self)}"


expr = Add(Num(2), Mul(Var("x"), Num(3)))  # 2 + x * 3
print(expr.accept(Show()), "=", expr.accept(Evaluate({"x": 4})))  # (2 + x * 3) = 14.0

interface Visitor<R> {
  visitNum(node: Num): R;
  visitVar(node: Var): R;
  visitAdd(node: Add): R;
  visitMul(node: Mul): R;
}

interface Expr {
  accept<R>(visitor: Visitor<R>): R;
}

class Num implements Expr {
  constructor(readonly value: number) {}
  accept<R>(v: Visitor<R>): R {
    return v.visitNum(this); // second dispatch: on the visitor
  }
}
class Var implements Expr {
  constructor(readonly name: string) {}
  accept<R>(v: Visitor<R>): R {
    return v.visitVar(this);
  }
}
class Add implements Expr {
  constructor(readonly left: Expr, readonly right: Expr) {}
  accept<R>(v: Visitor<R>): R {
    return v.visitAdd(this);
  }
}
class Mul implements Expr {
  constructor(readonly left: Expr, readonly right: Expr) {}
  accept<R>(v: Visitor<R>): R {
    return v.visitMul(this);
  }
}

class Evaluate implements Visitor<number> {
  // Operation 1: no node class was edited to add it.
  constructor(private readonly env: Record<string, number>) {}
  visitNum = (n: Num) => n.value;
  visitVar = (n: Var) => this.env[n.name];
  visitAdd = (n: Add): number => n.left.accept(this) + n.right.accept(this);
  visitMul = (n: Mul): number => n.left.accept(this) * n.right.accept(this);
}

class Show implements Visitor<string> {
  // Operation 2.
  visitNum = (n: Num) => String(n.value);
  visitVar = (n: Var) => n.name;
  visitAdd = (n: Add): string => `(${n.left.accept(this)} + ${n.right.accept(this)})`;
  visitMul = (n: Mul): string => `${n.left.accept(this)} * ${n.right.accept(this)}`;
}

const expr = new Add(new Num(2), new Mul(new Var("x"), new Num(3))); // 2 + x * 3
console.log(expr.accept(new Show()), "=", expr.accept(new Evaluate({ x: 4 }))); // (2 + x * 3) = 14

import operator
from dataclasses import dataclass
from typing import Any, Protocol

OPS = {"==": operator.eq, "!=": operator.ne, ">": operator.gt, ">=": operator.ge, "<": operator.lt, "<=": operator.le}


class Rule(Protocol):
    def evaluate(self, ctx: dict[str, Any]) -> bool: ...


@dataclass(frozen=True)
class Cmp:  # terminal expression
    field: str
    op: str
    value: Any

    def evaluate(self, ctx: dict[str, Any]) -> bool:
        if self.field not in ctx:
            return False  # unknown attributes never match
        return OPS[self.op](ctx[self.field], self.value)


@dataclass(frozen=True)
class And:  # non-terminal expressions
    left: Rule
    right: Rule

    def evaluate(self, ctx: dict[str, Any]) -> bool:
        return self.left.evaluate(ctx) and self.right.evaluate(ctx)  # short-circuits


@dataclass(frozen=True)
class Or:
    left: Rule
    right: Rule

    def evaluate(self, ctx: dict[str, Any]) -> bool:
        return self.left.evaluate(ctx) or self.right.evaluate(ctx)


@dataclass(frozen=True)
class Not:
    operand: Rule

    def evaluate(self, ctx: dict[str, Any]) -> bool:
        return not self.operand.evaluate(ctx)


rule = And(Cmp("plan", "==", "pro"), Or(Cmp("seats", ">", 5), Not(Cmp("trial", "==", True))))
print(rule.evaluate({"plan": "pro", "seats": 3, "trial": False}))  # True: not on trial
print(rule.evaluate({"plan": "pro", "seats": 3, "trial": True}))   # False

type Ctx = Record<string, string | number | boolean>;
type Op = "==" | "!=" | ">" | ">=" | "<" | "<=";

const OPS: Record<Op, (a: any, b: any) => boolean> = {
  "==": (a, b) => a === b,
  "!=": (a, b) => a !== b,
  ">": (a, b) => a > b,
  ">=": (a, b) => a >= b,
  "<": (a, b) => a < b,
  "<=": (a, b) => a <= b,
};

export interface Rule {
  evaluate(ctx: Ctx): boolean;
}

export class Cmp implements Rule {
  // Terminal expression.
  constructor(readonly field: string, readonly op: Op, readonly value: string | number | boolean) {}
  evaluate(ctx: Ctx): boolean {
    return this.field in ctx && OPS[this.op](ctx[this.field], this.value); // unknown attributes never match
  }
}

export class And implements Rule {
  // Non-terminal expressions.
  constructor(readonly left: Rule, readonly right: Rule) {}
  evaluate(ctx: Ctx) {
    return this.left.evaluate(ctx) && this.right.evaluate(ctx); // short-circuits
  }
}
export class Or implements Rule {
  constructor(readonly left: Rule, readonly right: Rule) {}
  evaluate(ctx: Ctx) {
    return this.left.evaluate(ctx) || this.right.evaluate(ctx);
  }
}
export class Not implements Rule {
  constructor(readonly operand: Rule) {}
  evaluate(ctx: Ctx) {
    return !this.operand.evaluate(ctx);
  }
}

const rule = new And(new Cmp("plan", "==", "pro"), new Or(new Cmp("seats", ">", 5), new Not(new Cmp("trial", "==", true))));
console.log(rule.evaluate({ plan: "pro", seats: 3, trial: false })); // true: not on trial
console.log(rule.evaluate({ plan: "pro", seats: 3, trial: true })); // false

from __future__ import annotations

from dataclasses import dataclass
from decimal import ROUND_HALF_EVEN, Decimal
from typing import Protocol


@dataclass(frozen=True)  # immutable; __eq__ and __hash__ compare by value
class Money:
    amount: Decimal
    currency: str

    def __post_init__(self) -> None:  # self-validating: invalid Money can't exist
        if len(self.currency) != 3 or not self.currency.isupper():
            raise ValueError(f"bad currency {self.currency!r}")
        object.__setattr__(self, "amount", Decimal(self.amount).quantize(Decimal("0.01"), ROUND_HALF_EVEN))

    def __add__(self, other: Money) -> Money:
        self._same_currency(other)
        return Money(self.amount + other.amount, self.currency)

    def __sub__(self, other: Money) -> Money:
        self._same_currency(other)
        return Money(self.amount - other.amount, self.currency)

    def times(self, factor: Decimal | int) -> Money:
        return Money(self.amount * Decimal(factor), self.currency)

    def _same_currency(self, other: Money) -> None:
        if other.currency != self.currency:
            raise ValueError(f"can't combine {self.currency} and {other.currency}")


class Discount(Protocol):
    def apply(self, price: Money) -> Money: ...


@dataclass(frozen=True)
class PercentOff:
    percent: int

    def apply(self, price: Money) -> Money:
        return price - price.times(Decimal(self.percent) / 100)


class NoDiscount:  # Null Object: a real Discount that does nothing
    def apply(self, price: Money) -> Money:
        return price


def checkout_total(price: Money, discount: Discount = NoDiscount()) -> Money:
    return discount.apply(price)  # no "if discount is not None" anywhere


assert Money(Decimal("10"), "GBP") == Money(Decimal("10.00"), "GBP")  # equal by value
print(checkout_total(Money(Decimal("80"), "GBP"), PercentOff(25)))     # Money(amount=Decimal('60.00'), currency='GBP')
print(checkout_total(Money(Decimal("80"), "GBP")))                     # unchanged

export class Money {
  // Immutable; stored as integer minor units, so there are no float rounding errors.
  private constructor(readonly minor: number, readonly currency: string) {
    Object.freeze(this);
  }

  static of(amount: string, currency: string): Money {
    // Self-validating: invalid Money can't exist.
    if (!/^[A-Z]{3}$/.test(currency)) throw new Error(`bad currency ${currency}`);
    if (!/^-?\d+(\.\d{1,2})?$/.test(amount)) throw new Error(`bad amount ${amount}`);
    const [whole, frac = ""] = amount.split(".");
    const sign = whole.startsWith("-") ? -1 : 1;
    return new Money(Number(whole) * 100 + sign * Number(frac.padEnd(2, "0")), currency);
  }

  plus(other: Money): Money {
    this.sameCurrency(other);
    return new Money(this.minor + other.minor, this.currency);
  }

  minus(other: Money): Money {
    this.sameCurrency(other);
    return new Money(this.minor - other.minor, this.currency);
  }

  percent(p: number): Money {
    return new Money(Math.round((this.minor * p) / 100), this.currency);
  }

  equals(other: Money): boolean {
    // TypeScript has no operator overloading: === compares identity, so values need equals().
    return this.minor === other.minor && this.currency === other.currency;
  }

  toString(): string {
    return `${(this.minor / 100).toFixed(2)} ${this.currency}`;
  }

  private sameCurrency(other: Money): void {
    if (other.currency !== this.currency) throw new Error(`can't combine ${this.currency} and ${other.currency}`);
  }
}

interface Discount {
  apply(price: Money): Money;
}

const percentOff = (p: number): Discount => ({ apply: (price) => price.minus(price.percent(p)) });
const noDiscount: Discount = { apply: (price) => price }; // Null Object: a real Discount that does nothing

const checkoutTotal = (price: Money, discount: Discount = noDiscount) => discount.apply(price); // no null checks

console.assert(Money.of("10", "GBP").equals(Money.of("10.00", "GBP"))); // equal by value
console.log(String(checkoutTotal(Money.of("80", "GBP"), percentOff(25)))); // 60.00 GBP
console.log(String(checkoutTotal(Money.of("80", "GBP")))); // 80.00 GBP

from __future__ import annotations

import sqlite3
from dataclasses import dataclass
from typing import Protocol


@dataclass
class Account:  # a domain object: knows nothing about storage
    id: str
    balance: int

    def withdraw(self, amount: int) -> None:
        if amount > self.balance:
            raise ValueError("insufficient funds")
        self.balance -= amount

    def deposit(self, amount: int) -> None:
        self.balance += amount


class AccountRepository(Protocol):  # owned by the domain
    def get(self, account_id: str) -> Account: ...
    def add(self, account: Account) -> None: ...


class SqliteAccountRepository:
    def __init__(self, conn: sqlite3.Connection) -> None:
        self._conn = conn
        self._identity_map: dict[str, Account] = {}  # one object per row, per unit of work
        self.seen: set[str] = set()

    def get(self, account_id: str) -> Account:
        if account_id not in self._identity_map:
            row = self._conn.execute("select id, balance from accounts where id = ?", (account_id,)).fetchone()
            if row is None:
                raise KeyError(account_id)
            self._identity_map[account_id] = Account(*row)
        self.seen.add(account_id)
        return self._identity_map[account_id]

    def add(self, account: Account) -> None:
        self._identity_map[account.id] = account
        self.seen.add(account.id)

    def flush(self) -> None:  # write every tracked object (a real UoW would track only dirty ones)
        for account in self._identity_map.values():
            self._conn.execute(
                "insert into accounts (id, balance) values (?, ?) on conflict(id) do update set balance = excluded.balance",
                (account.id, account.balance),
            )


class UnitOfWork:
    def __init__(self, conn: sqlite3.Connection) -> None:
        self._conn = conn

    def __enter__(self) -> UnitOfWork:
        self.accounts = SqliteAccountRepository(self._conn)
        return self

    def commit(self) -> None:
        self.accounts.flush()
        self._conn.commit()  # everything, or...

    def __exit__(self, exc_type, exc, tb) -> None:
        self._conn.rollback()  # ...nothing: anything not committed is discarded


def transfer(uow: UnitOfWork, source: str, target: str, amount: int) -> None:  # a use case
    with uow:
        uow.accounts.get(source).withdraw(amount)
        uow.accounts.get(target).deposit(amount)
        uow.commit()  # both balances change together, or neither does


conn = sqlite3.connect(":memory:")
conn.execute("create table accounts (id text primary key, balance integer not null)")
conn.executemany("insert into accounts values (?, ?)", [("a", 100), ("b", 0)])
conn.commit()
transfer(UnitOfWork(conn), "a", "b", 30)
print(conn.execute("select * from accounts order by id").fetchall())  # [('a', 70), ('b', 30)]

export class Account {
  // A domain object: knows nothing about storage.
  constructor(readonly id: string, public balance: number) {}
  withdraw(amount: number) {
    if (amount > this.balance) throw new Error("insufficient funds");
    this.balance -= amount;
  }
  deposit(amount: number) {
    this.balance += amount;
  }
}

export interface AccountRepository {
  // Owned by the domain.
  get(id: string): Promise<Account>;
  add(account: Account): void;
}

export interface UnitOfWork {
  readonly accounts: AccountRepository;
  commit(): Promise<void>;
}

// An in-memory unit of work: the same contract, for tests and local runs.
export class InMemoryUnitOfWork implements UnitOfWork {
  private readonly pending = new Map<string, Account>(); // identity map for this unit of work
  committed = false;

  constructor(private readonly store: Map<string, { id: string; balance: number }>) {}

  readonly accounts: AccountRepository = {
    get: async (id) => {
      if (!this.pending.has(id)) {
        const row = this.store.get(id);
        if (!row) throw new Error(`no account ${id}`);
        this.pending.set(id, new Account(row.id, row.balance));
      }
      return this.pending.get(id)!;
    },
    add: (account) => void this.pending.set(account.id, account),
  };

  async commit(): Promise<void> {
    for (const a of this.pending.values()) this.store.set(a.id, { id: a.id, balance: a.balance });
    this.committed = true; // nothing reaches the store until here
  }
}

export async function transfer(uow: UnitOfWork, source: string, target: string, amount: number): Promise<void> {
  (await uow.accounts.get(source)).withdraw(amount);
  (await uow.accounts.get(target)).deposit(amount);
  await uow.commit(); // both balances change together, or neither does
}

const store = new Map([["a", { id: "a", balance: 100 }], ["b", { id: "b", balance: 0 }]]);
await transfer(new InMemoryUnitOfWork(store), "a", "b", 30);
console.log([...store.values()]); // [{ id: 'a', balance: 70 }, { id: 'b', balance: 30 }]

from __future__ import annotations

import re
from dataclasses import dataclass
from functools import partial, reduce
from typing import Callable, Generic, TypeVar

A = TypeVar("A")
E = TypeVar("E")


def pipe(*fns: Callable) -> Callable:
    """pipe(f, g, h)(x) == h(g(f(x))): left-to-right composition."""
    return lambda x: reduce(lambda acc, fn: fn(acc), fns, x)


@dataclass(frozen=True)
class Ok(Generic[A]):
    value: A


@dataclass(frozen=True)
class Err(Generic[E]):
    error: E


Result = Ok[A] | Err[E]


def parse_quantity(text: str) -> Result[int, str]:
    if not text.strip().isdigit():
        return Err(f"not a number: {text!r}")
    qty = int(text)
    return Ok(qty) if 1 <= qty <= 99 else Err(f"out of range: {qty}")


def describe(result: Result[int, str]) -> str:
    match result:  # the caller must handle both cases: errors are values, not surprises
        case Ok(qty):
            return f"{qty} item(s)"
        case Err(message):
            return f"rejected ({message})"


normalise = pipe(str.strip, str.lower, partial(re.sub, r"\s+", "-"))  # partial pre-fills pattern and replacement
print(normalise("  Summer Sale  "))                                     # summer-sale
print([describe(parse_quantity(t)) for t in ("3", "0", "abc")])         # ['3 item(s)', 'rejected (out of range: 0)', ...]

export const pipe =
  <T>(...fns: Array<(x: T) => T>) =>
  (x: T): T =>
    fns.reduce((acc, fn) => fn(acc), x); // left-to-right composition

export type Result<T, E> = { ok: true; value: T } | { ok: false; error: E };
const ok = <T>(value: T): Result<T, never> => ({ ok: true, value });
const err = <E>(error: E): Result<never, E> => ({ ok: false, error });

export function parseQuantity(text: string): Result<number, string> {
  if (!/^\s*\d+\s*$/.test(text)) return err(`not a number: ${JSON.stringify(text)}`);
  const qty = Number(text);
  return qty >= 1 && qty <= 99 ? ok(qty) : err(`out of range: ${qty}`);
}

const describe = (r: Result<number, string>) => (r.ok ? `${r.value} item(s)` : `rejected (${r.error})`); // both cases handled

const replaceSpaces = (sep: string) => (s: string) => s.replaceAll(" ", sep); // a closure: a pre-filled function
const normalise = pipe<string>((s) => s.trim(), (s) => s.toLowerCase(), replaceSpaces("-"));
console.log(normalise("  Summer Sale  ")); // summer-sale
console.log(["3", "0", "abc"].map((t) => describe(parseQuantity(t)))); // ['3 item(s)', 'rejected (out of range: 0)', ...]

from abc import ABC, abstractmethod


# Before: four types, one factory and a provider, to send one kind of email.
class NotificationStrategy(ABC):
    @abstractmethod
    def send(self, user, message: str) -> None: ...


class EmailNotificationStrategy(NotificationStrategy):
    def __init__(self, smtp) -> None:
        self._smtp = smtp

    def send(self, user, message: str) -> None:
        self._smtp.send(user.email, message)


class NotificationStrategyFactory:
    def __init__(self, smtp) -> None:
        self._smtp = smtp

    def create(self, kind: str) -> NotificationStrategy:
        if kind == "email":
            return EmailNotificationStrategy(self._smtp)
        raise ValueError(kind)  # the only other kind that has ever existed


class NotificationStrategyFactoryProvider:
    factory: NotificationStrategyFactory | None = None

    @classmethod
    def get(cls) -> NotificationStrategyFactory:
        assert cls.factory is not None, "provider not configured"
        return cls.factory


# NotificationStrategyFactoryProvider.get().create("email").send(user, "Welcome!")


# After: what the requirement actually asks for today.
def send_welcome(smtp, user) -> None:
    smtp.send(user.email, "Welcome!")


# When SMS genuinely arrives, introduce a Notifier protocol THEN, with two real implementations.

// Before: four types, one factory and a provider, to send one kind of email.
interface NotificationStrategy {
  send(user: { email: string }, message: string): Promise<void>;
}

class EmailNotificationStrategy implements NotificationStrategy {
  constructor(private readonly smtp: { send(to: string, body: string): Promise<void> }) {}
  send(user: { email: string }, message: string) {
    return this.smtp.send(user.email, message);
  }
}

class NotificationStrategyFactory {
  constructor(private readonly smtp: { send(to: string, body: string): Promise<void> }) {}
  create(kind: string): NotificationStrategy {
    if (kind === "email") return new EmailNotificationStrategy(this.smtp);
    throw new Error(kind); // the only other kind that has ever existed
  }
}

class NotificationStrategyFactoryProvider {
  static factory?: NotificationStrategyFactory;
  static get(): NotificationStrategyFactory {
    if (!this.factory) throw new Error("provider not configured");
    return this.factory;
  }
}

// await NotificationStrategyFactoryProvider.get().create("email").send(user, "Welcome!");

// After: what the requirement actually asks for today.
export const sendWelcome = (smtp: { send(to: string, body: string): Promise<void> }, user: { email: string }) =>
  smtp.send(user.email, "Welcome!");

// When SMS genuinely arrives, introduce a Notifier interface THEN, with two real implementations.

from dataclasses import dataclass
from decimal import Decimal
from typing import Protocol

# Before: the same switch on `method` appears in cost() AND in eta_days().
#
# def cost(method, weight):
#     if method == "standard": return Decimal("3.99") + weight * Decimal("0.5")
#     elif method == "express": return Decimal("9.99") + weight * Decimal("0.8")
#     elif method == "pickup": return Decimal("0")
#
# def eta_days(method):
#     if method == "standard": return 4
#     ...
#
# Step 1: write characterisation tests for cost() and eta_days() for every method.
# Step 2: introduce the interface, and one class per branch, copying each branch's body.
# Step 3: add a lookup from the old string to the new class (keeps every caller working).
# Step 4: make cost() and eta_days() delegate through the lookup. Run the tests.
# Step 5: migrate callers to hold a ShippingMethod object; delete the string functions.


class ShippingMethod(Protocol):
    def cost(self, weight_kg: Decimal) -> Decimal: ...
    def eta_days(self) -> int: ...


@dataclass(frozen=True)
class Standard:
    def cost(self, weight_kg: Decimal) -> Decimal:
        return Decimal("3.99") + weight_kg * Decimal("0.5")

    def eta_days(self) -> int:
        return 4


@dataclass(frozen=True)
class Express:
    def cost(self, weight_kg: Decimal) -> Decimal:
        return Decimal("9.99") + weight_kg * Decimal("0.8")

    def eta_days(self) -> int:
        return 1


@dataclass(frozen=True)
class Pickup:
    def cost(self, weight_kg: Decimal) -> Decimal:
        return Decimal("0")

    def eta_days(self) -> int:
        return 0


METHODS: dict[str, ShippingMethod] = {"standard": Standard(), "express": Express(), "pickup": Pickup()}


def cost(method: str, weight_kg: Decimal) -> Decimal:  # step 4: the old API delegates, callers unchanged
    return METHODS[method].cost(weight_kg)

// Before: the same switch on `method` appears in cost() AND in etaDays().
//
// function cost(method: string, weightKg: number) {
//   switch (method) { case "standard": return 399 + weightKg * 50; case "express": ...; case "pickup": return 0; }
// }
//
// Step 1: write characterisation tests for cost() and etaDays() for every method.
// Step 2: introduce the interface, and one object per branch, copying each branch's body.
// Step 3: add a lookup from the old string to the new object (keeps every caller working).
// Step 4: make cost() and etaDays() delegate through the lookup. Run the tests.
// Step 5: migrate callers to hold a ShippingMethod; delete the string functions.

interface ShippingMethod {
  costPence(weightKg: number): number;
  etaDays(): number;
}

const standard: ShippingMethod = { costPence: (kg) => 399 + Math.round(kg * 50), etaDays: () => 4 };
const express: ShippingMethod = { costPence: (kg) => 999 + Math.round(kg * 80), etaDays: () => 1 };
const pickup: ShippingMethod = { costPence: () => 0, etaDays: () => 0 };

const METHODS: Record<string, ShippingMethod> = { standard, express, pickup };

export function cost(method: string, weightKg: number): number {
  // Step 4: the old API delegates, callers unchanged.
  const shipping = METHODS[method];
  if (!shipping) throw new Error(`unknown shipping method ${method}`);
  return shipping.costPence(weightKg);
}

from dataclasses import dataclass
from datetime import datetime, timedelta
from unittest.mock import Mock


@dataclass
class User:
    id: str
    email: str
    trial_ends: datetime


class TrialReminder:
    def __init__(self, users, mailer, clock, audit_log) -> None:
        self.users, self.mailer, self.clock, self.audit_log = users, mailer, clock, audit_log

    def run(self, user_id: str) -> None:
        user = self.users.get(user_id)
        if user.trial_ends.date() - self.clock.now().date() == timedelta(days=1):
            self.mailer.send(user.email, "Your trial ends tomorrow")


class FixedClock:  # stub: returns a canned answer
    def __init__(self, at: datetime) -> None:
        self.at = at

    def now(self) -> datetime:
        return self.at


class RecordingMailer:  # spy: records calls for the test to inspect
    def __init__(self) -> None:
        self.sent: list[tuple[str, str]] = []

    def send(self, to: str, body: str) -> None:
        self.sent.append((to, body))


class InMemoryUsers:  # fake: a working, simplified implementation
    def __init__(self) -> None:
        self._rows: dict[str, User] = {}

    def add(self, user: User) -> None:
        self._rows[user.id] = user

    def get(self, user_id: str) -> User:
        return self._rows[user_id]


def test_reminder_sent_the_day_before_the_trial_ends() -> None:
    users = InMemoryUsers()
    users.add(User("u1", "a@x.io", trial_ends=datetime(2026, 3, 1, 9)))
    mailer = RecordingMailer()
    TrialReminder(users, mailer, FixedClock(datetime(2026, 2, 28, 23)), audit_log=None).run("u1")  # None: a dummy
    assert mailer.sent == [("a@x.io", "Your trial ends tomorrow")]


def test_reminder_with_a_mock() -> None:
    users = InMemoryUsers()
    users.add(User("u1", "a@x.io", trial_ends=datetime(2026, 3, 1)))
    mailer = Mock()  # mock: the interaction itself is what's verified
    TrialReminder(users, mailer, FixedClock(datetime(2026, 2, 28)), audit_log=None).run("u1")
    mailer.send.assert_called_once_with("a@x.io", "Your trial ends tomorrow")

import { expect, test, vi } from "vitest";

interface User {
  id: string;
  email: string;
  trialEnds: Date;
}

class TrialReminder {
  constructor(
    private readonly users: { get(id: string): User },
    private readonly mailer: { send(to: string, body: string): void },
    private readonly clock: { now(): Date },
    private readonly auditLog: unknown,
  ) {}

  run(userId: string): void {
    const user = this.users.get(userId);
    const days = Math.round((startOfDay(user.trialEnds) - startOfDay(this.clock.now())) / 86_400_000);
    if (days === 1) this.mailer.send(user.email, "Your trial ends tomorrow");
  }
}

const startOfDay = (d: Date) => Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate());

const fixedClock = (at: Date) => ({ now: () => at }); // stub: returns a canned answer

class RecordingMailer {
  // Spy: records calls for the test to inspect.
  readonly sent: [string, string][] = [];
  send(to: string, body: string) {
    this.sent.push([to, body]);
  }
}

class InMemoryUsers {
  // Fake: a working, simplified implementation.
  private readonly rows = new Map<string, User>();
  add(user: User) {
    this.rows.set(user.id, user);
  }
  get(id: string): User {
    const user = this.rows.get(id);
    if (!user) throw new Error(`no user ${id}`);
    return user;
  }
}

test("reminder sent the day before the trial ends", () => {
  const users = new InMemoryUsers();
  users.add({ id: "u1", email: "a@x.io", trialEnds: new Date("2026-03-01T09:00:00Z") });
  const mailer = new RecordingMailer();
  new TrialReminder(users, mailer, fixedClock(new Date("2026-02-28T23:00:00Z")), null).run("u1"); // null: a dummy
  expect(mailer.sent).toEqual([["a@x.io", "Your trial ends tomorrow"]]);
});

test("reminder with a mock", () => {
  const users = new InMemoryUsers();
  users.add({ id: "u1", email: "a@x.io", trialEnds: new Date("2026-03-01T00:00:00Z") });
  const mailer = { send: vi.fn() }; // mock: the interaction itself is what's verified
  new TrialReminder(users, mailer, fixedClock(new Date("2026-02-28T00:00:00Z")), null).run("u1");
  expect(mailer.send).toHaveBeenCalledOnce();
  expect(mailer.send).toHaveBeenCalledWith("a@x.io", "Your trial ends tomorrow");
});