El patrón Result: Ok y Err

Bienvenida

Tipo Result

type Ok<T> = { ok: true; value: T };
type Err<E = Error> = { ok: false; error: E };
type Result<T, E = Error> = Ok<T> | Err<E>;

Constructores auxiliares

const ok = <T>(value: T): Ok<T> => ({ ok: true, value });
const err = <E>(error: E): Err<E> => ({ ok: false, error });

Devolver Results

async function fetchUser(id: number): Promise<Result<User>> {
  try {
    const user = await db.findUser(id);
    if (!user) return err(new Error('Not found'));
    return ok(user);
  } catch (e) { return err(e as Error); }
}

Consumir Results

const result = await fetchUser(1);
if (result.ok) {
  console.log(result.value.name); // User
} else {
  console.error(result.error.message);
}

Función auxiliar mapResult

function mapResult<T, U, E>(r: Result<T, E>, fn: (v: T) => U): Result<U, E> {
  return r.ok ? ok(fn(r.value)) : r;
}

Función auxiliar flatMapResult

function flatMap<T, U, E>(r: Result<T, E>, fn: (v: T) => Result<U, E>): Result<U, E> {
  return r.ok ? fn(r.value) : r;
}

Result frente a excepciones

Compatibilidad de bibliotecas

Result en controladores de API

app.get('/users/:id', async (req, res) => {
  const result = await fetchUser(parseInt(req.params.id));
  if (result.ok) res.json(result.value);
  else res.status(404).json({ error: result.error.message });
});

Results asíncronos

type AsyncResult<T, E = Error> = Promise<Result<T, E>>;

Comprobación rápida

Recapitulación