typescript - "homomorphic mapped type"是什么意思？

Question

我在一些 TypeScript PR 中看到了术语“同​​态映射类型”。这是一个例子:https://github.com/microsoft/TypeScript/pull/21919

In --strictNullChecks mode, when a homomorphic mapped type removes a ? modifier from a property in the underlying type it also removes undefined from the type of that property

什么是同态映射类型？究竟什么是同态？是否有一个很好的例子 非 -同态映射类型

我困惑的原因是一个 homomorphism是保留特定操作的两个结构之间的映射。这里有问题的操作是什么？也就是说，哪里 f是映射，什么是 op在以下等式中:
f(x op y) = f(x) op f(y)
我试过的

我试着假设 op是 & ，相交两种类型的操作。

那么一个同态映射将是这样的:
F<T & U> = F<T> & F<U>
同态映射的一个例子(来自 the TS handbook)是:

type Partial<T> = { [P in keyof T]?: T[P] }

因为 Partial<T & U>始终与 Partial<T> & Partial<U> 相同.

问题是我想不出任何方法来使映射类型非同态!

即使像这样愚蠢的人看起来也是同态的:

type Silly<T> = { [P in "foo"]: number}

令我困惑的是 Silly似乎是同态( Silly <T & U> = Silly<T> & Silly<U> )。

这似乎与 handbook 的内容相矛盾说一个同态映射类型:

...homomorphic, which means that the mapping applies only to properties of T and no others. The compiler knows that it can copy all the existing property modifiers before adding any new ones

Silly蜜饯 &但不是手册中定义的同态映射类型。

Answer 1

在 TypeScript 中，同态映射类型特指一种类型，在该类型中，编译器识别您正在映射现有对象类型的属性。在这种情况下，输出对象类型将具有相同的 readonly和/或可选( ? )属性修饰符，就像输入类型上的属性一样。我知道有几种方法可以使映射类型同态，还有一些其他方法可以使它......不是。

在接下来的内容中，让我们使用这种类型作为映射对象:

type Foo = {
    norm: string,
    opt?: string,
    readonly ro: string,
    readonly both?: string
};

主要同态映射类型技术， in keyof :

type Hom1<T> = { [P in keyof T]: number };
type Hom2<T, U> = { [K in keyof (T & U)]: K extends keyof T ? "L" : "R" };
type Hom3 = { [Q in keyof { readonly a: string, b?: number }]: Q };

在上面，您明确地迭代 keyof某物。让我们看看当我们在我们的 Foo 上使用它们时您会得到什么类型:

type Hom1Foo = Hom1<Foo>;
/* type Hom1Foo = {
    norm: number;
    opt?: number | undefined;
    readonly ro: number;
    readonly both?: number | undefined;
}*/

type Hom2FooDate = Hom2<Foo, { z: boolean }>
/*type Hom2FooDate = {
    norm: "L";
    opt?: "L" | undefined;
    readonly ro: "L";
    readonly both?: "L" | undefined;
    z: "R";
} */

type Hom3Itself = Hom3
/* type Hom3Itself = {
    readonly a: "a";
    b?: "b" | undefined;
} */

您可以看到，在所有输出中，只读和可选标记都是从输入复制过来的。这是产生同态映射类型的主要技术，也是迄今为止最常见的技术。

二级同态映射类型技术， in K哪里 K extends keyof T是泛型类型参数和 T是泛型类型参数:

// <K extends keyof T, T> ... {[P in K]: ...}
type Hom4<T, K extends keyof T> = { [P in K]: 1 };

这特别使我们能够从对象的某些键中复制属性修饰符，并且是 implemented here ，主要是为了制作 the Pick<T, K> utility type同态的。让我们看看如何 Hom4行为与 Foo :

type Hom4AllKeys = Hom4<Foo, keyof Foo>;
/* type Hom4AllKeys = {
    norm: 1;
    opt?: 1 | undefined;
    readonly ro: 1;
    readonly both?: 1 | undefined;
}*/

type Hom4SomeKeys = Hom4<Foo, "opt" | "ro">;
/* type Hom4SomeKeys = {
    opt?: 1 | undefined;
    readonly ro: 1;
}*/

现在几乎任何其他映射类型的使用都给出了非同态类型。如果您不认为自己映射了不同对象类型的键，那么这并不是真正的问题。例如:

type NonHom0 = { [P in "a" | "b" | "c"]: 0 };
/* type NonHom0 = {
    a: 0;
    b: 0;
    c: 0;
}*/

NonHom0的属性既不是可选的，也不是只读的；为什么会这样？没有其他类型的键 a , b , 和 c从中复制它们。如果您开始想象您正在从其他对象类型复制属性，事情会变得有点棘手，但编译器并不这么认为:

type NonHom1 = { [P in "norm" | "opt" | "ro" | "both"]: Foo[P] };
/* type NonHom = {
    norm: string;
    opt: string | undefined;
    ro: string;
    both: string | undefined;
}*/

type KeysOfFoo = keyof Foo
type NonHom2 = { [K in KeysOfFoo]: 1 }
/* type NonHom2 = {
    norm: 1;
    opt: 1;
    ro: 1;
    both: 1;
} */

type NonHom3 = { [Q in Extract<keyof Foo, string>]: Foo[Q] };
/* type NonHom3 = {
    norm: string;
    opt: string | undefined;
    ro: string;
    both: string | undefined;
}*/

在这些情况下，映射是非同态的；输出类型既没有只读属性也没有可选属性。 ( | undefined 仍然存在于曾经是可选的属性上，但属性本身不是可选的)。确实，您仍在迭代 Foo 的键，但编译器不再看到与 Foo 的关系.在 NonHom1 ，键恰好相同，但没有 keyof ，因此编译器不会将映射识别为同态。在 NonHom2 ，您正在使用 keyof ，但编译器急切地求值 KeysOfFoo这样当你到达 NonHom2 时，它与 NonHom1 中的映射相同.在 NonHom3 ，您只是在迭代 string Foo 的 key (这是所有这些)，但同样，编译器丢失了线程并且不再识别 in Extract<keyof Foo, string>作为同态映射的触发器。有 workarounds, see microsoft/TypeScript#24679 ，但这里的重点是，如果您偏离 in keyof或 in K -哪里- K extends keyof T -和- K -和- T -are-generic，您将获得非同态映射。

哇，我完成了。在这之后的几天里，我不想写“同态”这个词。无论如何，希望有所帮助；祝你好运!

Playground link to code