1 element function
2 tag function
3 ast
4 category
5 item
6 title Typed functions 1
7 expected
8 + function add(x: number, y: number): number {
9 + return x + y;
10 + }
11 + let myAdd = function (x: number, y: number): number { return x + y; };
12 ittf
13 +
14 function add
15 param x
16 :number
17 param y
18 :number
19 :return
20 :number
21 return x + y
22 let myAdd
23 function
24 param x
25 :number
26 param y
27 :number
28 :return
29 :number
30 return x + y
31 item
32 title Typed functions 2
33 expected
34 + let myAdd: (baseValue: number, increment: number) => number =
35 + function (x, y) { return x + y; };
36 ittf
37 let myAdd
38 :=>
39 :number
40 param x
41 :number
42 param y
43 :number
44 function
45 param x
46 :number
47 param y
48 :number
49 :return
50 :number
51 return x + y
52 item
53 title Optional parameters
54 expected
55 + function buildName(firstName: string, lastName?: string) {
56 + if (lastName)
57 + return firstName + " " + lastName;
58 + else
59 + return firstName;
60 + }
61 + let result1 = buildName("Bob"); // error, too few parameters
62 + let result2 = buildName("Bob", "Adams", "Sr."); // error, too many parameters
63 + let result3 = buildName("Bob", "Adams"); // ah, just right
64 ittf
65 +
66 function buildName
67 param firstName
68 :string
69 param lastName
70 :string
71 :optional
72 if lastName
73 return firstName + " " + lastName
74 else
75 return firstName
76 # error, too few parameters
77 let result1 = buildName("Bob")
78 # error, too many parameters
79 let result2 = buildName("Bob", "Adams", "Sr.")
80 # ah, just right
81 let result3 = buildName("Bob", "Adams")
82 item
83 title Rest parameters
84 expected
85 + function buildName(firstName: string, ...restOfName: string[]) {
86 + return firstName + " " + restOfName.join(" ");
87 + }
88 + let buildNameFun: (fname: string, ...rest: string[]) => string = buildName;
89 ittf
90 +
91 function buildName
92 param firstName
93 :string
94 param ...restOfName
95 :[
96 :string
97 return firstName + " " + restOfName.join(" ")
98 let buildNameFun
99 :=>
100 :string
101 param fname
102 :string
103 param ...rest
104 :[
105 :string
106 := buildName
107 item
108 title This and arrow functions
109 expected
110 + let deck = {
111 + suits: ["hearts", "spades", "clubs", "diamonds"],
112 + cards: Array(52),
113 + createCardPicker: function () {
114 + return () => {
115 + let pickedCard = Math.floor(Math.random() * 52);
116 + let pickedSuit = Math.floor(pickedCard / 13);
117 + return { suit: this.suits[pickedSuit], card: pickedCard % 13 };
118 + }
119 + }
120 + }
121 + let cardPicker = deck.createCardPicker();
122 + let pickedCard = cardPicker();
123 + alert("card: " + pickedCard.card + " of " + pickedCard.suit);
124 ittf
125 let deck
126 {
127 [ suits
128 @ "hearts"
129 @ "spades"
130 @ "clubs"
131 @ "diamonds"
132 @ cards Array(52)
133 @ createCardPicker
134 function
135 # NOTE: the line below is now an arrow function, allowing us to capture 'this' right here
136 return
137 =>
138 let pickedCard = Math.floor(Math.random() * 52)
139 let pickedSuit = Math.floor(pickedCard / 13)
140 return
141 {
142 @ suit this.suits[pickedSuit]
143 @ card pickedCard % 13
144 item
145 title This parameters in callbacks
146 expected
147 + interface UIElement {
148 + addClickListener(onclick: (this: void, e: Event) => void): void;
149 + }
150 + class Handler {
151 + info: string;
152 + onClickBad(this: Handler, e: Event) {
153 + // oops, used this here. using this callback would crash at runtime
154 + this.info = e.message;
155 + }
156 + }
157 ittf
158 +
159 :interface UIElement
160 :m addClickListener
161 :void
162 param onclick
163 :=>
164 :void
165 param this
166 :void
167 param e
168 :ref Event
169 class Handler
170 p info
171 :string
172 m onClickBad
173 param this
174 :ref Handler
175 param e
176 :ref Event
177 set this.info = e.message
178 item
179 title Overloads 1
180 expected
181 + let suits = ["hearts", "spades", "clubs", "diamonds"];
182 + function pickCard(x): any {
183 + // Check to see if we're working with an object/array
184 + // if so, they gave us the deck and we'll pick the card
185 + if (typeof x == "object") {
186 + let pickedCard = Math.floor(Math.random() * x.length);
187 + return pickedCard;
188 + }
189 + // Otherwise just let them pick the card
190 + else if (typeof x == "number") {
191 + let pickedSuit = Math.floor(x / 13);
192 + return { suit: suits[pickedSuit], card: x % 13 };
193 + }
194 + }
195 ittf
196 +
197 let suits
198 [
199 @ "hearts"
200 @ "spades"
201 @ "clubs"
202 @ "diamonds"
203 function pickCard
204 param x
205 :return
206 :any
207 if typeof x == "object"
208 let pickedCard = Math.floor(Math.random() * x.length)
209 return pickedCard
210 else
211 # Otherwise just let them pick the card
212 if typeof x == "number"
213 let pickedSuit = Math.floor(x / 13)
214 return
215 {
216 @ suit suits[pickedSuit]
217 @ card x % 13
218 item
219 title Overloads 2
220 expected
221 + let suits = ["hearts", "spades", "clubs", "diamonds"];
222 + function pickCard(x: { suit: string; card: number; }[]): number;
223 + function pickCard(x: number): { suit: string; card: number; };
224 + function pickCard(x): any {
225 + // Check to see if we're working with an object/array
226 + // if so, they gave us the deck and we'll pick the card
227 + if (typeof x == "object") {
228 + let pickedCard = Math.floor(Math.random() * x.length);
229 + return pickedCard;
230 + }
231 + // Otherwise just let them pick the card
232 + else if (typeof x == "number") {
233 + let pickedSuit = Math.floor(x / 13);
234 + return { suit: suits[pickedSuit], card: x % 13 };
235 + }
236 + }
237 ittf
238 +
239 let suits
240 [
241 @ "hearts"
242 @ "spades"
243 @ "clubs"
244 @ "diamonds"
245 :function pickCard
246 param x
247 :[
248 :{
249 :p suit
250 :string
251 :p card
252 :number
253 :return
254 :number
255 :function pickCard
256 param x
257 :number
258 :return
259 :{
260 :p suit
261 :string
262 :p card
263 :number
264 function pickCard
265 param x
266 :return
267 :any
268 # if so, they gave us the deck and we'll pick the card
269 if typeof x == "object"
270 let pickedCard = Math.floor(Math.random() * x.length)
271 return pickedCard
272 else
273 # Otherwise just let them pick the card
274 if typeof x == "number"
275 let pickedSuit = Math.floor(x / 13)
276 return
277 {
278 @ suit suits[pickedSuit]
279 @ card x % 13