It looks like you're using the same example as the official documentation on Discriminated Unions , so I assume you've seen that section. Out of curiosity then, what makes you say this? However newer docs don't seem to ever show discriminated unions If you're looking to have discriminated unions like Rust, follow that section to roll your own or look for a library that's already implemented them. fp-ts has everything under the sun in a Haskell style, neverthrow has Rust-like Result and ResultAsync, and sum-types helps with the boilerplate of defining your own sum types. I wouldn't recommend instanceof checks, TypeScript just isn't designed to work well with nominal typing so it's not the best experience. More on reddit.com

instanceof is usually code smell. As in, there is probably a better way to achieve the same thing.

For numbers and strings, typeof is a good option. For functions, duck typing is often a better choice than instanceof. So your code might look like this:

if (typeof obj.dispose === 'function')
    obj.dispose() 

constructor is unreliable and can be overridden easily. You should never rely on it to be a particular value.

More on reddit.com

JS gives you 2 keywords to verify the type of the value referred to by a reference. First of all, you have the typeof keyword. This keyword, used in the form of typeof will return a string that takes values from the following list: number string undefined object undefined symbol bigint boolean As we can see, typeof returns a primitive type. An interesting corner case is typeof null === 'object' surprisingly. Every class instance will also return 'object' on a typeof call. If you want to test for a specific class type, you have to use the instanceof keyword. The syntax is instanceof . What the aforementioned expression will return is a boolean value - true/false, if the class is part of the prototype chain. const m = new Map(); console.log(m instanceof Map) // true console.log(m instanceof Set) // false class MyMap extends Map { } const mm = new MyMap(); console.log(mm instanceof Map) // true console.log(mm instanceof MyMap) // true console.log(mm instanceof Set) // false More on reddit.com

To add to what others have said already, there's a neat trick you can do in typescript to check if your instance is of a given "type". You declare it as an abstract class and implement the Symbol.hasInstance method. Example: abstract class Person { abstract readonly name: string; abstract readonly age: number; public static [Symbol.hasInstance](instance: unknown): instance is Person { if (instance === null || (typeof instance !== 'object' && !(instance instanceof Person))) return false; const name: unknown = (instance as any).name; const age: unknown = (instance as any).age; if (typeof name !== 'string' && !(name instanceof String)) return false; return typeof age === 'number' || age instanceof Number; } } Then you can use it as: const person = { name: "SomeName", age: 55 }; const noPerson = { weight: "300kg" }; console.log(person instanceof Person); // will print true console.log(noPerson instanceof Person); // will print false The advantage of this method in my opinion is that because typescript has a structure typing system, you can just do: class PersonImpl implements Person { constructor( readonly name: string, readonly age: number ) { } } console.log(new PersonImpl("SomeName", 55) instanceof Person); // will also print true This way, if you make a typo on PersonImpl you will know immediately that it's wrong and at runtime you can still type check. More on reddit.com