Generics & Types — Find the Bug¶

import java.util.*;

static void fillWithDefault(List<Object> slots) { /* ... */ }

List<Integer> partNumbers = new ArrayList<>(List.of(0, 0, 0));
fillWithDefault(partNumbers); // COMPILE ERROR: List<Integer> is not List<Object>

static <T> void fillWith(List<T> slots, T value) {
    for (int i = 0; i < slots.size(); i++) slots.set(i, value);
}
// fillWith(partNumbers, "EMPTY") -> compile error: String is not Integer

Snippet 5 — Non-exhaustive switch silently drops a variant (TypeScript)¶

Difficulty: ⭐⭐ Common in the wild

type PaymentEvent =
  | { kind: "authorized"; amount: number }
  | { kind: "captured"; amount: number }
  | { kind: "refunded"; amount: number };
// Six months later a teammate adds:
//   | { kind: "disputed"; amount: number; reason: string };

function netRevenue(events: PaymentEvent[]): number {
  let total = 0;
  for (const e of events) {
    switch (e.kind) {
      case "authorized":
        break; // not yet money
      case "captured":
        total += e.amount;
        break;
      case "refunded":
        total -= e.amount;
        break;
    }
  }
  return total;
}

What's wrong?

function assertNever(x: never): never {
  throw new Error(`Unhandled payment event: ${JSON.stringify(x)}`);
}

function netRevenue(events: PaymentEvent[]): number {
  let total = 0;
  for (const e of events) {
    switch (e.kind) {
      case "authorized":
        break;
      case "captured":
        total += e.amount;
        break;
      case "refunded":
        total -= e.amount;
        break;
      default:
        return assertNever(e);
      // ^ When "disputed" is added, `e` is `{ kind: "disputed"; ... }` here,
      //   which is NOT assignable to `never` -> COMPILE ERROR.
    }
  }
  return total;
}

Snippet 6 — Type hint that lies via an Any leak (Python)¶

Difficulty: ⭐⭐⭐ Subtle

import json
from typing import Any


def load_config(path: str) -> dict[str, Any]:
    with open(path) as f:
        return json.load(f)


def get_max_connections(config: dict[str, Any]) -> int:
    return config["max_connections"]  # annotated int, but it's Any


def make_pool(config: dict[str, Any]) -> "ConnectionPool":
    size: int = get_max_connections(config)  # mypy: OK
    return ConnectionPool(size=size)


# config.json contains:  {"max_connections": "50"}   <-- a string
pool = make_pool(load_config("config.json"))
# Later:
for _ in range(pool.size):  # TypeError: 'str' object cannot be interpreted as an integer
    ...

What's wrong?

TypeError: 'str' object cannot be interpreted as an integer

def get_max_connections(config: dict[str, Any]) -> int:
    raw = config["max_connections"]
    if not isinstance(raw, int) or isinstance(raw, bool):  # bool is an int subclass — exclude it
        raise ValueError(f"max_connections must be an int, got {type(raw).__name__}: {raw!r}")
    return raw

from pydantic import BaseModel

class Config(BaseModel):
    max_connections: int   # coerces "50" -> 50, rejects "abc"

def load_config(path: str) -> Config:
    with open(path) as f:
        return Config.model_validate_json(f.read())

Snippet 7 — interface{} round-trip loses the type (Go)¶

Difficulty: ⭐⭐ Common in the wild

package main

import (
    "encoding/json"
    "fmt"
)

type Metric struct {
    Name  string
    Value interface{} // accepts "any" numeric type
}

func total(metrics []Metric) int {
    sum := 0
    for _, m := range metrics {
        sum += m.Value.(int) // type assertion
    }
    return sum
}

func main() {
    data := `[{"Name":"hits","Value":10},{"Name":"misses","Value":5}]`
    var metrics []Metric
    _ = json.Unmarshal([]byte(data), &metrics)
    fmt.Println(total(metrics))
}

What's wrong?

panic: interface conversion: interface {} is float64, not int

