1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
|
=== tests/cases/compiler/input.d.ts ===
type _BuildPowersOf2LengthArrays<
>_BuildPowersOf2LengthArrays : _BuildPowersOf2LengthArrays<Length, AccumulatedArray>
Length extends number,
AccumulatedArray extends never[][],
> = AccumulatedArray[0][Length] extends never
? AccumulatedArray
: _BuildPowersOf2LengthArrays<
Length,
[[...AccumulatedArray[0], ...AccumulatedArray[0]], ...AccumulatedArray]
>;
type _ConcatLargestUntilDone<
>_ConcatLargestUntilDone : _ConcatLargestUntilDone<Length, AccumulatedArray, NextArray>
Length extends number,
AccumulatedArray extends never[][],
NextArray extends never[],
> = NextArray['length'] extends Length
? NextArray
: [...AccumulatedArray[0], ...NextArray][Length] extends never
? _ConcatLargestUntilDone<
Length,
AccumulatedArray extends [AccumulatedArray[0], ...infer U]
? U extends never[][]
? U
: never
: never,
NextArray
>
: _ConcatLargestUntilDone<
Length,
AccumulatedArray extends [AccumulatedArray[0], ...infer U]
? U extends never[][]
? U
: never
: never,
[...AccumulatedArray[0], ...NextArray]
>
type _Replace<R extends unknown[], T> = { [K in keyof R]: T };
>_Replace : _Replace<R, T>
export type TupleOf<Type, Length extends number> = number extends Length
>TupleOf : TupleOf<Type, Length>
? Type[]
: {
// in case Length is a union
[LengthKey in Length]: _BuildPowersOf2LengthArrays<
LengthKey,
[[never]]
> extends infer TwoDimensionalArray
? TwoDimensionalArray extends never[][]
? _Replace<_ConcatLargestUntilDone<LengthKey, TwoDimensionalArray, []>, Type>
: never
: never
}[Length];
export type Subtract<N1 extends number, N2 extends number> = TupleOf<never, N1> extends [
>Subtract : Subtract<N1, N2>
...TupleOf<never, N2>,
...infer R,
]
? R['length']
: never;
export type Decrement<T extends number> = Subtract<T, 1>;
>Decrement : Decrement<T>
export type Add<N1 extends number, N2 extends number> = [
>Add : Add<N1, N2>
...TupleOf<never, N1>,
...TupleOf<never, N2>,
]['length'] &
// intersection to suppress compiler narrowing bug
number;
type _MultiAdd<
>_MultiAdd : _MultiAdd<Num, Accumulator, IterationsLeft>
Num extends number,
Accumulator extends number,
IterationsLeft extends number,
> = IterationsLeft extends 0
? Accumulator
: _MultiAdd<Num, Add<Num, Accumulator>, Decrement<IterationsLeft>>
export type Multiply<N1 extends number, N2 extends number> = number extends N1 | N2
>Multiply : Multiply<N1, N2>
? number
: {
[K2 in N2]: { [K1 in N1]: _MultiAdd<K1, 0, N2> }[N1]
}[N2]
type PowerTailRec<
>PowerTailRec : PowerTailRec<Num, PowerOf, Result>
Num extends number,
PowerOf extends number,
Result extends number,
> = number extends PowerOf
? number
: PowerOf extends 0
? Result
: PowerTailRec<Num, Decrement<PowerOf>, Multiply<Result, Num>>;
export type Power<Num extends number, PowerOf extends number> = PowerTailRec<Num, PowerOf, 1>;
>Power : Power<Num, PowerOf>
=== tests/cases/compiler/a.tsx ===
import { Power } from "./input";
>Power : any
export const power = <Num extends number, PowerOf extends number>(
>power : <Num extends number, PowerOf extends number>(num: Num, powerOf: PowerOf) => Power<Num, PowerOf>
><Num extends number, PowerOf extends number>( num: Num, powerOf: PowerOf): Power<Num, PowerOf> => (num ** powerOf) as never : <Num extends number, PowerOf extends number>(num: Num, powerOf: PowerOf) => Power<Num, PowerOf>
num: Num,
>num : Num
powerOf: PowerOf
>powerOf : PowerOf
): Power<Num, PowerOf> => (num ** powerOf) as never;
>(num ** powerOf) as never : never
>(num ** powerOf) : number
>num ** powerOf : number
>num : Num
>powerOf : PowerOf
|
