10장: 타입 수준 프로그래밍 — 타입으로 로직 작성하기

// 숫자를 해당 길이의 튜플로 표현
type NumberToTuple<N extends number, T extends any[] = []> =
  T["length"] extends N ? T : NumberToTuple<N, [...T, any]>;
 
type Three = NumberToTuple<3>;  // [any, any, any]
type Five = NumberToTuple<5>;   // [any, any, any, any, any]

type Add<A extends number, B extends number> =
  [...NumberToTuple<A>, ...NumberToTuple<B>]["length"] extends infer R extends number
    ? R
    : never;
 
type Sum = Add<3, 4>;  // 7
 
type Subtract<A extends number, B extends number> =
  NumberToTuple<A> extends [...NumberToTuple<B>, ...infer Rest]
    ? Rest["length"]
    : never;
 
type Diff = Subtract<7, 3>;  // 4
type Neg = Subtract<3, 7>;   // never (음수는 표현 불가)

type GreaterThan<A extends number, B extends number> =
  A extends B ? false :
  NumberToTuple<A> extends [...NumberToTuple<B>, ...infer _]
    ? true
    : false;
 
type GT1 = GreaterThan<5, 3>;  // true
type GT2 = GreaterThan<3, 5>;  // false
type GT3 = GreaterThan<3, 3>;  // false
 
type LessThan<A extends number, B extends number> = GreaterThan<B, A>;
 
type LT = LessThan<3, 5>;  // true

type Multiply<A extends number, B extends number, Acc extends any[] = []> =
  B extends 0 ? Acc["length"] extends infer R extends number ? R : never :
  NumberToTuple<B> extends [any, ...infer RestB]
    ? Multiply<A, RestB["length"], [...Acc, ...NumberToTuple<A>]>
    : never;
 
type Product = Multiply<3, 4>;  // 12
type Zero = Multiply<5, 0>;     // 0

type And<A extends boolean, B extends boolean> =
  A extends true ? B : false;
 
type Or<A extends boolean, B extends boolean> =
  A extends true ? true : B;
 
type Not<A extends boolean> =
  A extends true ? false : true;
 
type R1 = And<true, true>;    // true
type R2 = And<true, false>;   // false
type R3 = Or<false, true>;    // true
type R4 = Not<true>;          // false

type StringLength<S extends string, Acc extends any[] = []> =
  S extends `${infer _}${infer Rest}`
    ? StringLength<Rest, [...Acc, any]>
    : Acc["length"];
 
type Len1 = StringLength<"hello">;  // 5
type Len2 = StringLength<"">;       // 0
type Len3 = StringLength<"TypeScript">;  // 10

type TrimLeft<S extends string> =
  S extends ` ${infer Rest}` | `\n${infer Rest}` | `\t${infer Rest}`
    ? TrimLeft<Rest>
    : S;
 
type TrimRight<S extends string> =
  S extends `${infer Rest} ` | `${infer Rest}\n` | `${infer Rest}\t`
    ? TrimRight<Rest>
    : S;
 
type Trim<S extends string> = TrimLeft<TrimRight<S>>;
 
type Trimmed = Trim<"  hello world  ">;  // "hello world"

type Join<T extends string[], D extends string> =
  T extends [] ? "" :
  T extends [infer First extends string] ? First :
  T extends [infer First extends string, ...infer Rest extends string[]]
    ? `${First}${D}${Join<Rest, D>}`
    : never;
 
type Joined = Join<["a", "b", "c"], "-">;  // "a-b-c"
type Path = Join<["users", "123", "posts"], "/">;  // "users/123/posts"

type MapSet<M extends Record<string, any>, K extends string, V> =
  Omit<M, K> & Record<K, V>;
 
type MapGet<M extends Record<string, any>, K extends string> =
  K extends keyof M ? M[K] : never;
 
type MapDelete<M extends Record<string, any>, K extends string> =
  Omit<M, K>;
 
type MapHas<M extends Record<string, any>, K extends string> =
  K extends keyof M ? true : false;
 
// 사용
type M0 = {};
type M1 = MapSet<M0, "name", "Alice">;        // { name: "Alice" }
type M2 = MapSet<M1, "age", 30>;              // { name: "Alice"; age: 30 }
type M3 = MapDelete<M2, "age">;               // { name: "Alice" }
 
type Name = MapGet<M2, "name">;   // "Alice"
type Has = MapHas<M2, "age">;     // true

type StackPush<S extends any[], V> = [...S, V];
type StackPop<S extends any[]> =
  S extends [...infer Rest, infer _] ? Rest : never;
type StackPeek<S extends any[]> =
  S extends [...any[], infer Last] ? Last : never;
type StackIsEmpty<S extends any[]> =
  S extends [] ? true : false;
 
type S0 = [];
type S1 = StackPush<S0, "a">;       // ["a"]
type S2 = StackPush<S1, "b">;       // ["a", "b"]
type S3 = StackPush<S2, "c">;       // ["a", "b", "c"]
type Top = StackPeek<S3>;            // "c"
type S4 = StackPop<S3>;              // ["a", "b"]
type Empty = StackIsEmpty<S0>;       // true

