Aggregate function assertions

Suggestion

🔍 Search Terms

Multi-assertions, function assertion signatures, type assertions, aggregate assertions

✅ Viability Checklist

My suggestion meets these guidelines:

• This wouldn't be a breaking change in existing TypeScript/JavaScript code
• This wouldn't change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, new syntax sugar for JS, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.

⭐ Suggestion

Allow functions that assert a type or condition to assert multiple types or conditions

(Maybe?) Allow functions with "asserts" signatures to return a type other than void.
(Update: the secondary goal is covered by other issues)

💻 Use Cases

It allows multiple type assertions at once.

// declare AssertionError

function assert(x: unknown, y: unknown): (asserts x is number) & (asserts y is number) {
    if (typeof x !== "number" || typeof y !== "number") {
        throw new AssertionError("Assert failed: 'x' and 'y' are not both numbers");
    }
}

or

function safeAdd(x: unknown, y: unknown): (number) & (asserts x is number) & (asserts y is number) {
    if (typeof x !== "number" || typeof y !== "number") {
        throw new AssertionError("`x` and `y` are not both numbers");
    } else {
        return x + y;
    }
}

or

declare function safeAdd(...args: unknown[]): asserts args is [number, number];

No idea what the syntax would be, but this should give the idea.

📃 Motivating Example

My use for this was that I had a function that accepted two parameters. It only operated if the first parameter was of a type (T), it also had an overload for the second parameter being the same type (T) or anything else.

declare function assertIsT (x: unknown): asserts x is T;
declare function isT (x: unknown): x is T;
function f (x: unknown, y: unknown): asserts x is T;
function f (x: T, y: T | H) {
    assertIsT(x);
    // x: T

    if ( isT(y) ) {
        // ... y: T
    } else {
        // ... y: H
    }
}

This was meant to be "JavaScript-compatible" code, as in, it could be used by a non-TS user with relative type safety, but, the assertion seems like extra work, as if I'm being over-cautious, so I wanted to simplify it:

declare function isT (x: unknown, y: unknown): (asserts x is T) & (y is T);
function f (x: unknown, y: unknown): asserts x is T;
function f (x: T, y: T | H) {
    if ( isT(x, y) ) {
        // ... x: T
        // ... y: T
    } else {
        // ... x: T
        // ... y: H
    }
}

Now, it's terse and straightforward, while retaining type-safety.
(I am not advocating any specific syntax for the aggregation/mixing)

I tried to get this to work with function overloads, but it wasn't happening.
Playground link

---

Related issues?
https://github.com/microsoft/TypeScript/issues/40562
https://github.com/microsoft/TypeScript/issues/34636

Start with the assertion-signature examples and the linked Playground reproduction, then read related issues 40562 and 34636. Determine the intended syntax and type-checking behavior for combining assertions, including the proposed tuple assertion; done means the language design and compatibility implications are resolved.