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 };
  }
}

For anyone who just wants to throw this function into their codebase and test it out

export function tryCatch<T, E = Error>(fn: () => T) {
  type Result<TResult, EResult> =
    | { data: TResult; error: null }
    | { data: null; error: EResult };
  type ReturnType =
    T extends Promise<infer P> ? Promise<Result<P, E>> : Result<T, E>;

  try {
    const result = fn();
    if (result instanceof Promise) {
      return result
        .then((data: Promise<unknown>) => ({ data, error: null }))
        .catch((e: unknown) => {
          return { data: null, error: e as E };
        }) as ReturnType;
    } else {
      return { data: result, error: null } as ReturnType;
    }
  } catch (e: unknown) {
    return { data: null, error: e as E } as ReturnType;
  }
}

@osoclos Let me explain my solution safe-throw:

An example function:

import * as st from 'safe-throw';

const fn = () => Math.random() < 0.5 ? 10 : st.err('Random');

The problem here is "how to create a safe wrapper with good DX for outside APIs that can throw". Theo's code is a solution to that. Your code is a way to control errors in your own hand-rolled APIs. These two problems are very much not the same.

@Joseph-Martre it has an API for that

import * as native from 'safe-throw/native';

const safePromise = await native.tryPromise(promise); // T | native.Err
const safeFetch = native.asyncTry(fetch);

This thread nerdsniped me to unify the sync/async methods in my lib: https://github.com/thelinuxlich/go-go-try