Branded Types — 같은 string이지만 다른 의미를 구분하기

type UserId = number;
type ProductId = number;

function getUser(id: UserId) { /* ... */ }

const productId: ProductId = 42;
getUser(productId); // ⚠️ 에러 없음! — 둘 다 number이므로 호환됨

// 브랜드 속성을 인터섹션으로 추가
type UserId = number & { readonly __brand: unique symbol };
type ProductId = number & { readonly __brand: unique symbol };

// 값을 생성하는 팩토리 함수
function createUserId(id: number): UserId {
  return id as UserId;
}

function createProductId(id: number): ProductId {
  return id as ProductId;
}

// 이제 서로 호환되지 않음
function getUser(id: UserId) { /* ... */ }

const userId = createUserId(1);
const productId = createProductId(42);

getUser(userId);     // ✅ OK
// getUser(productId); // ❌ Error — ProductId는 UserId에 할당 불가
// getUser(42);        // ❌ Error — 일반 number도 할당 불가

// 범용 브랜딩 유틸리티
type Brand<T, B extends string> = T & { readonly __brand: B };

type UserId = Brand<number, 'UserId'>;
type ProductId = Brand<number, 'ProductId'>;
type Email = Brand<string, 'Email'>;
type Url = Brand<string, 'Url'>;

type Email = Brand<string, 'Email'>;
type PositiveNumber = Brand<number, 'PositiveNumber'>;

// 검증 후 브랜드를 붙여서 반환
function createEmail(input: string): Email {
  if (!input.includes('@')) {
    throw new Error('유효하지 않은 이메일');
  }
  return input as Email;
}

function createPositiveNumber(n: number): PositiveNumber {
  if (n <= 0) {
    throw new Error('양수여야 합니다');
  }
  return n as PositiveNumber;
}

// 안전한 사용
function sendEmail(to: Email, subject: string) {
  // to는 이미 검증된 이메일
  console.log(`${to}에게 메일 발송: ${subject}`);
}

const email = createEmail('test@example.com');
sendEmail(email, '안녕하세요'); // OK
// sendEmail('not-email', '안녕');  // ❌ Error

type Result<T, E> = { ok: true; value: T } | { ok: false; error: E };

function parseEmail(input: string): Result<Email, string> {
  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  if (!emailRegex.test(input)) {
    return { ok: false, error: '유효하지 않은 이메일 형식' };
  }
  return { ok: true, value: input as Email };
}

import { z } from 'zod';

const EmailSchema = z.string().email().brand<'Email'>();
type Email = z.infer<typeof EmailSchema>; // string & Brand<'Email'>

const result = EmailSchema.safeParse('test@example.com');
if (result.success) {
  // result.data는 Email 타입
}

type KRW = Brand<number, 'KRW'>;
type USD = Brand<number, 'USD'>;

function krw(amount: number): KRW { return amount as KRW; }
function usd(amount: number): USD { return amount as USD; }

function addKRW(a: KRW, b: KRW): KRW {
  return (a + b) as KRW;
}

const price = krw(10000);
const tax = krw(1000);
addKRW(price, tax); // ✅ OK

const dollars = usd(100);
// addKRW(price, dollars); // ❌ Error — 달러와 원화를 섞을 수 없음

type SortedArray<T> = readonly T[] & { readonly __brand: 'Sorted' };

function sort<T>(arr: readonly T[], compare: (a: T, b: T) => number): SortedArray<T> {
  return [...arr].sort(compare) as unknown as SortedArray<T>;
}

function binarySearch<T>(arr: SortedArray<T>, target: T): number {
  // 정렬된 배열에서만 동작하는 함수
  // ...
  return -1;
}

const sorted = sort([3, 1, 2], (a, b) => a - b);
binarySearch(sorted, 2);     // ✅ OK
// binarySearch([3, 1, 2], 2); // ❌ Error — 정렬되지 않은 배열

// 브랜드 속성은 런타임에 존재하지 않음
const id = createUserId(42);
console.log(typeof id);    // 'number' — 여전히 number
console.log(id + 1);       // 43 — 산술 연산 가능

// as로 브랜드를 우회할 수 있음 (개발자의 규율에 의존)
const fake = 42 as UserId; // ⚠️ 검증 없이 브랜드를 붙임