Typescript 控制流分析无法识别已知类型

Question

我试图理解为什么需要明确告诉编译器 Policies 中的值的类型。类型是，尽管它只能是我的 Types 之一。

type Types = 'baz' | 'bar';

// tagged union types
type Foo<T extends Types> = { type: T; }
type FooOne = { one: string } & Foo<'baz'>;
type FooAnother = { another: string } & Foo<'bar'>;

type Predicate<T extends Types> = (e: Foo<T>) => boolean;

type Policies = {
    [P in Types]: Predicate<P>
}

const policies: Policies = {
    baz: (e: FooOne) => e.one === 'neo',
    bar: (e: FooAnother) => e.another === 'morphieus'
}

// this method receives a union type
function verify(e: FooOne | FooAnother) {
    // these both work, understandably
    if (e.type === 'baz') {
        const policy1 = policies[e.type]; // ide says this type is a Predicate<'baz'>
        const result1 = policy1(e); // fine  
    } else {
        const policy2 = policies[e.type]; // and this is a Predicate<'bar'>
        const result2 = policy2(e); // fine
    }

    // but this doesn't work even though e.type is known to be 'baz' | 'bar', and the keys at policies can only be 'baz' | 'bar'
    const policy3 = policies[e.type]; // ide says this type is a Predicate<'bar'> | Predicate<'baz'>
    const result3 = policy3(e); // error Cannot invoke an expression whose type lacks a call signature  

    // this works, if i hint to the compiler what is at policies[T]
    const policy4: Predicate<Types> = policies[e.type]; // Predicate<'baz' | bar'>
    const result4 = policy4(e); // fine 
}

Answer 1

这里没有好的解决方案，您需要某种类型断言才能使事情正常工作。

问题在于流分析无法跟踪值的来源。所以当你写:

const policy3 = policies[e.type]; 
const result3 = policy3(e);

policy3将是Predicate<"baz"> | Predicate<"bar">但编译器不知道是哪一个。当您调用policy3时因为它不知道变量中实际上是哪种函数类型，所以在较新的版本中，它将强制您指定一个可以与联合中的任一函数一起使用的参数。它不记得policy3 si 实际上绑定(bind)到 e.type和policy3(e)将是类型安全的。 (仅供引用:在旧版本中 policy3 根本无法调用，因为它是一个联合)

此代码有效:

const policy4= policies[e.type] as Predicate<Types> ; // Predicate<'baz' | bar'>
const result4 = policy4(e); // fine 

但是Predicate<"baz"> | Predicate<"bar">与 Predicate<Types> 不同。前者是一个需要 baz 的函数或采用 bar 的函数后者是一个函数，它接受 baz或bar 。因此，该调用将起作用，因为您已断言该函数可以接受任一参数类型(这并不完全正确，但就像我所说的没有好的解决方案)。