Result & tryCatch

A thrown exception is invisible in a function's type - nothing at the call site says it can fail, and catch (e) just hands you unknown. Result<T, E> moves the failure into the return type instead: the caller gets { ok: true, value } or { ok: false, error }, and can't reach value without checking ok first.

@itsnas usage.ts

codeusage.ts

// Wrap a sync call that throws, no try/catch at the call site
// @src/code/result
const config = tryCatch(() => JSON.parse(raw) as Config)
 
if (!config.ok) {
  logger.warn('invalid config, using defaults', config.error)
  return defaultConfig
}
 
applyConfig(config.value) // Config, narrowed
 
// Wrap a promise that may reject
const user = await tryCatchAsync(fetchUser(id))
if (!user.ok) return null
return user.value
 
// `error` is always an Error, so subclasses still narrow
const insert = await tryCatchAsync(db.insert(row))
if (!insert.ok && insert.error instanceof UniqueViolationError) {
  return conflict()
}
 
// For a failure you raise yourself, return ok() / err() directly
function half(n: number): Result<number, string> {
  return n % 2 === 0 ? ok(n / 2) : err('odd number')
}

main

Nas (@itsnas)

export type Result<T, E = Error> =
  | { ok: true; value: T }
  | { ok: false; error: E }
 
export function ok<T>(value: T): Result<T, never> {
  return { ok: true, value }
}
 
export function err<E>(error: E): Result<never, E> {
  return { ok: false, error }
}
 
// Run a throwing function; capture the outcome instead of it
// escaping.
export function tryCatch<T>(fn: () => T): Result<T> {
  try {
    return ok(fn())
  } catch (e) {
    return err(toError(e))
  }
}
 
// Same, for a promise that may reject.
export async function tryCatchAsync<T>(
  promise: Promise<T>,
): Promise<Result<T>> {
  try {
    return ok(await promise)
  } catch (e) {
    return err(toError(e))
  }
}
 
function toError(e: unknown): Error {
  return e instanceof Error ? e : new Error(String(e))
}

main

Nas (@itsnas)