Effect-TS - Programación funcional en TypeScript

¿Qué es Effect-TS?

Effect-TS es una librería que permite la programación funcional en TypeScript. Proporciona manejo de errores type-safe, inyección de dependencias y procesamiento concurrente, permitiendo construir aplicaciones robustas.

Conceptos básicos

Tipo Effect

Effect<A, E, R> tiene tres parámetros de tipo.

Effect<
  A,  // Tipo del valor de retorno en caso de éxito
  E,  // Tipo de errores posibles
  R   // Dependencias requeridas (Requirements)
>

Uso básico

Creación de Effect

import { Effect } from 'effect';

// Effect exitoso
const success = Effect.succeed(42);

// Effect fallido
const failure = Effect.fail(new Error('Something went wrong'));

// Effect asíncrono
const asyncEffect = Effect.promise(() => fetch('/api/data').then(r => r.json()));

// Capturar excepciones
const safe = Effect.try({
  try: () => JSON.parse(invalidJson),
  catch: (error) => new ParseError(error)
});

Ejecución de Effect

import { Effect } from 'effect';

const program = Effect.succeed(42);

// Ejecución síncrona
const result = Effect.runSync(program);

// Ejecución asíncrona
const promise = Effect.runPromise(program);

// Promise (devuelve error como tipo Either)
const exit = await Effect.runPromiseExit(program);

Manejo de errores

Errores type-safe

import { Effect, Data } from 'effect';

// Definición de errores personalizados
class NetworkError extends Data.TaggedError('NetworkError')<{
  message: string;
}> {}

class ValidationError extends Data.TaggedError('ValidationError')<{
  field: string;
  message: string;
}> {}

// Función que puede generar errores
const fetchUser = (id: string): Effect.Effect<
  User,
  NetworkError | ValidationError
> => {
  if (!id) {
    return Effect.fail(new ValidationError({ field: 'id', message: 'Required' }));
  }
  return Effect.tryPromise({
    try: () => fetch(`/api/users/${id}`).then(r => r.json()),
    catch: () => new NetworkError({ message: 'Failed to fetch' })
  });
};

Procesamiento de errores

const program = fetchUser('123').pipe(
  // Capturar error específico
  Effect.catchTag('NetworkError', (e) =>
    Effect.succeed({ name: 'Fallback User' })
  ),
  // Capturar todos los errores
  Effect.catchAll((e) => Effect.succeed({ name: 'Default' }))
);

Inyección de dependencias

Definición de servicios

import { Context, Effect, Layer } from 'effect';

// Interfaz del servicio
class Database extends Context.Tag('Database')<
  Database,
  {
    query: (sql: string) => Effect.Effect<unknown[]>;
  }
>() {}

// Función que usa el servicio
const getUsers = Effect.gen(function* () {
  const db = yield* Database;
  return yield* db.query('SELECT * FROM users');
});

// Implementación
const DatabaseLive = Layer.succeed(Database, {
  query: (sql) => Effect.promise(() => pool.query(sql))
});

// Mock para testing
const DatabaseTest = Layer.succeed(Database, {
  query: () => Effect.succeed([{ id: 1, name: 'Test' }])
});

// Ejecución
const program = getUsers.pipe(
  Effect.provide(DatabaseLive)
);

Procesamiento concurrente

Ejecución en paralelo

import { Effect } from 'effect';

const task1 = Effect.promise(() => fetch('/api/users'));
const task2 = Effect.promise(() => fetch('/api/posts'));
const task3 = Effect.promise(() => fetch('/api/comments'));

// Ejecutar todo en paralelo
const all = Effect.all([task1, task2, task3], { concurrency: 'unbounded' });

// Limitar paralelismo
const limited = Effect.all([task1, task2, task3], { concurrency: 2 });

// Obtener el primero que complete
const race = Effect.race([task1, task2, task3]);

Gestión de recursos

import { Effect } from 'effect';

const acquire = Effect.promise(() => pool.connect());
const release = (conn: Connection) => Effect.promise(() => conn.release());

const withConnection = Effect.acquireUseRelease(
  acquire,
  (conn) => Effect.promise(() => conn.query('SELECT 1')),
  release
);

Pipelines

import { Effect, pipe } from 'effect';

const program = pipe(
  Effect.succeed({ name: 'Alice', age: 30 }),
  Effect.map(user => user.name),
  Effect.flatMap(name => Effect.succeed(`Hello, ${name}!`)),
  Effect.tap(greeting => Effect.log(greeting))
);

// O también
const program2 = Effect.succeed({ name: 'Alice', age: 30 }).pipe(
  Effect.map(user => user.name),
  Effect.flatMap(name => Effect.succeed(`Hello, ${name}!`))
);

Sintaxis Generator

import { Effect } from 'effect';

const program = Effect.gen(function* () {
  const user = yield* fetchUser('123');
  const posts = yield* fetchPosts(user.id);
  const comments = yield* fetchComments(posts[0].id);

  return { user, posts, comments };
});

Scheduling

import { Effect, Schedule } from 'effect';

// Estrategia de retry
const retry = Schedule.exponential('100 millis').pipe(
  Schedule.compose(Schedule.recurs(3))
);

const program = fetchData.pipe(
  Effect.retry(retry)
);

// Ejecución periódica
const repeated = Effect.repeat(
  fetchData,
  Schedule.spaced('1 minute')
);

Resumen

Effect-TS añade potentes capacidades de programación funcional a TypeScript. Permite construir aplicaciones con alta mantenibilidad y confiabilidad gracias al manejo de errores type-safe, inyección de dependencias y procesamiento concurrente.