Theo's preferred way of handling try/catch in TypeScript

try-catch.ts

// Types for the result object with discriminated union
type Success<T> = {
  data: T;
  error: null;
};

type Failure<E> = {
  data: null;
  error: E;
};

type Result<T, E = Error> = Success<T> | Failure<E>;

// Main wrapper function
export async function tryCatch<T, E = Error>(
  promise: Promise<T>,
): Promise<Result<T, E>> {
  try {
    const data = await promise;
    return { data, error: null };
  } catch (error) {
    return { data: null, error: error as E };
  }
}

@osoclos

1. How do you know if a function throws? With this you always know the result may throw by returning an error (plus it's way faster to not capture stack trace and allocate an Error instance).
2. With this you don't need stack traces. You can always throw if you want to for unrecoverable errors (you should check out neverthrow).

I think just like promises , it might be useful to try catch normal callback functions

export function tryCatchSync<T, E = Error>(callback: () => T): Result<T, E> {
  try {
    const data = callback();
    return { data, error: null };
  } catch (error) {
    return { data: null, error: error as E };
  }
}

So now you can use it like

const {data,error} = tryCatchSync(()=>JSON.parse(someString))