深入探讨 `Type-Driven Development` (类型驱动开发) 在 `TypeScript` 中如何通过 `Algebraic Data Types` (代数数据类型) 来提升代码健壮性。

晚上好，各位听众！今天咱们聊聊 TypeScript 里的类型驱动开发，特别是如何用代数数据类型（Algebraic Data Types，简称 ADT）来武装我们的代码，让它们更健壮，更不容易出 Bug。

一、啥是类型驱动开发？（Type-Driven Development）

想象一下，你盖房子，是先哐哐哐地堆砖头，还是先画好蓝图？显然，先画蓝图更靠谱。类型驱动开发就是编程界的“先画蓝图”，只不过这个蓝图是类型系统。

简单来说，类型驱动开发就是：

1. 先定义好数据的形状（类型）。 明确输入和输出的类型，就像给函数定了规矩，什么能进，什么能出，一清二楚。
2. 再根据类型来编写代码。 代码就好像按照蓝图施工，类型系统会帮你检查，确保你没用错材料，没盖歪楼。
3. 类型系统成为你的第一道防线。 在运行时出现错误之前，很多问题在编译时就被类型系统揪出来了。

二、代数数据类型（Algebraic Data Types）：类型世界的乐高积木

ADT 听起来很高大上，其实就是把几种基本类型像乐高积木一样组合起来，创造出更复杂的类型。它主要有两种形式：

• Sum Types (联合类型): “要么是这个，要么是那个”。 就像一个开关，要么是开，要么是关，不能同时是两种状态。
• Product Types (乘积类型): “既要这个，也要那个”。 就像一个包裹，既要有地址，也要有收件人姓名。

2.1 Sum Types (联合类型)

联合类型允许一个变量拥有多种可能的类型。在 TypeScript 中，我们用 | (竖线) 来表示联合类型。

例子：一个表示 HTTP 请求结果的类型

type HttpRequestResult =
  | { status: 'success', data: any }
  | { status: 'error', code: number, message: string };

function handleRequest(result: HttpRequestResult) {
  if (result.status === 'success') {
    console.log('请求成功，数据：', result.data);
  } else {
    console.error('请求失败，错误代码：', result.code, '错误信息：', result.message);
  }
}

const successResult: HttpRequestResult = { status: 'success', data: { name: '张三', age: 30 } };
const errorResult: HttpRequestResult = { status: 'error', code: 500, message: '服务器内部错误' };

handleRequest(successResult);
handleRequest(errorResult);

在这个例子中，HttpRequestResult 可以是成功的结果（包含 data），也可以是失败的结果（包含 code 和 message）。TypeScript 会强制你处理所有可能的情况。 如果你忘了处理 error 的情况，编译器会立刻报错。

更进一步：Discriminated Unions (可辨识联合)

为了更方便地处理联合类型，我们通常会使用“可辨识联合”。 也就是在联合类型的每个成员中，都包含一个唯一的 discriminator (判别器) 属性。 在上面的例子中，status 就是一个判别器。

type Shape =
  | { kind: 'circle', radius: number }
  | { kind: 'square', sideLength: number }
  | { kind: 'rectangle', width: number, height: number };

function getArea(shape: Shape): number {
  switch (shape.kind) {
    case 'circle':
      return Math.PI * shape.radius ** 2;
    case 'square':
      return shape.sideLength ** 2;
    case 'rectangle':
      return shape.width * shape.height;
    default:
      // TypeScript 会检查是否所有情况都处理了，否则会报错
      const _exhaustiveCheck: never = shape;
      return _exhaustiveCheck;
  }
}

const circle: Shape = { kind: 'circle', radius: 5 };
const square: Shape = { kind: 'square', sideLength: 4 };
const rectangle: Shape = { kind: 'rectangle', width: 6, height: 8 };

console.log('圆形面积：', getArea(circle));
console.log('正方形面积：', getArea(square));
console.log('矩形面积：', getArea(rectangle));

在这个例子中，kind 属性就是判别器。 switch 语句会根据 kind 的不同，执行不同的代码。 如果你添加了一个新的形状，但忘记在 switch 语句中处理，TypeScript 会报错，提醒你遗漏了情况。 const _exhaustiveCheck: never = shape; 这一行代码的作用是确保 switch 语句覆盖了所有可能的 shape.kind。 如果 shape 存在 switch 未处理的 kind，那么 _exhaustiveCheck 就不会是 never 类型， TypeScript 会报错，提示你遗漏了情况。

2.2 Product Types (乘积类型)

