For a long time, TypeScript has lacked a robust standard library. While other languages like Rust, Go, or Python offer standard tools for error handling, concurrency, and side effects, TypeScript developers have had to resort to multiple specialized libraries. Effect TS is changing this by offering a unified and powerful solution for modern TypeScript application development.

What is Effect TS?

Effect is a powerful TypeScript library designed to help developers easily create complex, synchronous, and asynchronous programs. Inspired by ZIO from Scala, Effect brings functional programming principles to TypeScript in a practical and accessible way.

Key features include:

• Fiber-based concurrency: For highly scalable and ultra-low latency applications
• Composability: Build maintainable software using small, reusable blocks
• Resource safety: Safely manage resource acquisition and release
• Type safety: Leverage TypeScript’s type system to the fullest
• Structured error handling: Errors as values, not exceptions
• Complete observability: With tracing capabilities for debugging and monitoring

The Error Handling Problem in TypeScript

Consider a typical error handling example in TypeScript:

async function getTodo(id: number): Promise<any> {
  try {
    const response = await fetch(`/todos/${id}`)
    if (!response.ok) throw new Error("Not OK!")

    try {
      const todo = await response.json()
      return todo
    } catch (jsonError) {
      throw new Error("Invalid JSON")
    }
  } catch (error) {
    throw new Error("Request failed")
  }
}

The problems are evident:

• Implicit errors: No type information about what errors can occur
• Verbose handling: Multiple nested try-catch blocks
• Information loss: Original errors get lost in transformations
• Lack of type safety: catch (error) is of type unknown

The Solution with Effect TS

With Effect, the same code looks like this:

import { Effect, HttpClient } from "effect"

const getTodo = (id: number): Effect.Effect<unknown, HttpClientError> =>
  HttpClient.get(`/todos/${id}`).pipe(
    Effect.andThen((response) => response.json)
  )

What have we gained?

• Explicit errors: The HttpClientError type tells us exactly what can fail
• Composability: We use pipe to chain operations
• Deferred execution: The effect describes the computation without executing it immediately
• Complete type safety: Everything is typed, including errors

The Effect System of Effect TS

In Effect, an effect is represented as Effect<Success, Error, Requirements>:

• Success (A): The value type returned when the operation succeeds
• Error (E): The error type returned if the operation fails
• Requirements (R): The dependencies the function requires

import { Effect } from "effect"

// An effect that can fail with 'string' and succeeds with 'number'
const divide = (a: number, b: number): Effect.Effect<number, string, never> =>
  b === 0
    ? Effect.fail("Division by zero")
    : Effect.succeed(a / b)

// Composing effects
const calculation = Effect.gen(function* () {
  const result1 = yield* divide(10, 2)  // 5
  const result2 = yield* divide(result1, 0)  // Error!
  return result2
})

Advanced Error Handling

Effect offers multiple strategies for error handling:

Error Recovery

const safeCalculation = calculation.pipe(
  Effect.catchAll((error) =>
    Effect.succeed(`Error: ${error}`)
  )
)

Automatic Retries

const withRetry = calculation.pipe(
  Effect.retry({ times: 3, delay: "1 second" })
)

Error Transformation

const withBetterErrors = calculation.pipe(
  Effect.mapError((error) => new CustomError(error))
)

Concurrency Without Complications

Effect handles concurrency using fibers, which are like lightweight threads but safer:

import { Effect } from "effect"

const fetchUser = (id: string) =>
  Effect.promise(() => fetch(`/users/${id}`))

const fetchProfile = (id: string) =>
  Effect.promise(() => fetch(`/profiles/${id}`))

// Execute both operations in parallel
const fetchUserData = (id: string) =>
  Effect.all([
    fetchUser(id),
    fetchProfile(id)
  ], { concurrency: "unbounded" })

Elegant Dependency Injection

Effect includes a powerful, type-safe dependency injection system:

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

// Define a service
class DatabaseService extends Context.Tag("DatabaseService")<
  DatabaseService,
  {
    readonly getUser: (id: string) => Effect.Effect<User, DatabaseError>
  }
>() {}

// Use the service
const getUser = (id: string) =>
  Effect.gen(function* () {
    const db = yield* DatabaseService
    return yield* db.getUser(id)
  })

// Service implementation
const DatabaseServiceLive = Layer.succeed(
  DatabaseService,
  {
    getUser: (id) => Effect.succeed({ id, name: "John" })
  }
)

// Execute with the dependency
const program = getUser("123").pipe(
  Effect.provide(DatabaseServiceLive)
)

Integrated Data Validation

Effect includes a powerful validation system called Schema:

import { Schema } from "@effect/schema"

const User = Schema.Struct({
  id: Schema.String,
  name: Schema.String,
  age: Schema.Number.pipe(Schema.between(0, 120)),
  email: Schema.String.pipe(Schema.Email)
})

const parseUser = (data: unknown) =>
  Schema.decodeUnknown(User)(data)

// Usage
const result = parseUser({
  id: "123",
  name: "John",
  age: 30,
  email: "john@example.com"
})
// result is Effect<User, ParseError, never>

Comparison with Alternatives

Effect vs. Promises

Effect vs. fp-ts

fp-ts is a library for typed functional programming in TypeScript. While fp-ts focuses on pure mathematical abstractions, Effect is more pragmatic:

• Effect: Focus on real-world applications
• fp-ts: Focus on mathematical correctness
• Effect: More accessible documentation
• fp-ts: Steeper learning curve

Ideal Use Cases

Effect TS is especially useful for:

1. APIs and web services with multiple dependencies
2. Data processing with complex validation
3. Highly concurrent applications
4. Systems requiring advanced observability
5. Projects where correctness is critical

Should You Adopt Effect TS?

Advantages:

• ✅ Superior error handling
• ✅ Excellent type system
• ✅ Powerful concurrency tools
• ✅ Unified ecosystem
• ✅ Comprehensive documentation

Considerations:

• ⚠️ Moderate learning curve
• ⚠️ Different paradigm from typical imperative style
• ⚠️ Larger bundle size (though tree-shakeable)

Conclusion

Effect is filling this gap by providing a solid foundation of data structures, utilities, and abstractions to make building applications easier.

Effect TS represents a fundamental shift in how we develop TypeScript applications. It’s not just another functional library - it’s a complete ecosystem that addresses the fundamental limitations of modern TypeScript development.

If you work with complex applications that require robust error handling, advanced concurrency, or simply want to improve the quality and maintainability of your code, Effect TS deserves serious evaluation.

The library is rapidly gaining traction in the TypeScript community, and there’s a reason for it: we finally have a de facto standard library for TypeScript.

Have you tried Effect TS in your projects? What do you think about the functional approach to side effect handling? I’d love to know your experience!