基于种类的类型推断的打字稿语法

Question

我在编写正确的 typescript 语法以严格推断 where 时遇到问题：

1. 编译器正确报告缺少的 switch/case 选项
2. 返回值按类型匹配输入类型

type KindA = {kind:'a'};
type KindB = {kind:'b'};
type KindC = {kind:'c'};
type AllKinds = KindA | KindB | KindC;

function create<T extends AllKinds>(kind:AllKinds['kind']):T {
  switch(kind) {
    case "a": return {kind:'a'};
    case "b": return {kind:'b'};
    case "c": return {kind:'c'};
  }
}

create("a");

Playground

我想知道最新的 Typescript 是否可以做到这一点。

使用我的其他方法（即case "a": return {kind:'b'} as T;），返回的值未根据我的需要进行类型检查。

Answer 1

在您的情况下返回T 是不安全的。

看看为什么：

type KindA = { kind: 'a' };
type KindB = { kind: 'b' };
type KindC = { kind: 'c' };
type AllKinds = KindA | KindB | KindC;

function create<T extends AllKinds>(kind: AllKinds['kind']): T {
  switch (kind) {
    case "a": return { kind: 'a' };
    case "b": return { kind: 'b' };
    case "c": return { kind: 'c' };
  }
}

const result = create<{ kind: 'a', WAAAT: () => {} }>("a")
result.WAAAT() // compiler but causes an error in runtime

通用参数在 90% 的情况下应取决于输入值。

看这个例子：

type KindA = { kind: 'a' };
type KindB = { kind: 'b' };
type KindC = { kind: 'c' };
type AllKinds = KindA | KindB | KindC;


const builder = <Kind extends AllKinds['kind']>(kind: Kind) => ({ kind })

const result = builder("a"); // {kind: 'a' }

Playground

请参阅this 答案、this 答案和我的article 了解更多上下文

我说得对吗，女巫当前的 Typescript，不能两者兼得？

问题不在于switch 语句，而在于显式返回类型。返回类型不能依赖于未绑定函数参数的泛型值。

其实你想要的都是可以实现的：

type KindA = { kind: 'a' };
type KindB = { kind: 'b' };
type KindC = { kind: 'c' };
type AllKinds = KindA | KindB | KindC;

function create<Kind extends AllKinds['kind']>(kind: Kind): Extract<AllKinds, { kind: Kind }>
function create(kind: AllKinds['kind']) {
    switch (kind) {
        case "a": return { kind: 'a' };
        case "b": return { kind: 'b' };
        case "c": return { kind: 'c' };
    }
}

const result1 = create("a") // KindA
const result2 = create("b") // KindB
const result3 = create("c") // KindC

Playground

您可能已经注意到，我使用了function overloading。它使 TS 编译器不那么严格。换句话说，提供了一些不安全性，但同时使其更具可读性并推断返回类型。

AFAIK，函数重载行为bivariantly。因此，由您决定哪个选项更好

Answer 2

错误描述性很强。

Type '{ kind: "a"; }' is not assignable to type 'T'.
  '{ kind: "a"; }' is assignable to the constraint of type 'T',
  but 'T' could be instantiated with a different subtype of constraint 'AllKinds'.

即使使用更简单的类型约束也会出现此问题。

function foo<T extends string>(): T {
  return 'foo';
}

这里我们会得到以下错误。

Type 'string' is not assignable to type 'T'.
  'string' is assignable to the constraint of type 'T',
  but 'T' could be instantiated with a different subtype of constraint 'string'.

问题是我们说我们会返回T 类型的东西，但T 与string 的类型不同。是的，T 类型扩展了string，但这意味着T 是string 的子类型。例如，'bar' 类型是string 的子类型。因此，我们可以用'bar' 实例化T。因此，我们希望返回值为'bar'，但返回值为'foo'。

解决方案就是不使用泛型。如果您想返回string，那么只需说您要返回string。不要说您正在返回某个子类型 T 或 string 的值。

function foo(): string {
  return 'foo';
}

同样，如果您想返回一个AllKinds 类型的值，那么只需说您要返回一个AllKinds 类型的值。不要说您正在返回某个子类型 T 或 AllKinds 的值。

type KindA = {kind:'a'};
type KindB = {kind:'b'};
type KindC = {kind:'c'};
type AllKinds = KindA | KindB | KindC;

function create(kind:AllKinds['kind']): AllKinds {
  switch(kind) {
    case "a": return {kind:'a'};
    case "b": return {kind:'b'};
    case "c": return {kind:'c'};
  }
}

create("a");

---

编辑：你需要依赖类型来做你想做的事。 TypeScript 没有依赖类型。但是，您可以创建一个自定义折叠函数来提供额外的类型安全性。

type Kind = 'a' | 'b' | 'c';

type KindA = { kind: 'a' };
type KindB = { kind: 'b' };
type KindC = { kind: 'c' };

type AllKinds = KindA | KindB | KindC;

function foldKind<A, B, C>(a: A, b: B, c: C): (kind: Kind) => A | B | C {
  return function (kind: Kind): A | B | C {
    switch (kind) {
      case 'a': return a;
      case 'b': return b;
      case 'c': return c;
    }
  }
}

const create: (kind: Kind) => AllKinds = foldKind<KindA, KindB, KindC>(
  { kind: 'a' },
  { kind: 'b' },
  { kind: 'c' }
);

现在，您只能为'a' 提供KindA 的值，为'b' 提供KindB 的值，为'c' 提供KindC 的值。亲自查看demo。