interface StateMachineDefinition {
  states: Record<string, {
    on: Record<string, string>;
  }>;
  initial: string;
}
 
type ValidTransition<
  Def extends StateMachineDefinition,
  CurrentState extends keyof Def["states"],
  Event extends string
> = Event extends keyof Def["states"][CurrentState]["on"]
  ? Def["states"][CurrentState]["on"][Event]
  : never;
 
type OrderMachine = {
  states: {
    draft: { on: { SUBMIT: "pending"; DELETE: "cancelled" } };
    pending: { on: { APPROVE: "confirmed"; REJECT: "draft" } };
    confirmed: { on: { SHIP: "shipped"; CANCEL: "cancelled" } };
    shipped: { on: { DELIVER: "delivered" } };
    delivered: { on: {} };
    cancelled: { on: {} };
  };
  initial: "draft";
};
 
// 유효한 전이
type T1 = ValidTransition<OrderMachine, "draft", "SUBMIT">;     // "pending"
type T2 = ValidTransition<OrderMachine, "pending", "APPROVE">;  // "confirmed"
 
// 유효하지 않은 전이
type T3 = ValidTransition<OrderMachine, "draft", "SHIP">;       // never
type T4 = ValidTransition<OrderMachine, "delivered", "SUBMIT">; // never

class TypeSafeStateMachine<Def extends StateMachineDefinition> {
  private currentState: keyof Def["states"];
 
  constructor(private definition: Def) {
    this.currentState = definition.initial as keyof Def["states"];
  }
 
  transition<
    S extends keyof Def["states"],
    E extends keyof Def["states"][S]["on"]
  >(
    _fromState: S,
    event: E
  ): Def["states"][S]["on"][E] {
    const nextState = (this.definition.states as any)[_fromState].on[event];
    this.currentState = nextState;
    return nextState as any;
  }
 
  getState() {
    return this.currentState;
  }
}

type BuilderState = Record<string, unknown>;
 
class TypedBuilder<
  Target extends Record<string, unknown>,
  Built extends Partial<Target> = {}
> {
  private data: Partial<Target> = {};
 
  set<K extends Exclude<keyof Target, keyof Built>>(
    key: K,
    value: Target[K]
  ): TypedBuilder<Target, Built & Pick<Target, K>> {
    (this.data as any)[key] = value;
    return this as any;
  }
 
  // build()는 모든 필수 프로퍼티가 설정된 후에만 호출 가능
  build(
    this: TypedBuilder<Target, Target>
  ): Target {
    return this.data as Target;
  }
}
 
interface UserConfig {
  name: string;
  email: string;
  role: "admin" | "user";
}
 
const user = new TypedBuilder<UserConfig>()
  .set("name", "Alice")
  .set("email", "alice@example.com")
  .set("role", "admin")
  .build(); // OK — 모든 프로퍼티 설정됨
 
// const incomplete = new TypedBuilder<UserConfig>()
//   .set("name", "Alice")
//   .build(); // Error — email과 role이 누락됨

type JsonSchema =
  | { type: "string" }
  | { type: "number" }
  | { type: "boolean" }
  | { type: "null" }
  | { type: "array"; items: JsonSchema }
  | { type: "object"; properties: Record<string, JsonSchema>; required?: string[] };
 
type SchemaToType<S extends JsonSchema> =
  S extends { type: "string" } ? string :
  S extends { type: "number" } ? number :
  S extends { type: "boolean" } ? boolean :
  S extends { type: "null" } ? null :
  S extends { type: "array"; items: infer I extends JsonSchema } ? SchemaToType<I>[] :
  S extends { type: "object"; properties: infer P extends Record<string, JsonSchema>; required: infer R extends string[] }
    ? { [K in Extract<keyof P, R[number]>]: SchemaToType<P[K]> } &
      { [K in Exclude<keyof P, R[number]>]?: SchemaToType<P[K]> }
    : S extends { type: "object"; properties: infer P extends Record<string, JsonSchema> }
      ? { [K in keyof P]?: SchemaToType<P[K]> }
      : never;
 
// 스키마 정의
const userSchema = {
  type: "object",
  properties: {
    name: { type: "string" },
    age: { type: "number" },
    tags: { type: "array", items: { type: "string" } },
  },
  required: ["name", "age"],
} as const satisfies JsonSchema;
 
type User = SchemaToType<typeof userSchema>;
// { name: string; age: number } & { tags?: string[] }

// 피해야 할 패턴: 과도하게 복잡한 타입
type OverlyComplex<T> =
  DeepPartial<DeepReadonly<ConditionalMapping<TemplateTransform<T>>>>;
 
// 권장: 중간 타입으로 분해
type Step1<T> = TemplateTransform<T>;
type Step2<T> = ConditionalMapping<Step1<T>>;
type Step3<T> = DeepReadonly<Step2<T>>;
type FinalType<T> = DeepPartial<Step3<T>>;