TypeScript
Type guards
Add a type guard for each node.
Type guard for a node
Writing a type guard for each node type allows external code to safely narrow the node. A guard of the form isNumberNode(n: Node): n is NumberNode narrows n to NumberNode when it returns true.
type NumberNode = { kind: "number"; value: number };
function isNumberNode(n: Node): n is NumberNode {
return n.kind === "number";
}
Multiple guards
Writing guards for multiple node types makes complex branching clean. The isNumberNode(n), isStringNode(n), isAddNode(n) guards can also narrow with if chains instead of switch.
function isStringNode(n: Node): n is StringNode {
return n.kind === "string";
}
function isAddNode(n: Node): n is AddNode {
return n.kind === "add";
}
function process(n: Node): string {
if (isNumberNode(n)) return "num:" + n.value;
if (isStringNode(n)) return "str:" + n.value;
return "add";
}
Exercise Write node type guards
Define the Node discriminated union type ("number" (value: number), "string" (value: string), "add" (left: Node, right: Node)). Define NumberNode and StringNode types. Write isNumberNode(n: Node): n is NumberNode and isStringNode(n: Node): n is StringNode guard functions (each checking with n.kind === "..."). Write a describe(n: Node): string function: if isNumberNode(n) is true, return "num:" + n.value; else if isStringNode(n) is true, return "str:" + n.value; else return "add". Print the result via console.log(describe({ kind: "string", value: "x" })).
Show example solution
type Node =
| { kind: "number"; value: number }
| { kind: "string"; value: string }
| { kind: "add"; left: Node; right: Node };
type NumberNode = { kind: "number"; value: number };
type StringNode = { kind: "string"; value: string };
function isNumberNode(n: Node): n is NumberNode {
return n.kind === "number";
}
function isStringNode(n: Node): n is StringNode {
return n.kind === "string";
}
function describe(n: Node): string {
if (isNumberNode(n)) return "num:" + n.value;
if (isStringNode(n)) return "str:" + n.value;
return "add";
}
console.log(describe({ kind: "string", value: "x" }));
Test yourself
-
What is the benefit of writing a type guard for an AST node?
- It makes the code longer
- It increases runtime speed
- It reduces the number of nodes
- It allows external code to safely narrow the node
Show answer
It allows external code to safely narrow the node — A type guard allows external code to narrow a node to the correct type in an if condition; clean branching can also be done with an if chain instead of switch.
-
isNumberNode predicate
function isNumberNode(n: Node): ____ {
return n.kind === "number";
}
Show answer
function isNumberNode(n: Node): n is NumberNode {
return n.kind === "number";
}
-
Type guards parts
- isNumberNode(n)
- narrows n to NumberNode
- n is NumberNode
- predicate return type
- n.kind === "number"
- runtime check
- if (isNumberNode(n))
- narrowing with if chain
Next lesson: Exhaustive eval
