any, unknown, never — 탈출구와 불가능의 타입

let value: any = 42;
value = 'hello';       // OK
value = true;          // OK
value.foo.bar.baz;     // OK — 런타임에 에러가 나더라도 컴파일은 통과
value();               // OK
value[0];              // OK

const data: any = fetchSomething();
const name = data.user.name;  // name: any — any가 전파됨
const upper = name.toUpperCase(); // upper: any

// any가 한 번 들어가면 그 이후 모든 타입 검사가 무의미해짐

// 1. JavaScript에서 마이그레이션 중일 때 (임시방편)
// 2. 서드파티 라이브러리에 타입 정의가 없을 때
// 3. 정말로 어떤 타입이든 받아야 하는 유틸리티 함수
//    → 이 경우에도 unknown이 더 좋은 선택

let value: unknown = 42;
value = 'hello';       // OK — 할당은 자유
value = true;          // OK

// ❌ 하지만 바로 사용은 불가
// value.toUpperCase(); // Error: Object is of type 'unknown'
// value();             // Error
// value[0];            // Error

// ✅ 타입을 좁힌 후 사용
if (typeof value === 'string') {
  console.log(value.toUpperCase()); // OK
}

// API 응답 처리 — 무엇이 올지 모르는 외부 데이터
async function fetchData(url: string): Promise<unknown> {
  const response = await fetch(url);
  return response.json();
}

// 사용할 때 타입을 검증
const data = await fetchData('/api/user');

// 타입 가드로 검증
function isUser(data: unknown): data is { name: string; age: number } {
  return (
    typeof data === 'object' &&
    data !== null &&
    'name' in data &&
    'age' in data
  );
}

if (isUser(data)) {
  console.log(data.name); // OK — data는 { name: string; age: number }
}

// 1. 항상 예외를 던지는 함수
function throwError(message: string): never {
  throw new Error(message);
}

// 2. 무한 루프
function forever(): never {
  while (true) {}
}

// 3. 모든 경우를 처리한 후의 남은 타입
type Shape = 'circle' | 'square';

function getArea(shape: Shape): number {
  switch (shape) {
    case 'circle':
      return Math.PI;
    case 'square':
      return 1;
    default:
      // shape: never — 모든 경우를 이미 처리했으므로
      const _exhaustive: never = shape;
      return _exhaustive;
  }
}

type Animal = 'dog' | 'cat' | 'bird';

function makeSound(animal: Animal): string {
  switch (animal) {
    case 'dog': return '멍멍';
    case 'cat': return '야옹';
    case 'bird': return '짹짹';
    default:
      // 새로운 동물이 추가되면 여기서 컴파일 에러 발생
      const _never: never = animal;
      throw new Error(`처리되지 않은 동물: ${_never}`);
  }
}

// 나중에 Animal에 'fish'를 추가하면
// type Animal = 'dog' | 'cat' | 'bird' | 'fish';
// → default에서 에러: Type 'fish' is not assignable to type 'never'

// unknown은 모든 타입의 슈퍼타입 (Top Type)
// any는 타입 시스템을 벗어남 (특수한 존재)
// never는 모든 타입의 서브타입 (Bottom Type)

// unknown: 모든 타입이 할당 가능
const a: unknown = 42;
const b: unknown = 'hello';
const c: unknown = true;

// never: 어떤 타입에도 할당 가능 (값이 없으므로 논리적으로 참)
function getDefault(): never {
  throw new Error('no default');
}
const num: number = getDefault(); // OK (never는 number에 할당 가능)
const str: string = getDefault(); // OK (never는 string에 할당 가능)

// 하지만 never에 할당하는 것은 불가
// const n: never = 42; // ❌ Error

// 유니온에서 never는 사라짐
type A = string | never;   // string
type B = number | never;   // number

// 인터섹션에서 never는 전체를 never로 만듦
type C = string & never;   // never

// 유니온에서 unknown은 전체를 unknown으로 만듦
type D = string | unknown; // unknown

// 인터섹션에서 unknown은 사라짐
type E = string & unknown; // string

// ❌ any 사용
function parse(json: string): any {
  return JSON.parse(json);
}
const data = parse('{"name": "test"}');
data.whatever.something; // 타입 에러 없이 런타임 에러

// ✅ unknown 사용
function parseSafe(json: string): unknown {
  return JSON.parse(json);
}
const safeDaata = parseSafe('{"name": "test"}');
// safeData.whatever; // ❌ 컴파일 에러 — 타입 좁히기를 강제