转移函数与表驱动 —— 状态机的心脏是一个纯函数

type OrderState = "cart" | "paying" | "paid" | "shipped" | "done";

type OrderEvent =
  | { type: "CHECKOUT" }
  | { type: "PAY_OK" }
  | { type: "SHIP" }
  | { type: "CONFIRM" };

// 心脏：当前状态 + 事件 => 新状态
function transition(state: OrderState, event: OrderEvent): OrderState {
  switch (state) {
      case "cart":
          if (event.type === "CHECKOUT") { return "paying"; }
          return state;                    // 其他事件：无视
      case "paying":
          if (event.type === "PAY_OK") { return "paid"; }
          return state;
      case "paid":
          if (event.type === "SHIP") { return "shipped"; }
          return state;
      case "shipped":
          if (event.type === "CONFIRM") { return "done"; }
          return state;
      case "done":
          return state;                    // 终态：所有事件一律无视
  }
}

// 试驾：
let s: OrderState = "cart";
s = transition(s, { type: "CHECKOUT" });     // paying
s = transition(s, { type: "SHIP" });         // 还是 paying——没付钱就想发货？无视
console.log("当前状态：" + s);
s = transition(s, { type: "PAY_OK" });
console.log("付款后：" + s);

type Light = "red" | "green" | "yellow";

// never：unit-1 没讲过的底牌类型——"不可能存在的值"
// 一个值如果所有可能都被 case 排除完了，剩下的类型就是 never
function assertNever(x: never): never {
  throw new Error("漏了分支：" + JSON.stringify(x));
}

function next(light: Light): Light {
  switch (light) {
      case "red":
          return "green";
      case "green":
          return "yellow";
      case "yellow":
          return "red";
      default:
          return assertNever(light);   // 三种全覆盖时，light 在这里是 never，编译通过
  }
}

console.log(next("red"));
// 实验：给 Light 加上 | "blinking"，再看这一行——
// assertNever(light) 立刻报 TS2345：blinking 不能赋给 never
// 编译器替你找出了全项目每一个没处理新状态的 switch

type OrderState = "cart" | "paying" | "paid" | "shipped" | "done";
type OrderEventType = "CHECKOUT" | "PAY_OK" | "SHIP" | "CONFIRM";

// 转移表：state -> (事件 -> 新状态)。没列出的组合 = 无视
// Record<K, V>：内置工具类型，"键为 K、值为 V 的对象"
// Partial<...>：把字段全变可选——每个状态只响应自己认识的事件
const transitions: Record<OrderState, Partial<Record<OrderEventType, OrderState>>> = {
  cart:    { CHECKOUT: "paying" },
  paying:  { PAY_OK: "paid" },
  paid:    { SHIP: "shipped" },
  shipped: { CONFIRM: "done" },
  done:    {},                          // 终态：一张空菜单
};

function transition(state: OrderState, eventType: OrderEventType): OrderState {
  const target = transitions[state][eventType];
  return target !== undefined ? target : state;    // 查不到 = 无视
}

// 试驾（和 switch 版行为完全一致）：
let s: OrderState = "cart";
s = transition(s, "CHECKOUT");
s = transition(s, "SHIP");               // 无视
console.log("当前状态：" + s);

// 表的超能力：它是数据，可以被程序"读"——
// 比如自动打印任何状态的"菜单"：
console.log("paying 能响应：" + Object.keys(transitions["paying"]).join(", "));

type Light = "red" | "green" | "yellow";
type LightEvent = { type: "TIMER" } | { type: "PEDESTRIAN" };

function assertNever(x: never): never {
  throw new Error("漏了分支：" + JSON.stringify(x));
}

// 你的 transition 写在下面

// 自测：
// let l: Light = "red";
// l = transition(l, { type: "PEDESTRIAN" });   // 应仍是 red
// l = transition(l, { type: "TIMER" });        // green
// l = transition(l, { type: "PEDESTRIAN" });   // yellow——行人按钮生效
// console.log(l);

type GateState = "locked" | "unlocked";
type GateEventType = "SWIPE" | "PUSH";

// 你的转移表和 transition 写在下面

// 自测：
// let g: GateState = "locked";
// g = transition(g, "PUSH");    // 仍是 locked——硬推不开
// g = transition(g, "SWIPE");   // unlocked
// g = transition(g, "SWIPE");   // 仍是 unlocked——不重复扣费
// console.log(g);