Declaring failures as types instead of try-catch changes how you write service tests.

// Promise — can't tell from the signature what it might throw
async function findUser(id: string): Promise<User> { ... }
 
// Effect — failures and dependencies are declared in the signature
const findUser = (id: string): Effect.Effect<User, UserNotFound | DbError, Database> => ...

import { Data, Effect } from "effect";
 
class UserNotFound extends Data.TaggedError("UserNotFound")<{
  id: string;
}> {}
 
class DbError extends Data.TaggedError("DbError")<{
  cause: unknown;
}> {}

const program = Effect.gen(function* () {
  const user = yield* findUser("123");
  // E channel: UserNotFound | DbError automatically composed
  return user;
}).pipe(
  // Handle UserNotFound locally → removed from E channel
  Effect.catchTag("UserNotFound", (e) =>
    Effect.succeed({ id: e.id, name: "Guest" })
  )
  // DbError remains in E channel → caller must handle it
);
// Type: Effect<User, DbError, Database>

import { Context, Effect, Layer } from "effect";
 
interface DatabaseService {
  query: (sql: string, params: unknown[]) => Effect.Effect<unknown[], DbError>;
}
 
// "Database" is the runtime identifier, DatabaseService is the static type
const Database = Context.GenericTag<DatabaseService>("Database");
 
const DatabaseLive = Layer.succeed(Database, {
  query: (sql, params) =>
    Effect.tryPromise({
      try: () => pool.query(sql, params).then((r) => r.rows),
      catch: (e) => new DbError({ cause: e }),
    }),
});

// user.service.ts
import { Effect } from "effect";
 
// In a real project, it's recommended to validate with Effect Schema or Zod
const parseUser = (row: unknown): User => {
  const r = row as Record<string, unknown>;
  return {
    id: r["id"] as string,
    name: r["name"] as string,
    email: r["email"] as string,
  };
};
 
@Injectable()
export class UserService {
  findOne(id: string): Effect.Effect<User, UserNotFound | DbError, Database> {
    return Effect.gen(function* () {
      const db = yield* Database;
      // db.query has DbError in its E channel, so it propagates automatically via yield*
      const rows = yield* db.query(`SELECT * FROM users WHERE id = $1`, [id]);
 
      if (rows.length === 0) {
        return yield* new UserNotFound({ id });
      }
 
      return parseUser(rows[0]);
    });
  }
}

// effect.interceptor.ts — global interceptor
import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from "@nestjs/common";
import { Effect } from "effect";
import { Observable, from, of, switchMap } from "rxjs";
 
@Injectable()
export class EffectInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<unknown> {
    return next.handle().pipe(
      switchMap((value) => {
        if (Effect.isEffect(value)) {
          return from(
            Effect.runPromise(
              value.pipe(Effect.provide(DatabaseLive))
            )
          );
        }
        return of(value);
      })
    );
  }
}

// user.service.spec.ts
import { Effect, Exit, Cause, Layer } from "effect";
 
const TestDatabase = Layer.succeed(Database, {
  query: (_sql, _params) =>
    Effect.succeed([{ id: "123", name: "Alice", email: "alice@example.com" }]),
});
 
describe("UserService.findOne", () => {
  it("returns a User when the user exists", async () => {
    const result = await Effect.runPromise(
      userService.findOne("123").pipe(Effect.provide(TestDatabase))
    );
 
    expect(result.name).toBe("Alice");
  });
 
  it("raises a UserNotFound error when the user does not exist", async () => {
    const EmptyDatabase = Layer.succeed(Database, {
      query: () => Effect.succeed([]),
    });
 
    // runPromiseExit: returns both success and failure as Exit<A, E> (no reject)
    const exit = await Effect.runPromiseExit(
      userService.findOne("999").pipe(Effect.provide(EmptyDatabase))
    );
 
    expect(Exit.isFailure(exit)).toBe(true);
    if (Exit.isFailure(exit) && Cause.isFail(exit.cause)) {
      expect(exit.cause.error).toBeInstanceOf(UserNotFound);
      expect((exit.cause.error as UserNotFound).id).toBe("999");
    }
  });
});

// user.handler.ts (Hono)
import { Effect } from "effect";
 
app.get("/users/:id", async (c) => {
  const handler = Effect.gen(function* () {
    const user = yield* userService.findOne(c.req.param("id"));
    return c.json(user);
  }).pipe(
    // E: UserNotFound | DbError → DbError
    Effect.catchTag("UserNotFound", (e) =>
      Effect.succeed(c.json({ error: `User ${e.id} not found` }, 404))
    ),
    // E: DbError → never
    Effect.catchTag("DbError", (e) => {
      console.error(e.cause);
      return Effect.succeed(c.json({ error: "Internal server error" }, 500));
    }),
    // R: Database → never (satisfies runPromise compile condition)
    Effect.provide(DatabaseLive)
  );
 
  return Effect.runPromise(handler);
});

import { Effect, Schedule, Data } from "effect";
 
class RateLimitError extends Data.TaggedError("RateLimitError")<{}> {}
class ModelUnavailableError extends Data.TaggedError("ModelUnavailableError")<{}> {}
 
// A schedule that retries only on RateLimitError
const rateLimitSchedule = Schedule.exponential("1 second").pipe(
  Schedule.intersect(Schedule.recurs(3)),
  Schedule.whileInput(
    (e: RateLimitError | ModelUnavailableError) => e._tag === "RateLimitError"
  )
);
 
const callLLM = (prompt: string) =>
  Effect.gen(function* () {
    // ... gpt-4o call
  }).pipe(
    // RateLimit: retry up to 3 times with exponential backoff
    // ModelUnavailableError: does not meet schedule condition → passed to catchTag below
    Effect.retry(rateLimitSchedule),
    // If ModelUnavailable, fall back to fallback model
    Effect.catchTag("ModelUnavailableError", () => callFallbackLLM(prompt))
  );