type Metric struct {
    Name  string
    Value int // concrete — json decodes the number straight into int
}

func total(metrics []Metric) int {
    sum := 0
    for _, m := range metrics {
        sum += m.Value
    }
    return sum
}

func asInt(v interface{}) (int, bool) {
    switch n := v.(type) {
    case int:
        return n, true
    case float64: // what encoding/json actually produces
        return int(n), true
    default:
        return 0, false
    }
}

Snippet 8 — Number widening / boxing identity (Java)¶

Difficulty: ⭐⭐⭐ Subtle

import java.util.*;

public class FeatureFlags {
    private final Map<String, Long> rollout = new HashMap<>();

    public void setPercent(String flag, long percent) {
        rollout.put(flag, percent);
    }

    public boolean isFullyRolledOut(String flag) {
        Long value = rollout.get(flag);
        return value == 100; // compare to fully-on
    }
}

// Caller:
FeatureFlags flags = new FeatureFlags();
flags.setPercent("new-checkout", 100);
System.out.println(flags.isFullyRolledOut("new-checkout")); // true or false?

flags.setPercent("dark-mode", 200);          // clamp bug elsewhere, ignore
System.out.println(flags.isFullyRolledOut("dark-mode"));     // ?

What's wrong?

public boolean isFullyRolledOut(String flag) {
    Long value = rollout.get(flag);
    return value != null && value.longValue() == 100L; // explicit, null-safe, value compare
}
// or, avoid boxing entirely:
private final Map<String, Long> rollout = new HashMap<>();
public boolean isFullyRolledOut(String flag) {
    return rollout.getOrDefault(flag, 0L) == 100L; // primitive long on the right forces value compare
}

Snippet 9 — Generic method violates an unstated invariant (TypeScript)¶

Difficulty: ⭐⭐⭐ Subtle

// "Merge a partial update into an entity."
function merge<T>(base: T, patch: Partial<T>): T {
  return { ...base, ...patch };
}

interface Account {
  id: string;
  balance: number;
  currency: "USD" | "EUR";
}

const account: Account = { id: "A1", balance: 100, currency: "USD" };

// A patch built from untyped form data:
const formPatch = { balance: undefined, currency: "GBP" } as Partial<Account>;

const updated = merge(account, formPatch);
console.log(updated.balance.toFixed(2)); // ?

What's wrong?

function merge<T extends object>(base: T, patch: Partial<T>): T {
  const defined = Object.fromEntries(
    Object.entries(patch).filter(([, v]) => v !== undefined),
  ) as Partial<T>;
  return { ...base, ...defined };
}

// And build the patch through validation, not `as`:
const PatchSchema = z.object({
  balance: z.number().optional(),
  currency: z.enum(["USD", "EUR"]).optional(),
});
const formPatch = PatchSchema.parse(rawFormData); // rejects "GBP" here

Snippet 10 — Optional chaining hides a missing field after a cast (TypeScript)¶

Difficulty: ⭐⭐ Common in the wild

interface ApiResponse {
  data: {
    user: {
      settings: {
        theme: "light" | "dark";
        notificationsEnabled: boolean;
      };
    };
  };
}

function shouldNotify(json: unknown): boolean {
  const res = json as ApiResponse;
  // Defensive optional chaining — surely safe?
  return res?.data?.user?.settings?.notificationsEnabled ?? true;
}

// The real payload nests settings one level deeper: data.user.preferences.settings
const payload = { data: { user: { preferences: { settings: { notificationsEnabled: false } } } } };
console.log(shouldNotify(payload)); // ?

What's wrong?

const ResponseSchema = z.object({
  data: z.object({
    user: z.object({
      preferences: z.object({
        settings: z.object({
          theme: z.enum(["light", "dark"]),
          notificationsEnabled: z.boolean(),
        }),
      }),
    }),
  }),
});

function shouldNotify(json: unknown): boolean {
  const res = ResponseSchema.parse(json); // throws if the shape is wrong
  return res.data.user.preferences.settings.notificationsEnabled;
}

