Errata

The code fragment after

"Let’s start by pulling out filter’s full type signature, and adding some placeholder unknowns for the types:"

type Filter = {
(array: unknown, f: unknown) => unknown[]
}

does not compile with error TS1005: ':' expected.

The code should be:

type Filter = {
(array: unknown, f: unknown): unknown[]
}

The note on overloading a function declaration has this listing with createElement function:

function createElement(tag: 'a'): HTMLAnchorElement
function createElement(tag: 'canvas'): HTMLCanvasElement
function createElement(tag: 'table'): HTMLTableElement
function createElement(tag: string): HTMLElement {
// ...
}

It is not the same as previous createElement. It is missing an overload for string. It is not possible to call the second createElement with a string other than 'a', 'canvas', and 'table'. For example createElement('foo') results in

error TS2769: No overload matches this call.
Overload 1 of 3, '(tag: "a"): HTMLAnchorElement', gave the following error.
Argument of type '"foo"' is not assignable to parameter of type '"a"'.
Overload 2 of 3, '(tag: "canvas"): HTMLCanvasElement', gave the following error.
Argument of type '"foo"' is not assignable to parameter of type '"canvas"'.
Overload 3 of 3, '(tag: "table"): HTMLTableElement', gave the following error.
Argument of type '"foo"' is not assignable to parameter of type '"table"'.

Corrected listing:

function createElement(tag: 'a'): HTMLAnchorElement
function createElement(tag: 'canvas'): HTMLCanvasElement
function createElement(tag: 'table'): HTMLTableElement
function createElement(tag: string): HTMLElement // this line was missing
function createElement(tag: string): HTMLElement {
// ...
}

The createElement example

type CreateElement = {
(tag: 'a'): HTMLAnchorElement
(tag: 'canvas'): HTMLCanvasElement
(tag: 'table'): HTMLTableElement
(tag: string): HTMLElement
}

let createElement: CreateElement = (tag: string): HTMLElement => {
// ...
}

results in error

TS2322: Type '(tag: string) => HTMLElement' is not assignable to type 'CreateElement'.
Type 'HTMLElement' is missing the following properties from type 'HTMLAnchorElement': charset, coords, download, hreflang, and 21 more.

" notice that everything but c and h is implicitly typed", implicitly should be explicitly.

When discussing overload function types, I noticed the following example provides a comment that should be switched:

type Reservation = string

type Reserve = {
(from: Date, to: Date, destination: string): Reservation
(from: Date, destination: string): Reservation
}

let reserve: Reserve = (
from: Date,
toOrDestination: Date | string,
destination?: string
) => {
if (toOrDestination instanceof Date && destination !== undefined) {
return "Book a one-way trip"
} else if (typeof toOrDestination === 'string') {
return "Book a round trip"
}

return "You are not going anywhere"
}

console.log(reserve(new Date(), new Date(), 'Bali'))
console.log(reserve(new Date(), 'Bali'))

In this example, we are saying that sending three arguments means the caller wants to book a one way trip. However, when calling the reserve function, when you send three arguments, that means they want to book a round trip.

To resolve this minor mistake, simply switch the following comments in the book:

// Book a one-way trip
// Book a round trip

Should be in this order:

// Book a round trip
// Book a one-way trip

In the function implementation of `Reserve`, you've implied that if the `toOrDestination` parameter is an instance of Date and undefined, that it refers to the one-way trip overload case, when I believe this refers to a round-trip case. Very minor issue, but can cause confusion when trying to connect this example to the function overload described previously.

Function overload:
type Reserve = {
(from: Date, to: Date, destination: string): Reservation;
(from: Date, destination: string): Reservation;
}

Implementation (comments below should be swapped):
let reserve: Reserve = (
from: Date,
toOrDestination: Date | string,
destination?: string
) => {
if (toOrDestination instanceof Date && destination !== undefined) {
// Book a one-way trip
} else if (typeof toOrDestination === 'string') {
// Book a round trip
}
....
}

In the following code snippet exemplifying how you can explicitly bind a generic type to MyEvent<T>,

let buttonEvent: MyEvent<HTMLButtonElement> = {
target: myButton,
type: string
}

and in the fourth code snippet featured in the same section:

let myEvent: MyEvent = {
target: myElement,
type: string
}

Given that both of the snippets feature assignment statements with object literal expressions on the right-hand side, shouldn't the "type" property have either a string literal or a variable holding a string value as its value?

The the argument to `fetch` in the `get` example (search for `await fetch`) is missing backticks around it's string argument. The line is:

let res = await fetch(/api/${entry})

and should be

let res = await fetch(`/api/${entry}`)

PS This form requires a page number, but I see no way to determine a page number in Safari Online.