// Before: 사용하지 않는 변수에 이름을 지어야 했음
try {
    parseJson(input);
} catch (JsonException e) {   // e를 안 쓰는데 이름을 지어야 함
    return fallback;
}

// After: 명시적으로 무시
try {
    parseJson(input);
} catch (JsonException _) {   // "이 예외 객체는 안 씁니다"
    return fallback;
}

// for-each에서 인덱스만 필요하고 값은 필요 없을 때
int count = 0;
for (var _ : collection) {
    count++;
}

// 람다에서 파라미터를 안 쓸 때
map.forEach((_, value) -> process(value));

// switch 패턴 매칭에서 특정 필드를 무시할 때
switch (shape) {
    case Circle(var radius)    -> computeCircle(radius);
    case Rectangle(var w, _)   -> computeWidth(w);  // 높이는 안 씀
    default -> throw new IllegalArgumentException();
}

// Before: super() 전에 인자 검증을 하려면 별도 static 메서드 필요
public class PositiveRange extends Range {
    public PositiveRange(int start, int end) {
        super(validate(start), validate(end));  // static 메서드로 우회
    }

    private static int validate(int value) {
        if (value < 0) throw new IllegalArgumentException();
        return value;
    }
}

// After: super() 전에 직접 검증 가능
public class PositiveRange extends Range {
    public PositiveRange(int start, int end) {
        if (start < 0 || end < 0) {
            throw new IllegalArgumentException("음수 불가");
        }
        super(start, end);  // 검증 후 호출
    }
}

public PositiveRange(int start, int end) {
    // ✅ OK: 지역 변수, static 메서드, 파라미터 사용
    int validatedStart = Math.max(0, start);

    // ❌ 컴파일 에러: 인스턴스 필드/메서드 참조 불가
    // this.someField = 10;
    // this.someMethod();

    super(validatedStart, end);
}

// Before: switch에서 int 범위 매칭이 불가능
public String classify(int statusCode) {
    if (statusCode >= 200 && statusCode < 300) return "Success";
    if (statusCode >= 400 && statusCode < 500) return "Client Error";
    if (statusCode >= 500) return "Server Error";
    return "Unknown";
}

// After: switch 패턴 매칭으로 가독성 향상
public String classify(int statusCode) {
    return switch (statusCode) {
        case int s when s >= 200 && s < 300 -> "Success";
        case int s when s >= 400 && s < 500 -> "Client Error";
        case int s when s >= 500            -> "Server Error";
        default -> "Unknown";
    };
}

// primitive narrowing을 안전하게 체크
Object value = getConfig("timeout");
if (value instanceof int timeout) {
    setTimer(timeout);
} else if (value instanceof long timeout) {
    setTimer((int) Math.min(timeout, Integer.MAX_VALUE));
}

// Before: HTML 기반 JavaDoc
/**
 * Calculates the area of a circle.
 *
 * <p>The formula used is:</p>
 * <pre>{@code
 * area = π × radius²
 * }</pre>
 *
 * @param radius the radius of the circle
 * @return the area
 * @throws IllegalArgumentException if radius is negative
 */
public double circleArea(double radius) { ... }

// After: 마크다운 기반 JavaDoc
/// Calculates the area of a circle.
///
/// The formula used is:
///
/// ```
/// area = π × radius²
/// ```
///
/// @param radius the radius of the circle
/// @return the area
/// @throws IllegalArgumentException if radius is negative
public double circleArea(double radius) { ... }

// Before: 여러 import문
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

// After: 모듈 단위 import
import module java.base;  // java.base 모듈의 모든 public 타입 사용 가능

// 정식 API로 사용 가능
var batches = items.stream()
    .gather(Gatherers.windowFixed(100))
    .gather(Gatherers.mapConcurrent(5, this::process))
    .toList();

try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
    Subtask<User> user = scope.fork(() -> fetchUser(id));
    Subtask<List<Order>> orders = scope.fork(() -> fetchOrders(id));

    scope.join().throwIfFailed();
    return new UserDashboard(user.get(), orders.get());
}

// 클래스 파일 읽기
ClassModel cm = ClassFile.of().parse(bytes);
for (MethodModel method : cm.methods()) {
    System.out.println(method.methodName().stringValue());
}

// 클래스 파일 변환 (메서드 이름 변경 등)
byte[] newBytes = ClassFile.of().transformClass(cm,
    ClassTransform.dropping(me -> me instanceof MethodModel m
        && m.methodName().equalsString("deprecated")));

// Before: Hello World에 필요한 보일러플레이트
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

// After: 최소한의 코드
void main() {
    println("Hello, World!");
}

// 미래: Value Type (문법은 변경될 수 있음)
value class Point {
    int x;
    int y;
}
// 힙 할당 없이 인라인으로 저장
// List<Point>에서도 boxing 오버헤드 없음