Allow narrowing of unions discriminated by numeric literals using `>` `<` etc

[fabiospampinato]

🔎 Search Terms

"arguments length"

🕗 Version & Regression Information

It works the same in v3.3.3

⏯ Playground Link

https://www.typescriptlang.org/play/?target=99&module=0&ts=5.8.3#code/GYVwdgxgLglg9mABAUwB4EMC2AHANsgRgAoA6M9AJwHMBnALkQG0wRMAjZCgXUQB8muASkQBvAFCJJiGMERFKtEvjBUoAC0QA+RAAZh4qYcQVkUEBSQKajHVwDcEqQF8UuGslGOjx0+aQA5dH8HQycxMNBIWAQUDBx8ACZScmp6JhZ2Th5+RiFPQxk5KyVkFXV9LyMTMwtEKxt7SpdkNw8Dbx8agKCQ53CxSOh4JDQsPGQAZmSSKwZmVg5uPgEKgtl5VJKyjQBePd1Vjuq-REDgptd3fKPfWvrbXskwpyA

💻 Code

Some basic ways to check if we have any arguments could be these:

function example1(...args: [number] | []) {
    if (args.length > 0) {
        return args[0];
    } else {
        return NaN;
    }
}
function example2(...args: [number] | []) {
    if (args.length) {
        return args[0];
    } else {
        return NaN;
    }
}
function example3(...args: [number] | []) {
    if (args.length === 0) {
        return NaN;
    } else {
        return args[0];
    }
}

But TS doesn't seem to understand the first one.

🙁 Actual behavior

It doesn't understand the way it's done in "example1".

🙂 Expected behavior

It should understand the way it's done in "example1".

Additional information about the issue

Type inference on "args" after the check for "example1":

Type inference on "args" after the check for "example2":

Type inference on "args" after the check for "example3":

Notice how for "example2" and "example3" the type is correctly narrowed to just [number], but for "example1" the unnarowed [number] | [] type remains.

[MartinJohns]

This is working as intended / a design limitation.

You can't use the larger-than operator to narrow literal types. Your request would require additional logic to allow a check > 0 to narrow literal union types like 0 | 1 which very likely is just not worth the additional effort.

[fabiospampinato]

Personally I think TS should strive for giving out the same "output" for every possible cheaply-statically-analyzable way of doing the same thing.

But I understand resources are not infinite.

Still IMO it's worth keeping this issue open just to recognize it as an issue, even if it won't be addressed anytime soon if ever.

[MartinJohns]

for every possible cheaply-statically-analyzable way

I have my doubts that 0 | 1 > 0 is cheaply-statically-analyzable, especially considering that TypeScript currently has no mechanism to tell that one type is larger than another.

[jcalz]

#26382 seems to be a prerequisite for this?

[snarbles2]

As a half measure, < and > could be treated as != for the purposes of narrowing.

edit: or if that's a bad idea, I'm more than happy to hear why

[RyanCavanaugh]

This is implementable using available primitives, just not something that's come up yet.