TypeScript元组互斥类型推断问题：Promise包装器类型窄化失效

我实现了一个Promise包装函数safePromise，它返回[结果, null]或[null, 错误]的元组。但遇到了类型推断异常：

• 当错误类型为string时，判断error存在并返回后，TypeScript无法将data的类型从Val | null正确窄化为Val
• 错误为数组或对象时，类型推断正常；非Promise场景下也能正确推断

safePromise实现代码：

async function safePromise<T>(promise: Promise<T>) {
  try {
    const res = await promise;
    return [res, null] as const;
  } catch (err) {
    return [null, err as IErr] as const;
  }
}

1. 字符串类型的推断局限：string是原始类型，TypeScript对原始类型与null组成的联合类型，无法通过元组中一个元素的存在，反向推断另一个元素必然为null。而对象/数组是引用类型，TypeScript能通过引用的存在性更准确地关联元组的互斥状态。
2. 异步函数的类型推导限制：异步函数的返回类型是分支类型的合并结果，as const虽然固定了元组字面量类型，但异步场景下TypeScript对分支间互斥关系的推导能力弱于同步场景，进一步放大了原始类型的推断问题。

方法1：明确指定互斥联合返回类型 #

直接给函数定义返回类型，让TypeScript清晰感知两个分支的互斥性：

type SafePromiseResult<T, E> = [T, null] | [null, E];

async function safePromise<T>(promise: Promise<T>): Promise<SafePromiseResult<T, IErr>> {
  try {
    const res = await promise;
    return [res, null] as const;
  } catch (err) {
    return [null, err as IErr] as const;
  }
}

方法2：自定义类型守卫函数 #

通过类型守卫强制TypeScript窄化元组类型：

function isSuccess<T, E>(result: [T, null] | [null, E]): result is [T, null] {
  return result[1] === null;
}

// 使用示例
const [data, error] = await safePromise(somePromise);
if (!isSuccess([data, error])) {
  console.error(error);
  return;
}
// 此时data类型已被正确窄化为T
console.log(data);

方法3：改用带判别式的对象返回 #

放弃元组，使用带明确标识的对象，从根源避免元组的类型推断歧义：

type SafeResult<T, E> = 
  | { success: true; data: T } 
  | { success: false; error: E };

async function safePromise<T>(promise: Promise<T>): Promise<SafeResult<T, IErr>> {
  try {
    const res = await promise;
    return { success: true, data: res };
  } catch (err) {
    return { success: false, error: err as IErr };
  }
}

// 使用示例
const result = await safePromise(somePromise);
if (!result.success) {
  console.error(result.error);
  return;
}
console.log(result.data); // 类型自动窄化为T

要让TypeScript识别返回值的严格互斥，需做到以下几点：

• 定义明确的互斥联合类型：直接声明两个完全互斥的类型分支（如[T, null]和[null, E]），让类型系统明确同一时刻只会是其中一种。
• 避免模糊的错误类型：确保错误类型IErr不包含null或与结果类型T重叠的类型，否则会破坏互斥性。
• 优先使用判别式对象：对象的判别式字段（如success）是TypeScript最可靠的互斥类型判断方式，比元组更适合异步场景。

内容的提问来源于stack exchange，提问作者Komi