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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
|
=== tests/cases/compiler/genericSpecializationToTypeLiteral1.ts ===
interface IEnumerable<T> {
>IEnumerable : IEnumerable<T>
>T : T
zip<TResult>(second: IEnumerable<T>, resultSelector: (first: T, second: T, index: number) => TResult): IEnumerable<TResult>;
>zip : { <TResult>(second: IEnumerable<T>, resultSelector: (first: T, second: T, index: number) => TResult): IEnumerable<TResult>; <TResult>(second: T[], resultSelector: (first: T, second: T, index: number) => TResult): IEnumerable<TResult>; <TResult>(...params: any[]): IEnumerable<TResult>; }
>TResult : TResult
>second : IEnumerable<T>
>IEnumerable : IEnumerable<T>
>T : T
>resultSelector : (first: T, second: T, index: number) => TResult
>first : T
>T : T
>second : T
>T : T
>index : number
>TResult : TResult
>IEnumerable : IEnumerable<T>
>TResult : TResult
zip<TResult>(second: T[], resultSelector: (first: T, second: T, index: number) => TResult): IEnumerable<TResult>;
>zip : { <TResult>(second: IEnumerable<T>, resultSelector: (first: T, second: T, index: number) => TResult): IEnumerable<TResult>; <TResult>(second: T[], resultSelector: (first: T, second: T, index: number) => TResult): IEnumerable<TResult>; <TResult>(...params: any[]): IEnumerable<TResult>; }
>TResult : TResult
>second : T[]
>T : T
>resultSelector : (first: T, second: T, index: number) => TResult
>first : T
>T : T
>second : T
>T : T
>index : number
>TResult : TResult
>IEnumerable : IEnumerable<T>
>TResult : TResult
zip<TResult>(...params: any[]): IEnumerable<TResult>; // last one is selector
>zip : { <TResult>(second: IEnumerable<T>, resultSelector: (first: T, second: T, index: number) => TResult): IEnumerable<TResult>; <TResult>(second: T[], resultSelector: (first: T, second: T, index: number) => TResult): IEnumerable<TResult>; <TResult>(...params: any[]): IEnumerable<TResult>; }
>TResult : TResult
>params : any[]
>IEnumerable : IEnumerable<T>
>TResult : TResult
merge<TResult>(...params: IEnumerable<T>[]): IEnumerable<T>;
>merge : { <TResult>(...params: IEnumerable<T>[]): IEnumerable<T>; <TResult>(...params: T[][]): IEnumerable<T>; }
>TResult : TResult
>params : IEnumerable<T>[]
>IEnumerable : IEnumerable<T>
>T : T
>IEnumerable : IEnumerable<T>
>T : T
merge<TResult>(...params: T[][]): IEnumerable<T>;
>merge : { <TResult>(...params: IEnumerable<T>[]): IEnumerable<T>; <TResult>(...params: T[][]): IEnumerable<T>; }
>TResult : TResult
>params : T[][]
>T : T
>IEnumerable : IEnumerable<T>
>T : T
concat(...sequences: IEnumerable<T>[]): IEnumerable<T>;
>concat : { (...sequences: IEnumerable<T>[]): IEnumerable<T>; (...sequences: T[]): IEnumerable<T>; }
>sequences : IEnumerable<T>[]
>IEnumerable : IEnumerable<T>
>T : T
>IEnumerable : IEnumerable<T>
>T : T
concat(...sequences: T[]): IEnumerable<T>;
>concat : { (...sequences: IEnumerable<T>[]): IEnumerable<T>; (...sequences: T[]): IEnumerable<T>; }
>sequences : T[]
>T : T
>IEnumerable : IEnumerable<T>
>T : T
insert(index: number, second: IEnumerable<T>): IEnumerable<T>;
>insert : (index: number, second: IEnumerable<T>) => IEnumerable<T>
>index : number
>second : IEnumerable<T>
>IEnumerable : IEnumerable<T>
>T : T
>IEnumerable : IEnumerable<T>
>T : T
sequenceEqual(second: IEnumerable<T>): boolean;
>sequenceEqual : { (second: IEnumerable<T>): boolean; <TCompare>(second: IEnumerable<T>, compareSelector: (element: T) => TCompare): boolean; (second: T[]): boolean; <TCompare>(second: T[], compareSelector: (element: T) => TCompare): boolean; }
>second : IEnumerable<T>
>IEnumerable : IEnumerable<T>
>T : T
sequenceEqual<TCompare>(second: IEnumerable<T>, compareSelector: (element: T) => TCompare): boolean;
>sequenceEqual : { (second: IEnumerable<T>): boolean; <TCompare>(second: IEnumerable<T>, compareSelector: (element: T) => TCompare): boolean; (second: T[]): boolean; <TCompare>(second: T[], compareSelector: (element: T) => TCompare): boolean; }
>TCompare : TCompare
>second : IEnumerable<T>
>IEnumerable : IEnumerable<T>
>T : T
>compareSelector : (element: T) => TCompare
>element : T
>T : T
>TCompare : TCompare
sequenceEqual(second: T[]): boolean;
>sequenceEqual : { (second: IEnumerable<T>): boolean; <TCompare>(second: IEnumerable<T>, compareSelector: (element: T) => TCompare): boolean; (second: T[]): boolean; <TCompare>(second: T[], compareSelector: (element: T) => TCompare): boolean; }
>second : T[]
>T : T
sequenceEqual<TCompare>(second: T[], compareSelector: (element: T) => TCompare): boolean;
>sequenceEqual : { (second: IEnumerable<T>): boolean; <TCompare>(second: IEnumerable<T>, compareSelector: (element: T) => TCompare): boolean; (second: T[]): boolean; <TCompare>(second: T[], compareSelector: (element: T) => TCompare): boolean; }
>TCompare : TCompare
>second : T[]
>T : T
>compareSelector : (element: T) => TCompare
>element : T
>T : T
>TCompare : TCompare
toDictionary<TKey>(keySelector: (element: T) => TKey): IDictionary<TKey, any>;
>toDictionary : { <TKey>(keySelector: (element: T) => TKey): IDictionary<TKey, any>; <TKey, TValue>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TValue): IDictionary<TKey, TValue>; <TKey, TValue, TCompare>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TValue, compareSelector: (key: TKey) => TCompare): IDictionary<TKey, TValue>; }
>TKey : TKey
>keySelector : (element: T) => TKey
>element : T
>T : T
>TKey : TKey
>IDictionary : IDictionary<TKey, TValue>
>TKey : TKey
toDictionary<TKey, TValue>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TValue): IDictionary<TKey, TValue>;
>toDictionary : { <TKey>(keySelector: (element: T) => TKey): IDictionary<TKey, any>; <TKey, TValue>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TValue): IDictionary<TKey, TValue>; <TKey, TValue, TCompare>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TValue, compareSelector: (key: TKey) => TCompare): IDictionary<TKey, TValue>; }
>TKey : TKey
>TValue : TValue
>keySelector : (element: T) => TKey
>element : T
>T : T
>TKey : TKey
>elementSelector : (element: T) => TValue
>element : T
>T : T
>TValue : TValue
>IDictionary : IDictionary<TKey, TValue>
>TKey : TKey
>TValue : TValue
toDictionary<TKey, TValue, TCompare>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TValue, compareSelector: (key: TKey) => TCompare): IDictionary<TKey, TValue>;
>toDictionary : { <TKey>(keySelector: (element: T) => TKey): IDictionary<TKey, any>; <TKey, TValue>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TValue): IDictionary<TKey, TValue>; <TKey, TValue, TCompare>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TValue, compareSelector: (key: TKey) => TCompare): IDictionary<TKey, TValue>; }
>TKey : TKey
>TValue : TValue
>TCompare : TCompare
>keySelector : (element: T) => TKey
>element : T
>T : T
>TKey : TKey
>elementSelector : (element: T) => TValue
>element : T
>T : T
>TValue : TValue
>compareSelector : (key: TKey) => TCompare
>key : TKey
>TKey : TKey
>TCompare : TCompare
>IDictionary : IDictionary<TKey, TValue>
>TKey : TKey
>TValue : TValue
}
interface IDictionary<TKey, TValue> {
>IDictionary : IDictionary<TKey, TValue>
>TKey : TKey
>TValue : TValue
toEnumerable(): IEnumerable<{ key: TKey; value: TValue }>;
>toEnumerable : () => IEnumerable<{ key: TKey; value: TValue; }>
>IEnumerable : IEnumerable<T>
>key : TKey
>TKey : TKey
>value : TValue
>TValue : TValue
}
|
