2nd/10_Wiki/Topic_Programming/Architecture/Switch Statements (Switch 문).md

id, title, category, status, canonical_id, aliases, duplicate_of, source_trust_level, confidence_score, verification_status, tags, raw_sources, last_reinforced, github_commit, tech_stack

id	title	category	status	canonical_id	aliases	duplicate_of	source_trust_level	confidence_score	verification_status	tags	raw_sources	last_reinforced	github_commit	tech_stack
wiki-2026-0508-switch-statements-switch-문	Switch Statements (Switch 문)	10_Wiki/Topics	verified	self	Switch Statement Pattern Matching Replace Switch	none	A	0.9	applied	refactoring code-smell polymorphism		2026-05-10	pending	language framework multi refactoring

Switch Statements (Switch 문)

매 한 줄

"매 type-tagged switch 의 polymorphism 의 missed opportunity". 매 classic code smell 의 — 매 type 의 switch 의 새 type 의 추가 시 매 모든 switch 의 update 의 필요. 2026 의 modern lang 의 sealed types + pattern matching 의 acceptable.

매 핵심

매 왜 smell 인가

• OCP 위반: 매 새 type 의 추가 의 매 switch 의 modify 의 필요.
• Shotgun surgery: 매 동일 switch 의 codebase 의 scatter.
• Type safety hole: 매 default 의 fallthrough — 매 unhandled case 의 silent.

매 acceptable cases

• Sealed/exhaustive matching (Kotlin, Rust, Swift, Java 21+).
• Single switch — 매 dispatch 의 한 곳.
• Performance-critical hot path (jump table).
• Parsing / state machines.

매 refactoring 전략

• Replace with polymorphism: type-tagged switch → method override.
• Replace with strategy: behavior-tagged switch → strategy injection.
• Replace with map: data-tagged switch → lookup table.
• Sealed pattern match: 매 modern lang 의 exhaustive 의 보장.

매 응용

1. AST visitor (legitimate switch).
2. State machine (legitimate).
3. Domain logic dispatch (refactor to polymorphism).

💻 패턴

Smell — type-tagged switch

// BAD
double area(Shape s) {
    switch (s.type) {
        case CIRCLE: return Math.PI * s.radius * s.radius;
        case SQUARE: return s.side * s.side;
        case TRIANGLE: return 0.5 * s.base * s.height;
        default: throw new IllegalStateException();
    }
}

Refactor — polymorphism

sealed interface Shape permits Circle, Square, Triangle {
    double area();
}
record Circle(double r) implements Shape {
    public double area() { return Math.PI * r * r; }
}
record Square(double side) implements Shape {
    public double area() { return side * side; }
}
record Triangle(double base, double h) implements Shape {
    public double area() { return 0.5 * base * h; }
}
// caller: shape.area()

Java 21 — pattern matching switch (exhaustive)

double area(Shape s) {
    return switch (s) {
        case Circle c   -> Math.PI * c.r() * c.r();
        case Square sq  -> sq.side() * sq.side();
        case Triangle t -> 0.5 * t.base() * t.h();
        // no default — compiler proves exhaustive
    };
}

Kotlin — sealed when

sealed class Event
data class Click(val x: Int, val y: Int) : Event()
data class Key(val code: Int) : Event()
object Close : Event()

fun handle(e: Event) = when (e) {
    is Click -> "click at ${e.x},${e.y}"
    is Key   -> "key ${e.code}"
    Close    -> "bye"
}  // exhaustive — no else needed

Rust — match

enum Msg { Quit, Move { x: i32, y: i32 }, Write(String) }

fn process(m: Msg) {
    match m {
        Msg::Quit => println!("quit"),
        Msg::Move { x, y } => println!("move to {x},{y}"),
        Msg::Write(s) => println!("write {s}"),
    }
}

Replace with map (data dispatch)

// BAD
function fmt(t: string, v: number): string {
  switch (t) {
    case "usd": return `$${v}`;
    case "eur": return `€${v}`;
    case "krw": return `₩${v}`;
  }
}

// GOOD
const PREFIX: Record<string, string> = { usd: "$", eur: "€", krw: "₩" };
const fmt = (t: string, v: number) => `${PREFIX[t] ?? ""}${v}`;

Replace with strategy

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

class Pct(Discount):
    def __init__(self, p): self.p = p
    def apply(self, price): return price * (1 - self.p)

class Fixed(Discount):
    def __init__(self, amt): self.amt = amt
    def apply(self, price): return max(0, price - self.amt)

# caller injects Discount, no switch

매 결정 기준

상황	Approach
Type dispatch (open set)	Polymorphism
Type dispatch (closed set)	Sealed + pattern match
Data lookup	Map / dict
Complex behavior swap	Strategy pattern
AST / state machine	Switch (legitimate)

기본값: 매 sealed types + exhaustive pattern matching — 매 modern lang 의 ergonomic + safe.

🔗 Graph

• 부모: Code Smells · Refactoring_Best_Practices
• 변형: Pattern Matching · Polymorphism
• 응용: State Machine · Visitor Pattern · ADT
• Adjacent: Open-Closed Principle

🤖 LLM 활용

언제: 매 switch 의 detect 의 refactor suggestion, type 의 sealed 의 propose. 언제 X: legitimate switch (AST, state machine) 의 전체 refactor 의 — 매 false positive.

❌ 안티패턴

• Refactor every switch: 매 legitimate cases 의 보존 — AST, parser.
• Visitor for trivial dispatch: 매 over-engineering — 매 polymorphism 의 충분.
• Strategy without need: 매 single-impl 의 strategy 의 yagni.

🧪 검증 / 중복

• Verified (Fowler, "Refactoring" 2nd ed.; Effective Java 3rd ed.; JEP 441).
• 신뢰도 A.

🕓 Changelog

날짜	변경
2026-05-08	Phase 1
2026-05-10	Manual cleanup — refactor patterns, modern pattern matching