Snippet 11 — == identity vs structural equality (Go / Java)¶

Difficulty: ⭐⭐⭐ Subtle

package main

import "fmt"

type UserID struct {
    Tenant string
    Local  string
}

func dedupe(ids []*UserID) []*UserID {
    seen := map[*UserID]bool{} // keyed by pointer
    out := []*UserID{}
    for _, id := range ids {
        if !seen[id] {
            seen[id] = true
            out = append(out, id)
        }
    }
    return out
}

func main() {
    a := &UserID{Tenant: "acme", Local: "42"}
    b := &UserID{Tenant: "acme", Local: "42"} // same value, different pointer
    fmt.Println(len(dedupe([]*UserID{a, b}))) // expected 1?
}

What's wrong?

func dedupe(ids []*UserID) []*UserID {
    seen := map[UserID]bool{} // keyed by VALUE
    out := []*UserID{}
    for _, id := range ids {
        if !seen[*id] {
            seen[*id] = true
            out = append(out, id)
        }
    }
    return out
}

String a = new String("acme/42");
String b = new String("acme/42");
System.out.println(a == b);        // false  — different objects (identity)
System.out.println(a.equals(b));   // true   — same characters (structural)

// In a HashSet you must override equals()/hashCode() or dedup compares identity.
record UserId(String tenant, String local) {} // records auto-generate value equals/hashCode
new HashSet<>(List.of(new UserId("acme","42"), new UserId("acme","42"))).size(); // 1

Snippet 12 — TypedDict / cast lets str masquerade as int (Python)¶

Difficulty: ⭐⭐⭐ Subtle

from typing import TypedDict, cast
import csv


class Sale(TypedDict):
    product: str
    quantity: int
    price: float


def load_sales(path: str) -> list[Sale]:
    rows: list[Sale] = []
    with open(path) as f:
        for row in csv.DictReader(f):
            rows.append(cast(Sale, row))  # csv gives all-str dicts
    return rows


def revenue(sales: list[Sale]) -> float:
    return sum(s["quantity"] * s["price"] for s in sales)


# sales.csv:
#   product,quantity,price
#   widget,3,9.99
print(revenue(load_sales("sales.csv")))  # ?

What's wrong?

TypeError: can't multiply sequence by non-int of type 'str'

def load_sales(path: str) -> list[Sale]:
    rows: list[Sale] = []
    with open(path) as f:
        for row in csv.DictReader(f):
            rows.append(Sale(
                product=row["product"],
                quantity=int(row["quantity"]),   # "3" -> 3, raises on "three"
                price=float(row["price"]),        # "9.99" -> 9.99
            ))
    return rows

Scorecard¶

Tally how the type system was defeated in each snippet. The four columns are the four ways a static type loses contact with the runtime value.

Score yourself:

• 0–4 found: You read types as documentation. Start treating every as, cast, (T), and interface{} as an unverified claim — circle them on sight.
• 5–8 found: Solid instincts. You spot the casts; now sharpen on the quiet ones (Snippet 10's silent default, Snippet 5's missing variant) where there is no crash to point at.
• 9–12 found: You think like the runtime, not the compiler. You know a green type check is a conditional proof — conditional on every assertion being honest.

The one rule: a type assertion (as, cast, raw (T), interface{} + .()) is a promise you must keep, because the compiler stopped checking the moment you wrote it. Keep the promise at the boundary — parse, validate, convert — or the runtime will collect on it.

Related Topics¶

• junior.md — the foundational rules these snippets violate: prefer narrow types, validate at boundaries, avoid escape hatches.
• tasks.md — hands-on exercises to practice replacing casts with validated parsing and constrained generics.
• Chapter README — the positive rules for Generics & Types, and the anti-patterns this file weaponizes.
• Anti-Patterns — broader catalog of code-level traps, including type-system abuse.
• Refactoring — systematic techniques for re-grounding lying types in reality (Replace Cast with Parse, Encapsulate Primitive).