René's URL Explorer Experiment

Title: Conditional types by ahejlsberg · Pull Request #21316 · microsoft/TypeScript · GitHub

Open Graph Title: Conditional types by ahejlsberg · Pull Request #21316 · microsoft/TypeScript

X Title: Conditional types by ahejlsberg · Pull Request #21316 · microsoft/TypeScript

Description: This PR introduces conditional types which add the ability to express non-uniform type mappings. A conditional type selects one of two possible types based on a condition expressed as a type relationship test: T extends U ? X : Y The type above means when T is assignable to U the type is X, otherwise the type is Y. Evaluation of a conditional type is deferred when evaluation of the condition depends on type variables in T or U, but is resolved to either X or Y when the condition depends on no type variables. An example: type TypeName = T extends string ? "string" : T extends number ? "number" : T extends boolean ? "boolean" : T extends undefined ? "undefined" : T extends Function ? "function" : "object"; type T0 = TypeName; // "string" type T1 = TypeName<"a">; // "string" type T2 = TypeName; // "boolean" type T3 = TypeName<() => void>; // "function" type T4 = TypeName; // "object" Conditional types in which the checked type is a naked type parameter are called distributive conditional types. Distributive conditional types are automatically distributed over union types during instantiation. For example, an instantiation of T extends U ? X : Y with the type argument A | B | C for T is resolved as (A extends U ? X : Y) | (B extends U ? X : Y) | (C extends U ? X : Y). type T10 = TypeName void)>; // "string" | "function" type T12 = TypeName; // "string" | "object" | "undefined" type T11 = TypeName; // "object" In instantiations of a distributive conditional type T extends U ? X : Y, references to T within the conditional type are resolved to individual constituents of the union type (i.e. T refers to the individual constituents after the conditional type is distributed over the union type). Furthermore, references to T within X have an additional type parameter constraint U (i.e. T is considered assignable to U within X). type BoxedValue = { value: T }; type BoxedArray = { array: T[] }; type Boxed = T extends any[] ? BoxedArray : BoxedValue; type T20 = Boxed; // BoxedValue; type T21 = Boxed; // BoxedArray; type T22 = Boxed; // BoxedValue | BoxedArray; Notice that T has the additional constraint any[] within the true branch of Boxed and it is therefore possible to refer to the element type of the array as T[number]. Also, notice how the conditional type is distributed over the union type in the last example. The distributive property of conditional types can conveniently be used to filter union types: type Diff = T extends U ? never : T; // Remove types from T that are assignable to U type Filter = T extends U ? T : never; // Remove types from T that are not assignable to U type T30 = Diff<"a" | "b" | "c" | "d", "a" | "c" | "f">; // "b" | "d" type T31 = Filter<"a" | "b" | "c" | "d", "a" | "c" | "f">; // "a" | "c" type T32 = Diff void), Function>; // string | number type T33 = Filter void), Function>; // () => void type NonNullable = Diff; // Remove null and undefined from T type T34 = NonNullable; // string | number type T35 = NonNullable; // string | string[] function f1(x: T, y: NonNullable) { x = y; // Ok y = x; // Error } function f2(x: T, y: NonNullable) { x = y; // Ok y = x; // Error let s1: string = x; // Error let s2: string = y; // Ok } Conditional types are particularly useful when combined with mapped types: type FunctionPropertyNames = { [K in keyof T]: T[K] extends Function ? K : never }[keyof T]; type FunctionProperties = Pick>; type NonFunctionPropertyNames = { [K in keyof T]: T[K] extends Function ? never : K }[keyof T]; type NonFunctionProperties = Pick>; interface Part { id: number; name: string; subparts: Part[]; updatePart(newName: string): void; } type T40 = FunctionPropertyNames; // "updatePart" type T41 = NonFunctionPropertyNames; // "id" | "name" | "subparts" type T42 = FunctionProperties; // { updatePart(newName: string): void } type T43 = NonFunctionProperties; // { id: number, name: string, subparts: Part[] } Combining all of the above to create a DeepReadonly type that recursively makes all properties of an object read-only and removes all function properties (i.e. methods): type DeepReadonly = T extends any[] ? DeepReadonlyArray : T extends object ? DeepReadonlyObject : T; interface DeepReadonlyArray extends ReadonlyArray> {} type DeepReadonlyObject = { readonly [P in NonFunctionPropertyNames]: DeepReadonly; }; function f10(part: DeepReadonly) { let name: string = part.name; let id: number = part.subparts[0].id; part.id = part.id; // Error part.subparts[0] = part.subparts[0]; // Error part.subparts[0].id = part.subparts[0].id; // Error part.updatePart("hello"); // Error } Similar to union and intersection types, conditional types are not permitted to reference themselves recursively (however, indirect references through interface types or object literal types are allowed, as illustrated by the DeepReadonly example above). For example the following is an error: type ElementType = T extends any[] ? ElementType : T; // Error For further examples see the tests associated with the PR. EDIT: See #21496 for type inference in conditional types. Fixes #12215. Fixes #12424.

Open Graph Description: This PR introduces conditional types which add the ability to express non-uniform type mappings. A conditional type selects one of two possible types based on a condition expressed as a type relati...

X Description: This PR introduces conditional types which add the ability to express non-uniform type mappings. A conditional type selects one of two possible types based on a condition expressed as a type relati...

Opengraph URL: https://github.com/microsoft/TypeScript/pull/21316

X: @github

direct link

Domain: github.com

Links:

Viewport: width=device-width