Add support for pattern matching class instances

Let’s suppose we have the following types:

class UserId {
    constructor(public val: string, private _?: string) {}
}

class SellerId {
    constructor(public val: string, private _?: string) {}
}

type Ids = UserId | SellerId

I’ve found that for nominal typing, a class with a private property is IMO the best and simplest way to achieve it. It is quite an advantage having both constructor and type on the same place. No unique symbol branding and no type casting on the constructor functions.

Also, as long as no inheritance shenanigans happen it allows to do strict pattern matching out of the box:

const assertNever = (val: never): never => {
    throw new Error('Should never happen')
}

const processId = (id: Ids): string => {

    if (id instanceof UserId) {
        return 'this is a user id'
    } else if (id instanceof SellerId) {
        return 'this is a seller id'
    }

    return assertNever(id)
}

Sadly, I have to put an ugly assertNever at the end.

I just discovered this lib, and it would be quite nice to be able to pattern match those cases too without tedious instanceof chains.

A sample implementation would be something like:

match(id)
    .with(UserId, (res) => 'UserId detected')
    .with(SellerId, (res) => 'SellerId detected')
    .exhaustive()

How difficult would it be to implement it?

[gvergnaud]

Having an instanceOf() pattern for this use case would be an interesting idea (if it wasn’t a reserved word). I’ll think about adding it to the lib.

in the meantime using when + an isInstanceOf helper function to create the predicate should work:

class UserId {
  constructor(public val: string, private _?: string) {}
}

class SellerId {
  constructor(public val: string, private _?: string) {}
}

type Ids = UserId | SellerId;

// Helper function
type AnyConstructor = new (...args: any[]) => any;

function isInstanceOf<T extends AnyConstructor>(classConstructor: T) {
  return (val: unknown): val is InstanceType<T> => val instanceof classConstructor;
}

const id = new UserId("") as Ids;

// This works fine
const result = match<Ids>(id)
  .when(isInstanceOf(UserId), (x) => console.log("user id"))
  .when(isInstanceOf(SellerId), (y) => console.log("seller id"))
  .exhaustive();

your matchClass function wasn’t working because val is T states that val is the constructor, not an instance of this class. you need to use val is InstanceType<T> instead.

[gvergnaud]

an instanceOf pattern has been added in the latest release! https://github.com/gvergnaud/ts-pattern/releases/tag/v3.2.1