Type limit operator for variable

[andjsrk]

Suggestion

🔍 Search Terms

type limit operator

✅ 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

This feature limits type for variable.

• Limited type should be assignable to original type.
• The limitation is in effect within current scope.

📃 Motivating Example

When I was writing overloaded function, I thought I'm writing unnecessary code(like type guard) on runtime because I assumed the user always provide valid arguments.

So, why don't you use as keyword?

There are two ways to use as keyword.
First, you can redeclare variable with as keyword.
Second, you can put as keyword on EVERYWHERE the variable used.
I think the first way makes unnecessary variable.
And the second way is terrible as you know.

💻 Use Cases

class A {}
class B extends A {
    foo() {}
}
const foo: A = new B();
if ('foo' in foo) {
    foo := B;
    console.log(foo.foo()); // no errors
}

function overloaded(type: 'array', array: Array<any>): undefined;
function overloaded(type: 'string', string: string): undefined;
function overloaded(type: 'array' | 'string', value: Array<any> | string) {
    if (type === 'array') {
        value := Array<any>;
        console.log(value.every(element => element !== undefined)); // no errors
    } else {
        value := string;
        console.log(value.substring(0, 5)); // no errors
    }
}

[jcalz]

Duplicate of #10421