Effect-TS: Handle Errors and Dependencies With Full Type Safety in TypeScript

Effect-TS tracks errors and dependencies in the type system - no more unknown catch blocks, no more implicit dependencies - here is how to adopt it in a real TypeScript project.

Mahmudul Haque Qudrati

CEO & ML Engineer

May 10, 2026

7 min read

// tags

#effect-ts#typed-errors#dependency-injection#typescript#functional

FIG. ART-22

7 min read

“

Effect-TS: Handle Errors and Dependencies With Full Type Safety in TypeScript

// reading plan

sections

517

words

min read

// Web Development

How to Build an MCP Server in TypeScript (Step-by-Step)

Build your first MCP server in TypeScript with the official SDK — tools, stdio transport, and a Claude Code test loop in under an hour.

5 min read

// Web Development

React Server Components: What They Are and When to Use Them

`Effect.gen()` - Async/Await Syntax

Effect.gen() provides generator-based syntax that reads like async/await but with typed errors:

import { Effect, Console } from "effect";

const program = Effect.gen(function* () {
  const user = yield* getUser("user-123");    // typed: User | fails with UserNotFound
  const posts = yield* getUserPosts(user.id); // typed: Post[] | fails with NotFound
  yield* Console.log(`${user.name} has ${posts.length} posts`);
  return { user, posts };
});

// Run it  -  provide requirements, handle errors
Effect.runPromise(
  program.pipe(
    Effect.provide(DatabaseLive),     // satisfy DatabaseClient requirement
    Effect.catchTag("UserNotFound", (e) =>
      Effect.succeed({ user: null, posts: [] })
    ),
  )
);

Typed Error Channel

import { Data, Effect } from "effect";

// Define typed errors
class UserNotFound extends Data.TaggedError("UserNotFound")<{ id: string }> {}
class DatabaseError extends Data.TaggedError("DatabaseError")<{ cause: unknown }> {}

const fetchUser = (id: string) =>
  Effect.tryPromise({
    try: () => db.users.findOne(id),
    catch: (e) => new DatabaseError({ cause: e }),
  }).pipe(
    Effect.flatMap((user) =>
      user ? Effect.succeed(user) : Effect.fail(new UserNotFound({ id }))
    )
  );

// Handle specific error types
fetchUser("123").pipe(
  Effect.catchTag("UserNotFound", () => Effect.succeed(defaultUser)),
  Effect.catchTag("DatabaseError", (e) => {
    console.error(e.cause);
    return Effect.fail(new ServiceUnavailable());
  })
);

Dependency Injection via Layer

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

// Define a service interface
class EmailService extends Context.Tag("EmailService")<
  EmailService,
  { sendWelcome: (email: string) => Effect.Effect<void> }
>() {}

// Live implementation
const EmailServiceLive = Layer.succeed(
  EmailService,
  {
    sendWelcome: (email) =>
      Effect.tryPromise({
        try: () => nodemailer.sendMail({ to: email, subject: "Welcome!" }),
        catch: (e) => new EmailError({ cause: e }),
      }),
  }
);

// Test implementation
const EmailServiceTest = Layer.succeed(
  EmailService,
  { sendWelcome: (_email) => Effect.void }
);

// Use in program  -  compiler requires EmailService to be provided
const registerUser = (email: string) =>
  Effect.gen(function* () {
    const mailer = yield* EmailService;
    yield* mailer.sendWelcome(email);
  });

Retry, Timeout, and Schedule

import { Effect, Schedule } from "effect";

const resilientFetch = fetchUser("123").pipe(
  Effect.timeout("5 seconds"),
  Effect.retry(
    Schedule.exponential("100 millis").pipe(
      Schedule.intersect(Schedule.recurs(3))  // max 3 retries with exponential backoff
    )
  ),
);

When to Adopt Effect-TS

Good fit:

New TypeScript projects where you control the whole stack
Server-side Node.js code with complex error scenarios
Replacing fp-ts (Effect is the spiritual successor)
Teams that want to eliminate runtime surprises

Not the right fit:

Browser bundles (Effect adds ~50KB gzipped)
Projects mixing plain JS and TypeScript
When you just need simple error handling - use neverthrow instead

References: Effect · GitHub · docs

Effect-TS: Handle Errors and Dependencies With Full Type Safety in TypeScript

Related Articles

How to Build an MCP Server in TypeScript (Step-by-Step)

React Server Components: What They Are and When to Use Them

The Problem Effect Solves

The Effect Type

`Effect.gen()` - Async/Await Syntax

Typed Error Channel

Dependency Injection via Layer

Retry, Timeout, and Schedule

When to Adopt Effect-TS

The workspace your team
actually needs

AI & ML insights, weekly

Mahmudul Haque Qudrati

Next.js App Router Patterns in 2026: What to Use and What to Avoid

Effect-TS: Handle Errors and Dependencies With Full Type Safety in TypeScript

Related Articles

How to Build an MCP Server in TypeScript (Step-by-Step)

React Server Components: What They Are and When to Use Them

The Problem Effect Solves

The Effect Type

Effect.gen() - Async/Await Syntax

Typed Error Channel

Dependency Injection via Layer

Retry, Timeout, and Schedule

When to Adopt Effect-TS

The workspace your teamactually needs

AI & ML insights, weekly

Mahmudul Haque Qudrati

Next.js App Router Patterns in 2026: What to Use and What to Avoid

`Effect.gen()` - Async/Await Syntax

The workspace your team
actually needs