|
| 1 | +// @strict: true |
| 2 | +// @declaration: true |
| 3 | + |
| 4 | +type Unpacked<T> = |
| 5 | + T extends (infer U)[] ? U : |
| 6 | + T extends (...args: any[]) => infer U ? U : |
| 7 | + T extends Promise<infer U> ? U : |
| 8 | + T; |
| 9 | + |
| 10 | +type T00 = Unpacked<string>; // string |
| 11 | +type T01 = Unpacked<string[]>; // string |
| 12 | +type T02 = Unpacked<() => string>; // string |
| 13 | +type T03 = Unpacked<Promise<string>>; // string |
| 14 | +type T04 = Unpacked<Unpacked<Promise<string>[]>>; // string |
| 15 | +type T05 = Unpacked<any>; // any |
| 16 | +type T06 = Unpacked<never>; // never |
| 17 | + |
| 18 | +type ReturnType<T extends Function> = T extends ((...args: any[]) => infer R) | (new (...args: any[]) => infer R) ? R : any; |
| 19 | + |
| 20 | +function f1(s: string) { |
| 21 | + return { a: 1, b: s }; |
| 22 | +} |
| 23 | + |
| 24 | +class C { |
| 25 | + x = 0; |
| 26 | + y = 0; |
| 27 | +} |
| 28 | + |
| 29 | +type T10 = ReturnType<() => string>; // string |
| 30 | +type T11 = ReturnType<(s: string) => void>; // void |
| 31 | +type T12 = ReturnType<(<T>() => T)>; // {} |
| 32 | +type T13 = ReturnType<(<T extends U, U extends number[]>() => T)>; // number[] |
| 33 | +type T14 = ReturnType<typeof f1>; // { a: number, b: string } |
| 34 | +type T15 = ReturnType<typeof C>; // C |
| 35 | +type T16 = ReturnType<any>; // any |
| 36 | +type T17 = ReturnType<never>; // any |
| 37 | +type T18 = ReturnType<string>; // Error |
| 38 | +type T19 = ReturnType<Function>; // any |
| 39 | + |
| 40 | +type ArgumentType<T extends (x: any) => any> = T extends (a: infer A) => any ? A : any; |
| 41 | + |
| 42 | +type T20 = ArgumentType<() => void>; // never |
| 43 | +type T21 = ArgumentType<(x: string) => number>; // string |
| 44 | +type T22 = ArgumentType<(x?: string) => number>; // string | undefined |
| 45 | +type T23 = ArgumentType<(...args: string[]) => number>; // string |
| 46 | +type T24 = ArgumentType<(x: string, y: string) => number>; // Error |
| 47 | +type T25 = ArgumentType<Function>; // Error |
| 48 | +type T26 = ArgumentType<any>; // any |
| 49 | +type T27 = ArgumentType<never>; // any |
| 50 | + |
| 51 | +type X1<T extends { x: any, y: any }> = T extends { x: infer X, y: infer Y } ? [X, Y] : any; |
| 52 | + |
| 53 | +type T30 = X1<{ x: any, y: any }>; // [any, any] |
| 54 | +type T31 = X1<{ x: number, y: string }>; // [number, string] |
| 55 | +type T32 = X1<{ x: number, y: string, z: boolean }>; // [number, string] |
| 56 | + |
| 57 | +type X2<T> = T extends { a: infer U, b: infer U } ? U : never; |
| 58 | + |
| 59 | +type T40 = X2<{}>; // never |
| 60 | +type T41 = X2<{ a: string }>; // never |
| 61 | +type T42 = X2<{ a: string, b: string }>; // string |
| 62 | +type T43 = X2<{ a: number, b: string }>; // string | number |
| 63 | +type T44 = X2<{ a: number, b: string, c: boolean }>; // string | number |
| 64 | + |
| 65 | +type X3<T> = T extends { a: (x: infer U) => void, b: (x: infer U) => void } ? U : never; |
| 66 | + |
| 67 | +type T50 = X3<{}>; // never |
| 68 | +type T51 = X3<{ a: (x: string) => void }>; // never |
| 69 | +type T52 = X3<{ a: (x: string) => void, b: (x: string) => void }>; // string |
| 70 | +type T53 = X3<{ a: (x: number) => void, b: (x: string) => void }>; // string & number |
| 71 | +type T54 = X3<{ a: (x: number) => void, b: () => void }>; // number |
0 commit comments