Feature Request: Improve type narrowing for class instances inside switch-case expressions

[ScarletFlash]

Suggestion

🔍 Search Terms

constructor, instanceof, switch

✅ 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

Add type narrowing based on object constructor in switch case expressions.

📃 Motivating Example

Let's imagine we have 2 dedicated parts of our codebase:

1. Objects creation
2. Created objects handling

It may be useful to use switch case expression for handling incoming objects instead of using multiple type guards:

Using switch case

abstract class Animal {}

class Pig extends Animal {
    public oink(): void {}
}
class Dog extends Animal {
    public bark(): void {}

}
class Cow extends Animal  {
    public moo(): void {}

}

const animal: Animal = new Pig();

switch (animal.constructor) {
  case Pig: {
    animal.oink()
    break;
  }
  case Dog: {
    animal.bark()
    break;
  }
  case Cow: {
    animal.moo()
    break;
  }
  default: {
    break;
  }
}

Using type guards

abstract class Animal {}

class Pig extends Animal {
    public oink(): void {}
}
class Dog extends Animal {
    public bark(): void {}

}
class Cow extends Animal  {
    public moo(): void {}

}

const animal: Animal = new Pig();

if (animal instanceof Pig) {
    animal.oink()
}

if (animal instanceof Dog) {
    animal.bark()
}

if (animal instanceof Cow) {
    animal.moo()
}

💻 Use Cases

This feature is required in event-driven architectures. Here goes a sample:

Sample

class UserInteractionHandler implements Creatable, Destroyable {
    private readonly onEventCallback: OnEventCallback = (busEvent: BusEvent) => {

        switch (busEvent.constructor) {
            case MouseClickBusEvent: {
                const { payload }: MouseClickBusEvent = busEvent;
                /** ... */
                break;
            }
            case MouseMoveBusEvent: {
                const { payload }: MouseMoveBusEvent = busEvent;
                /** ... */
                break;
            }
            case KeyDownBusEvent: {
                const { payload }: KeyDownBusEvent = busEvent;
                /** ... */
                break;
            }
            case KeyUpBusEvent: {
                const { payload }: KeyUpBusEvent = busEvent;
                /** ... */
                break;
            }
            default: {
                break;
            }
        }

    }

    constructor(private readonly eventBus){}

    public onCreate(): void {
        this.eventBus.listen(this.onEventCallback);
    }

    public onDestroy(): void {
        this.eventBus.unlisten(this.onEventCallback);
    }

}

class MouseEventsPublisher implements Creatable, Destroyable {
    private readonly clickListener: EventListener = (event: MouseEvent) => {
        this.eventBus.dispatch(new MouseClickBusEvent(event));
    }
    private readonly mouseMoveListener: EventListener = (event: MouseEvent) => {
        this.eventBus.dispatch(new MouseMoveBusEvent(event));
    }

    constructor(private readonly eventBus){}


    public onCreate(): void {
        window.addEventListener('click', this.clickListener);
        window.addEventListener('mousemove', this.mouseMoveListener);
    }

    public onDestroy(): void {
        window.removeEventListener('click', this.clickListener);
        window.removeEventListener('mousemove', this.mouseMoveListener);
    }
    
}

class KeyboardEventsPublisher implements Creatable, Destroyable {
    private readonly keyDownListener: EventListener = (event: KeyboardEvent) => {
        this.eventBus.dispatch(new KeyDownBusEvent(event));
    }
    private readonly keyUpListener: EventListener = (event: KeyboardEvent) => {
        this.eventBus.dispatch(new KeyUpBusEvent(event));
    }

    constructor(private readonly eventBus){}


    public onCreate(): void {
        window.addEventListener('keydown', this.keyDownListener);
        window.addEventListener('keyup', this.keyUpListener);
    }

    public onDestroy(): void {
        window.removeEventListener('keydown', this.keyDownListener);
        window.removeEventListener('keyup', this.keyUpListener);
    }
    
}

[MartinJohns]

Duplicate of #16035.

[typescript-bot]

This issue has been marked as a 'Duplicate' and has seen no recent activity. It has been automatically closed for house-keeping purposes.