❌ Go-like error catching implementation to avoid messy try-catch statements in Typescript.

attempt.ts

/**
 * Go-like error catching implementation.
 * 
 * The 'attempt' function receives a callback function as a parameter
 * and calls it inside a try catch statement.
 * 
 * Returns a tuple of [data, error] where 'data' (if exists) is the 
 * result of the operation and 'error' (if exists)
 * is the error from the catch statement.
 */

type AttemptError = {
  msg: string;
  errorObject: any;
};

type AttemptState<T> = {
  result: T | undefined;
  error: AttemptError | undefined;
}

type AttemptResult<T> = [T | undefined, AttemptError | undefined];

const attempt = async <T>(
  fn: () => Promise<T>
): Promise<AttemptResult<T>> => {
  
  let state: AttemptState<T> = {
    result: undefined,
    error: undefined,
  };

  try {
    state.result = await fn();
  } catch (err) {
    state.error = { 
      msg: 'An error has ocurred',
      errorObject: err
    };
  } finally {
    return [state.result, state.error];
  }
};

Example usage

const riskyFn = async (input: string): string => {
  await someRiskyOperation();
  return 'it works!';
}

const [result, error] = await attempt<string>(() => riskyFn('hope it works'));
if (error) {
 console.error(error.objectError);
 return 'Did not work :(';
}

console.log(result); // 'it works!'