乘积类型就是把多个类型组合成一个新的类型。 在 TypeScript 中，对象类型和接口就是典型的乘积类型。

例子：一个表示用户信息的类型

interface User {
  id: number;
  name: string;
  email: string;
  age: number;
}

const user: User = {
  id: 123,
  name: '李四',
  email: '[email protected]',
  age: 25
};

console.log('用户姓名：', user.name);
console.log('用户年龄：', user.age);

在这个例子中，User 类型就是一个乘积类型，它包含了 id、name、email 和 age 四个属性。 user 对象必须同时拥有这四个属性，才能符合 User 类型的要求。

乘积类型与联合类型的结合

我们可以把乘积类型和联合类型结合起来，创造出更复杂的类型。

例子：一个表示地址的类型，地址可以是国内地址或国外地址

type DomesticAddress = {
  country: '中国';
  province: string;
  city: string;
  street: string;
};

type ForeignAddress = {
  country: string;
  province?: string;
  city: string;
  street: string;
  zipCode: string;
};

type Address = DomesticAddress | ForeignAddress;

function printAddress(address: Address) {
  if (address.country === '中国') {
    console.log('国内地址：', address.province, address.city, address.street);
  } else {
    console.log('国外地址：', address.country, address.city, address.street, address.zipCode);
  }
}

const domesticAddress: Address = {
  country: '中国',
  province: '北京',
  city: '北京',
  street: '长安街'
};

const foreignAddress: Address = {
  country: '美国',
  city: '纽约',
  street: '第五大道',
  zipCode: '10001'
};

printAddress(domesticAddress);
printAddress(foreignAddress);

在这个例子中，Address 类型是一个联合类型，它可以是 DomesticAddress (国内地址) 或 ForeignAddress (国外地址)。 DomesticAddress 和 ForeignAddress 都是乘积类型，分别包含了不同的属性。

三、用 ADT 提升代码健壮性

ADT 的威力在于，它可以让类型系统更好地理解你的代码意图，从而在编译时发现更多错误。

3.1 避免无效状态

使用 ADT 可以避免程序进入无效状态。

例子：一个表示状态的类型，状态可以是加载中、已加载或错误

type LoadingState = { status: 'loading' };
type LoadedState<T> = { status: 'loaded', data: T };
type ErrorState = { status: 'error', message: string };

type State<T> = LoadingState | LoadedState<T> | ErrorState;

function renderState<T>(state: State<T>): string {
  switch (state.status) {
    case 'loading':
      return '加载中...';
    case 'loaded':
      return `数据：${state.data}`;
    case 'error':
      return `错误：${state.message}`;
    default:
      const _exhaustiveCheck: never = state;
      return _exhaustiveCheck;
  }
}

const loadingState: State<any> = { status: 'loading' };
const loadedState: State<string> = { status: 'loaded', data: 'Hello, world!' };
const errorState: State<any> = { status: 'error', message: '网络错误' };

console.log(renderState(loadingState));
console.log(renderState(loadedState));
console.log(renderState(errorState));

在这个例子中，State 类型只能是 loading、loaded 或 error 三种状态之一。 你不可能创建一个既是 loading 又是 loaded 的状态。 这样就避免了程序进入无效状态，提高了代码的健壮性。

3.2 强制处理所有情况

使用 ADT 可以强制你处理所有可能的情况，避免遗漏。

例子：一个表示颜色的类型，颜色可以是红色、绿色或蓝色

type Color = 'red' | 'green' | 'blue';

function getColorName(color: Color): string {
  switch (color) {
    case 'red':
      return '红色';
    case 'green':
      return '绿色';
    case 'blue':
      return '蓝色';
    default:
      // 如果你添加了新的颜色，但忘记在这里处理，TypeScript 会报错
      const _exhaustiveCheck: never = color;
      return _exhaustiveCheck;
  }
}

console.log(getColorName('red'));
console.log(getColorName('green'));
console.log(getColorName('blue'));

在这个例子中，Color 类型只能是 red、green 或 blue 三种颜色之一。 如果你添加了一个新的颜色，比如 yellow，但忘记在 getColorName 函数中处理，TypeScript 会报错，提醒你遗漏了情况。

3.3 提高代码可读性和可维护性

使用 ADT 可以让代码更易于理解和维护。

例子：一个表示表达式的类型，表达式可以是数字、加法或乘法

type Expression =
  | { type: 'number', value: number }
  | { type: 'addition', left: Expression, right: Expression }
  | { type: 'multiplication', left: Expression, right: Expression };

