TypeScript higher order function which wraps async fetcher and returns with Result<T,E> like Rust

result-type.ts

/* eslint-disable max-classes-per-file, no-useless-constructor, lines-between-class-members */
type Result<T, E extends Error> = Ok<T, E> | Err<T, E>;

export class Ok<T, E extends Error> {
  constructor(readonly val: T) {}
  isOk = (): this is Ok<T, E> => true;
  isErr = (): this is Err<T, E> => false;
}

export class Err<T, E extends Error> {
  constructor(readonly err: E) {}
  isOk = (): this is Ok<T, E> => false;
  isErr = (): this is Err<T, E> => true;
}

// eslint-disable-next-line @typescript-eslint/no-explicit-any
export const withResult = <T, A extends any[], E extends Error>(
  fn: (...args: A) => Promise<T>,
) => async (...args: A): Promise<Result<T, E>> => {
  try {
    return new Ok(await fn(...args));
  } catch (error) {
    return new Err(error as E);
  }
};

Usage:

// fetchUser: (userId: string) => Promise<User>
const data = await withResult(fetchUser)('oukayuka');

if (data.isErr()) {
  console.error(data.err);
} else {
  const user = data.val;
  console.log(`Hello, ${user.name}!`);
}