为何TypeScript函数重载需重复二次签名才能生效？

我定义了泛型类型Result，它是错误实现ErrImpl与成功实现OkImpl的联合类型：

• 确定成功状态：Result<T, never>
• 确定错误状态：Result<never, E>
• 不确定状态：Result<T, E>（可能成功或错误）

我需要实现and<U>(res: Result<U, E>): Result<U, E>方法，规则是：

• 当this为Ok时返回传入的res
• 当this为Err时返回this

返回类型的错误泛型E需要满足：

• 若this和res的E一个为never，返回类型取非never的那个
• 若两者都是never，则返回never

我通过函数重载实现了需求，但发现必须重复第二个签名两次才能生效，否则类型系统仅识别第一个重载。实现代码如下：

class ErrImpl<E> {
  readonly val: E

  readonly isError = true;

  constructor(val: E) {
    this.val = val
  }

  and<E, U>(this: Result<any, never>, res: Result<U, E>): Result<U, E>
  and<E, U>(this: Result<any, E>, res: Result<U, NoInfer<E>>): Result<U, E>
  and<E, U>(this: Result<any, E>, res: Result<U, NoInfer<E>>): Result<U, E> {
    return this as Result<U, E>
  }
}

class OkImpl<T> {
  readonly val: T

  readonly isError = false;

  constructor(val: T) {
    this.val = val
  }

  and<E, U>(this: Result<any, never>, res: Result<U, E>): Result<U, E>
  and<E, U>(this: Result<any, E>, res: Result<U, NoInfer<E>>): Result<U, E>
  and<E, U>(this: Result<any, E>, res: Result<U, NoInfer<E>>): Result<U, E> {
    return res
  }
}

export type Result<T, E> = OkImpl<T> | ErrImpl<E>

export const Ok = <T>(val: T): Result<T, never> => { return new OkImpl(val) }
export const Err = <E>(val: E): Result<never, E> => { return new ErrImpl(val) }

原因解析 #

这是TypeScript重载解析机制的特性导致的：
当处理联合类型（比如Result<T,E>是OkImpl|ErrImpl）的方法调用时，编译器会逐个尝试将重载签名与联合类型的每个成员匹配。重复第二个签名的核心作用是提升不确定状态下类型推断的优先级，解决never类型的特殊性问题：

1. 第一个签名this: Result<any, never>专门匹配确定的成功状态（Ok），此时res的E能被正确推断，返回Result<U,E>。
2. 第二个签名中的NoInfer<E>用于阻止编译器从res参数反向推断this的E类型，但由于never是所有类型的子类型，仅写一次时，编译器可能优先匹配第一个签名（即使this是错误状态），导致推断失效。重复签名相当于给编译器多一次匹配机会，确保联合类型的所有分支都能被正确覆盖。

优化方案（无需重复签名） #

可以通过明确区分ErrImpl和OkImpl的this类型签名，利用联合类型的分发特性实现需求，无需重复重载：

class ErrImpl<E> {
  readonly val: E;
  readonly isError = true;

  constructor(val: E) {
    this.val = val;
  }

  and<U, E2 = E>(this: ErrImpl<E>, res: Result<U, E2>): Result<U, E | E2>;
  and<U, E2>(this: OkImpl<any>, res: Result<U, E2>): Result<U, E2>;
  and<U, E2>(res: Result<U, E2>): Result<U, E | E2> {
    return this.isError ? (this as unknown as Result<U, E | E2>) : res;
  }
}

class OkImpl<T> {
  readonly val: T;
  readonly isError = false;

  constructor(val: T) {
    this.val = val;
  }

  and<U, E2>(this: OkImpl<T>, res: Result<U, E2>): Result<U, E2>;
  and<U, E2 = never>(this: ErrImpl<any>, res: Result<U, E2>): Result<U, E2>;
  and<U, E2>(res: Result<U, E2>): Result<U, E2> {
    return res;
  }
}

export type Result<T, E> = OkImpl<T> | ErrImpl<E>;

export const Ok = <T>(val: T): Result<T, never> => new OkImpl(val);
export const Err = <E>(val: E): Result<never, E> => new ErrImpl(val);

这个版本通过E | E2自动处理never的合并逻辑（never与任何类型的联合结果都是该类型，never | never = never），同时明确的this类型签名让编译器能准确匹配联合类型的每个成员，无需重复重载签名。

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