Hacker News Reader

Comment by benatkin | Hacker News Reader

Does Number.isInteger() still not serve as a Type Guard?

https://github.com/microsoft/TypeScript/issues/21199#issueco...

In TypeScript, type guards are considered to be exhaustive, so if you have a string | number and check it against a function that says it returns "x is number", then TypeScript will think that in the negative case, it's a string.

If isInteger was marked as a type guard, then you could write code like this:

  function f(s: string | number) {
    if (!Number.isInteger(s)) {
      console.log(s.substring(0, 0));
    }
  }

which is clearly wrong.

There's an open feature request for a new kind of "one-sided" type guards that don't cause narrowing when they return false.

That seems like an important feature request. I see TypeScript adding fancy stuff without fixing core limitations.

You can get around it pretty easily:

    const intSymbol = Symbol('integer')
    type integer = number & {[intSymbol]: never}

    const isInteger = (n: unknown): n is integer => Number.isInteger(n)

    function f(s: string | number) {
        if (isInteger(s)) {
            const allowed = s.toExponential()
        } else {
            // s still string | number
        } 
    }

With this you even get to define functions that must accept integers, which is kinda neat.

That doesn't seem to address my concern. It seems like more of a curiosity. Whatever floats your boat.

How does it not address your concern? It’s quite literally making isInteger into a type guard. The ‘integer’ type above can passed to any place ‘number’ is needed.

  if (typeof s === 'number' && Number.isInteger(s)) {

What do you expect me to do with this snippet provided with no context?

That's what I was wondering when I saw yours.

What I was showing here is that this solution is simpler than yours and just as good. Rather than add a utility function and a faux primitive type, I just do the normal workaround for TypeScript not supporting this, which is to redundantly check that something is both a number and an integer.

The point of having a utility function is that you don't have to do the redundant checks every time you want to make sure it's both a number and an integer.

The critical bit is that you need to define a new type for `integer`s distinct from `number`s to allow reusing the code in a way that doesn't break the type system on the negative path, as Ryan and I demonstrated.

It isn't redundant in terms of the amount of code written, to me. The overhead of having the utility function and type is greater IMO.

If it's in terms of performance, that seems like moving the goalposts. I also wonder if it could be optimized away.

Next time I run into it I might use this:

  if (Number.isInteger(s)) {
    const allowed = (s as number).toExponential()

...and keep the isInteger check close enough that it's readable.

...or this:

  if (Number.isInteger(s)) {
    const n = s as number // should be optimized away by the compiler I think

You asked for isInteger to work as a type guard and I showed you how. If you prefer explicit casts everywhere that's fine, but it isn't a type guard. You could even use the type anonymously if you really want: (n is number & {Symbol(): never}).

Whatever floats your boat, as you say.

Oh boy, I never ever asked for a replacement for Number.isInteger! I prefer to use native functions.

Have a nice day.

Then alter the type of the ambient native function itself:

    interface NumberConstructor {
      isInteger(n: unknown): n is number & { Symbol(): never }
    }

How is it wrong ?

If s is a non-integer number

I mean, that could be changed.

Currently: either string OR number

Possible: either string | number OR just number

"string | number | number" is just "string | number" to Typescript.

The OR doesn't indicate | in TypeScript, it indicates the result of the possible future type guard.

> The OR doesn't indicate | in TypeScript, it indicates the result of the possible future type guard.

Are you implying in your other comment (that HN won't let me reply to) that Typescript has an "OR" operator that is distinct from "|"? Can you link to documentation on that?

"OR" was just my (bad) way to explain it. In plain English:

if isInteger(x) is true, x is definitely a `number`

if isInteger(x) is false, x is unknown/unaltered (it remains `typeof x`)

Current type guards can't express "yes versus maybe", so isInteger cannot be a type guard at all.

Reply on news.ycombinator.com