在打字稿中使用带有currying的文字时如何防止缩小泛型类型？

Question

我在为 Sanctuary（函数式编程的 js 库）设计类型时遇到问题。我想创建Ord 类型，代表任何具有自然顺序的值。 Ord 是：

1. 一些内置的原始类型：number，string，Date，boolean
2. 实现所需接口的任何用户类型（compareTo 方法）
3. Ords 的数组

为了表达它，我使用了（这对我来说很自然）联合类型（与使重复类型成为可能的轻微变通方法），例如：

type Ord = boolean | Date | number | string | Comparable<any> | OrderedArray

interface OrderedArray extends Array<Ord> {}

（我提到的任何代码都可以在 typescript playground 获得）。

然后，创建类型定义，例如compare 函数，我使用了带有类型约束的泛型类型，即类似（注意它是咖喱）：

function compare<T extends Ord>(a: T): (b: T) => number

不幸的是，在使用带有文字参数的这种方法时，例如（compare(2)(3)，这是完全有效的代码），打字稿错误，'3' is not assignable to '2'。似乎在提供第一个参数的情况下，typescript 将类型参数缩小到2（文字类型只包含2 值），而它应该只缩小到number。有什么办法可以阻止他这样做吗？或者任何其他工作方法？

Answer 1

如果编译器doesn't do it（例如这里T 的上下文类型包括string、number 和boolean），您也可以使用类型系统自己进行字面扩展：

type Widen<T> = 
  T extends string ? string : 
  T extends number ? number : 
  T extends boolean ? boolean : 
  T;

const compare = <T extends Ord>(x: T) => (y: Widen<T>) => 0;

所以x 将保持狭窄，但y 将变宽。这将允许以下调用：

compare(1)(3);  // <1>(x: 1) => (y: number) => number

希望有所帮助；祝你好运！

Link to code

---

更新：如果您真的希望能够选择性地保持 T 狭窄，您可以做以下复杂的事情：

type OptionallyWiden<X, T> = 
   [X] extends [never] ? 
     T extends string ? string : 
     T extends number ? number : 
     T extends boolean ? boolean : 
     T
  : T;

const compare = <X extends Ord = never, T extends Ord = X>(x: T) => (
  y: OptionallyWiden<X, T>
) => 0;

这会给你这种行为：

compare(1)(3); // okay
// const compare: <never, 1>(x: 1) => (y: number) => number

compare<1 | 2>(1)(3); // error now
//  ------------> ~
// 3 is not assignable to 1 | 2
// const compare: <1 | 2, 1 | 2>(x: 1 | 2) => (y: 1 | 2) => number

它通过使用两个类型参数来工作...第一个，X，将默认为never，除非手动指定。如果X 是never，则T 的推断值将被扩大。如果X 不是never，则将使用指定的值而不是加宽。

这里的灵活性值得怪异笨重的类型杂耍吗？我想这由你来决定，但如果我想要灵活地同时拥有窄和宽 T 值，我可能会保留原来的 <T extends Ord>(x: T) => (y: T) => 0，如果这是我想要的，只需手动加宽 T。

无论如何，希望这会再次有所帮助！

Link to code

Answer 2

我最终想通了（至少以一种工作的方式，不一定是最好的）。事实证明，为所有具有文字表示的类型添加显式重载，因此可以缩小范围，修复它，例如：

function compare(x: number): (y: number) => number;
function compare(y: string): (y: string) => number;
function compare(x: boolean): (y: boolean) => number;

// and generic overload
function compare<T extends Ord>(x: T): (y: T) => number;
function compare<T extends Ord>(x: T): (y: T) => number {
  ...
};

我认为这些显式重载在签名解析中具有优先权，因此我的问题消失了，例如：

compare(2)(3) // resolves to compare(x: number)(y: number)

typescript playground 提供解决方案。

Answer 3

如果您简化Ord 的定义，则所有测试都会通过。

interface Comparable<T> {
  compareTo(other: T): number
}

type Ord<T> = T | Comparable<T> | Array<T>

const compare = <T extends Ord<any>>(x: T) => (y: T) => 0;

TypeScript Playground link.

不过，我不确定这是否符合库的所有其他要求。