Allow inline type predicates

From #5731

if (<foo is Element>(foo.nodeType === 1)) { 
    // Assume foo is Element here
}

A proposal from @sandersn: https://github.com/Microsoft/TypeScript/issues/5731#issuecomment-162586789

Type Predicate Expressions

A type predicate expression allows you to narrow a union type with a single expression. The syntax is

<variable is type> boolean-expression

When the expression is used in a conditional context, the true branch of the conditional narrows variable to type, while the false branch narrows variable by removing type.

The type predicate expression is of type Boolean, with apparent type of type predicate. The right hand side must be an expression of type Boolean. The left hand side’s variable must be a name bound in the current scope. The left hand side’s type must be a name bound in the current scope.

Open questions

1. How does variable capture work? Can a type predicate expression be returned from a function and used to narrow a variable that’s no longer in scope? This could be defined to cause an error, but that restriction is neither obvious nor easy to use.
2. Why reuse the type assertion syntax? The type of the right expression is checked to be Boolean, unlike assertions, and the resulting type is still Boolean, also unlike assertions.

[pushkine]

Here’s a workaround that gets removed by bundlers

const Narrow = <T>(v): v is T => true;

if (foo.nodeType === 1 && Narrow<Element>(foo)) {
}

(edit 2022) Here’s another workaround that works as a statement (= works in switch blocks)

function Narrow<T extends R, R = unknown>(value: R): asserts value is T {}

switch (foo.nodeType) {
	case 1: {
		foo; // any
		Narrow<Element>(foo);
		foo; // Element
	}
}

Playground Link

[ethanresnick]

You could also imagine doing this as the annotation for a variable holding the predicate’s result, i.e.:

declare const foo: Node;
const isElement: foo is Element = foo.nodeType === 1;

if (isElement) {
    // Assume foo is Element here
}