Type narrowing with foo.constructor

[calebegg]

TypeScript Version: 2.3.1

Code

class FooTask {
  foo: number;
}

class BarTask {
  bar: number;
}

type taskType = FooTask|BarTask;

function createEvent(task: taskType) {
  if (task instanceof FooTask) {
    task.foo; // Works.
  }

  switch (task.constructor) {
    case FooTask:
      task.foo; // Fails.
  }
}

It would be nice if the second worked like the first; narrowed the type of task appropriately.

[glebm]

At first I though this was because T.constructor is not of type T (#3841), but looks like that's not the only issue:

class A {
    'constructor': typeof A;
    a() { }
}
class B {
    'constructor': typeof B;
    b() { }
}

function f(x: A | B) {
    switch (x.constructor) {
        case A:
            x.a();  // Fails: not narrowed
        case B:
            x.b();  // Fails: not narrowed
    }
}

[glebm]

@RyanCavanaugh What kind of feedback is this awaiting?

[mhegazy]

What kind of feedback is this awaiting?

We would like to get hear more user requests in favor of supporting this features

[ExE-Boss]

You need to add break statements:

 function f(x: A | B) {
 	switch (x.constructor) {
 		case A:
 			x.a();
+			break;
  		case B:
 			x.b();
+			break;
 	}
 }

Also, another issue is that TypeScript doesn’t do narrowing using === on objects.

[karol-majewski]

I needed it a few times now. A use case from today: applying a strategy based on a runtime type.

let whitelist: string[] | RegExp | ((location: Location) => boolean);

let path = '/'
whitelist = [path];

((): boolean => {
  switch (whitelist.constructor) {
    case Array:
      return whitelist.includes(path);
    case RegExp:
      return path.match(whitelist) !== null;
    case Function:
      return whitelist(location);
  }
})()

TypeScript Playground

Such code is both concise and very readable. Wouldn't it be nice if elegance was complemented with type safety? 😢

[murbanowicz]

Is there any chance it will be fixed?

[ukstv]

Oh, I can add +1 to this feature request. Definitely needed in reactive programming.