function evaluate(expression: Expression): number {
  switch (expression.type) {
    case 'number':
      return expression.value;
    case 'addition':
      return evaluate(expression.left) + evaluate(expression.right);
    case 'multiplication':
      return evaluate(expression.left) * evaluate(expression.right);
    default:
      const _exhaustiveCheck: never = expression;
      return _exhaustiveCheck;
  }
}

const numberExpression: Expression = { type: 'number', value: 10 };
const additionExpression: Expression = { type: 'addition', left: numberExpression, right: { type: 'number', value: 5 } };
const multiplicationExpression: Expression = { type: 'multiplication', left: additionExpression, right: { type: 'number', value: 2 } };

console.log('表达式结果：', evaluate(multiplicationExpression)); // (10 + 5) * 2 = 30

在这个例子中，Expression 类型清晰地定义了表达式的结构。 你可以很容易地理解表达式可以是数字、加法或乘法。 这种清晰的结构使得代码更易于理解和维护。

四、ADT 的实际应用场景

ADT 在实际开发中有很多应用场景。

• 状态管理: 用 ADT 来表示应用程序的状态，例如加载中、已加载、错误等。
• 表单验证: 用 ADT 来表示表单字段的验证结果，例如有效、无效、必填等。
• 解析器: 用 ADT 来表示语法树，例如表达式、语句、函数等。
• 事件处理: 用 ADT 来表示事件类型，例如点击事件、鼠标移动事件、键盘事件等。
• 错误处理: 用 ADT 来表示错误类型，例如网络错误、文件错误、权限错误等。

五、ADT 的一些注意事项

• 过度使用: 不要为了使用 ADT 而使用 ADT。 如果一个类型很简单，直接用基本类型就可以了，没必要用 ADT。
• 命名规范: 给 ADT 的判别器属性起一个有意义的名字，例如 type、kind、status 等。
• 类型推断: TypeScript 的类型推断能力很强，可以自动推断出 ADT 的类型。 但有时候需要手动指定类型，以提高代码的可读性。
• 与第三方库的集成: 一些第三方库可能没有使用 ADT，需要进行适配。

六、总结

ADT 是 TypeScript 中一种强大的类型工具，可以帮助我们编写更健壮、更易于维护的代码。 通过合理地使用 ADT，我们可以将类型系统变成我们的第一道防线，在编译时发现更多错误，从而提高代码的质量。 希望今天的讲解能帮助大家更好地理解和使用 ADT，并在实际开发中应用它们。

一些方便大家理解的表格整理：

特性	Sum Types (联合类型)	Product Types (乘积类型)
概念	"或" 的关系，一个变量可以是多种类型中的一种。	"与" 的关系，一个类型包含多个属性。
TypeScript 语法	type MyType = TypeA | TypeB | TypeC;	interface MyInterface { prop1: TypeA; prop2: TypeB; }
例子	type Result = { success: true, data: string } | { success: false, error: string }	interface User { id: number; name: string; email: string; }
适用场景	表示多种可能的状态或结果。	表示一个实体或对象的多个属性。
优势	强制处理所有可能的情况，避免无效状态。	清晰地定义数据结构，提高代码可读性。
与 Discriminated Unions 的关系	Discriminated Unions 是 Sum Types 的一种更方便的用法。	–

ADT 的优点	描述
避免无效状态	通过限制类型可能的值，防止程序进入不应该存在的状态。 例如，一个状态只能是 "loading"、"loaded" 或 "error"，不能同时是多个状态。
强制处理所有情况	使用 switch 语句和 _exhaustiveCheck，确保处理了所有可能的类型。 如果添加了新的类型，但忘记在 switch 语句中处理，TypeScript 会报错，提醒你遗漏了情况。
提高代码可读性和可维护性	ADT 可以清晰地定义数据的结构，让代码更易于理解和维护。 例如，一个表达式可以是数字、加法或乘法，这种清晰的结构使得代码更易于理解和维护。
增强类型安全性	利用类型系统在编译时发现错误，减少运行时错误。 例如，如果你试图访问一个联合类型中不存在的属性，TypeScript 会报错。
更好的代码组织	通过将相关的类型组合在一起，可以更好地组织代码。 例如，可以将所有与用户相关的类型（例如 User、Address、Role）放在一个文件中。
更容易进行重构	如果你需要修改一个 ADT，TypeScript 会自动检查代码中所有使用该 ADT 的地方，并提示你进行相应的修改。 这使得重构代码更加安全和容易。

希望这些表格能帮助大家更好地理解 ADT 的概念和优点。 现在，大家可以开始尝试在自己的项目中应用 ADT 了！ 祝大家编程愉快！