I like to call the as T operator the make-this-expression-of-type-T-trust-me-i-know-what-type-this-is-and-i-know-what-i-am-doing-but-can-you-please-check-if-both-types-sufficiently-overlap-anyway-just-in-case operator.

I never liked the word "cast" for it because it implies something else in other programming languages.

Hmm, maybe x as T is an assertion expression, while calling a function returning asserts x is T is an assertion statement:

function as<T>(x: any): asserts x is T { }

// proper use
let exprAssertGood = Math.random() < 3 ? "hello" : 123;
(exprAssertGood as string).toUpperCase();

// proper use
let stmtAssertGood = Math.random() < 3 ? "hello" : 123;
as<string>(stmtAssertGood);
stmtAssertGood.toUpperCase(); // okay

// improper use
let exprAssertBad = Math.random() < 3 ? "hello" : 123;
exprAssertBad as string;
exprAssertBad.toUpperCase(); // error, prior assertion only existed in the immediate expression

// improper use
let stmtAssertBad = Math.random() < 3 ? "hello" : 123;
as<string>(stmtAssertBad).toUpperCase(); // error, assertion is a void expression

Playground link

Disclaimer: my opinion

"assertion" in these cases means that you're telling the compiler what a type is, and the compiler will trust you know what you're doing e.g.

• x as T is a type assertion because it's a demand on the compiler and could be wrong (vs x: T)

• asserts x is T is an assertion signature (in that it's always at the end of an existing function) which could be referred to as a function with an signature. The compiler doesn't validate it either.

I like both @orta and @jcalz's ideas! The book revision is ready to go, pending this decision.

One other thing that may be worth indicating in the name is that asserts is a bit unique, in that it's a lot like a side effect, but at the type level. "Assertion effect" or "Refinement effect" might be a bit too nerdy, but maybe there's a more obvious name that makes this clear.