1 element generics
2 tag
3 ast
4 category
5 item
6 title Identity function with any
7 expected
8 + function identity(arg: any): any {
9 + return arg;
10 + }
11 ittf
12 function identity
13 param arg
14 :any
15 :return
16 :any
17 return arg
18 item
19 title Identity function with type variable
20 expected
21 + function identity<T>(arg: T): T {
22 + return arg;
23 + }
24 ittf
25 function identity
26 :< T
27 param arg
28 :ref T
29 :return
30 :ref T
31 return arg
32 item
33 title Type argument
34 expected
35 + let output = identity<string>("myString"); // type of output will be 'string'
36 ittf
37 let output
38 _ identity
39 :< string
40 @ "myString"
41 item
42 title Length property fails
43 expected
44 + function loggingIdentity<T>(arg: T): T {
45 + console.log(arg.length);
46 + return arg;
47 + }
48 ittf
49 function loggingIdentity
50 :< T
51 param arg
52 :ref T
53 :return
54 :ref T
55 _ console.log(arg.length)
56 return arg
57 item
58 title Length property succeds 1
59 expected
60 + function loggingIdentity<T>(arg: T[]): T[] {
61 + console.log(arg.length);
62 + return arg;
63 + }
64 ittf
65 +
66 function loggingIdentity
67 :< T
68 param arg
69 :[
70 :ref T
71 :return
72 :[
73 :ref T
74 _ console.log(arg.length)
75 return arg
76 item
77 title Length property succeds 2
78 expected
79 + function loggingIdentity<T>(arg: Array<T>): Array<T> {
80 + console.log(arg.length);
81 + return arg;
82 + }
83 ittf
84 function loggingIdentity
85 :< T
86 param arg
87 :ref Array
88 :ref T
89 :return
90 :ref Array
91 :ref T
92 _ console.log(arg.length)
93 return arg
94 item
95 title Generic function
96 expected
97 + function identity<T>(arg: T): T {
98 + return arg;
99 + }
100 + let myIdentity: <T>(arg: T) => T = identity;
101 ittf
102 +
103 function identity
104 :< T
105 param arg
106 :ref T
107 :return
108 :ref T
109 return arg
110 let myIdentity
111 :=>
112 :ref T
113 param arg
114 :ref T
115 := identity
116 item
117 title Call signature object literal type
118 expected
119 + function identity<T>(arg: T): T {
120 + return arg;
121 + }
122 + let myIdentity: { <T>(arg: T): T } = identity;
123 ittf
124 +
125 function identity
126 :< T
127 param arg
128 :ref T
129 :return
130 :ref T
131 return arg
132 let myIdentity
133 :{
134 :call
135 :< T
136 :ref T
137 param arg
138 :ref T
139 := identity
140 item
141 title Generic interface
142 expected
143 + interface GenericIdentityFn<T> {
144 + (arg: T): T;
145 + }
146 + function identity<T>(arg: T): T {
147 + return arg;
148 + }
149 + let myIdentity: GenericIdentityFn<number> = identity;
150 ittf
151 +
152 :interface GenericIdentityFn
153 :< T
154 :call
155 :ref T
156 param arg
157 :ref T
158 function identity
159 :< T
160 param arg
161 :ref T
162 :return
163 :ref T
164 return arg
165 let myIdentity
166 :ref GenericIdentityFn
167 :param number
168 := identity
169 item
170 title Generic Classes
171 expected
172 + class GenericNumber<T> {
173 + zeroValue: T;
174 + add: (x: T, y: T) => T;
175 + }
176 ittf
177 class GenericNumber
178 :< T
179 p zeroValue
180 :ref T
181 p add
182 :=>
183 :ref T
184 param x
185 :ref T
186 param y
187 :ref T
188 item
189 title Generic Constraints - fails
190 expected
191 + function loggingIdentity<T>(arg: T): T {
192 + console.log(arg.length); // Error: T doesn't have .length
193 + return arg;
194 + }
195 ittf
196 function loggingIdentity
197 :< T
198 param arg
199 :ref T
200 :return
201 :ref T
202 _ console.log(arg.length)
203 return arg
204 item
205 title Generic Constraints - succeds
206 expected
207 + interface Lengthwise {
208 + length: number;
209 + }
210 + function loggingIdentity<T extends Lengthwise>(arg: T): T {
211 + console.log(arg.length); // Now we know it has a .length property, so no more error
212 + return arg;
213 + }
214 ittf
215 +
216 :interface Lengthwise
217 :p length
218 :number
219 function loggingIdentity
220 :< T
221 :ref Lengthwise
222 param arg
223 :ref T
224 :return
225 :ref T
226 _ console.log(arg.length)
227 return arg
228 item
229 title Type Parameters in Generic Constraints
230 expected
231 + function getProperty<T, K extends keyof T>(obj: T, key: K) {
232 + return obj[key];
233 + }
234 + let x = { a: 1, b: 2, c: 3, d: 4 };
235 + getProperty(x, "a");
236 + getProperty(x, "m");
237 ittf
238 +
239 function getProperty
240 :< T
241 :< K
242 :keyof
243 :ref T
244 param obj
245 :ref T
246 param key
247 :ref K
248 return obj[key]
249 let x
250 {
251 @ a 1
252 @ b 2
253 @ c 3
254 @ d 4
255 _ getProperty(x, "a")
256 _ getProperty(x, "m")
257 item
258 title Class Types in Generics
259 expected
260 + function create<T>(c: { new (): T; }): T {
261 + return new c();
262 + }
263 ittf
264 function create
265 :< T
266 param c
267 :{
268 :new
269 :ref T
270 :return
271 :ref T
272 return new c()
273 item
274 title Prototype property
275 expected
276 + class BeeKeeper {
277 + hasMask: boolean;
278 + }
279 + class ZooKeeper {
280 + nametag: string;
281 + }
282 + class Animal {
283 + numLegs: number;
284 + }
285 + class Bee extends Animal {
286 + keeper: BeeKeeper;
287 + }
288 + class Lion extends Animal {
289 + keeper: ZooKeeper;
290 + }
291 + function createInstance<A extends Animal>(c: new () => A): A {
292 + return new c();
293 + }
294 + var x = createInstance(Lion).keeper.nametag;
295 + var y = createInstance(Bee).keeper.hasMask;
296 ittf
297 +
298 class BeeKeeper
299 p hasMask
300 :boolean
301 class ZooKeeper
302 p nametag
303 :string
304 class Animal
305 p numLegs
306 :number
307 class Bee
308 super Animal
309 p keeper
310 :ref BeeKeeper
311 class Lion
312 super Animal
313 p keeper
314 :ref ZooKeeper
315 function createInstance
316 :< A
317 :ref Animal
318 param c
319 :ctor
320 :ref A
321 :return
322 :ref A
323 return new c()
324 var x = createInstance(Lion).keeper.nametag
325 var y = createInstance(Bee).keeper.hasMask