Warning

This is an auto-generated file. Manual edits will be overwritten by the publishing pipeline. For project information, see ABOUT.md

Effect Patterns Index (Review)

Grouped by skillLevel (intro → intermediate → advanced) then by the primary useCase (first element). Remaining useCase values appear as badges. Tie-breaker within groups is title (A–Z).

Table of Contents

• Start Here
• Intro
• Intermediate
• Advanced

---

Start Here

• Understand that Effects are Lazy Blueprints
• Understand the Three Effect Channels (A, E, R)
• Use .pipe for Composition
• Create Pre-resolved Effects with succeed and fail
• Wrap Synchronous Computations with sync and try
• Wrap Asynchronous Computations with tryPromise
• Transform Effect Values with map and flatMap
• Write Sequential Code with Effect.gen
• Converting from Nullable, Option, or Either
• Model Optional Values Safely with Option

---

Intro

Building APIs (4)

• Create a Basic HTTP Server - tags: http
  • summary: Launch a simple, effect-native HTTP server to respond to incoming requests.
• Extract Path Parameters - tags: http
  • summary: Capture and use dynamic segments from a request URL, such as a resource ID.
• Handle a GET Request - tags: http
  • summary: Define a route that responds to a specific HTTP GET request path.
• Send a JSON Response - tags: http
  • summary: Create and send a structured JSON response with the correct headers and status code.

Building Data Pipelines (3)

• Collect All Results into a List - tags: stream
  • summary: Run a pipeline and gather all of its results into an in-memory array.
• Create a Stream from a List - tags: stream
  • summary: Turn a simple in-memory array or list into a foundational data pipeline using Stream.
• Run a Pipeline for its Side Effects - tags: stream
  • summary: Execute a pipeline for its effects without collecting the results, saving memory.

Combinators (5)

• Chaining Computations with flatMap - badges: Composition, Sequencing
• tags: flatMap, combinator, monad, effect, stream, option, either
  • summary: Use flatMap to chain together computations where each step may itself be effectful, optional, or error-prone.
• Combining Values with zip - badges: Composition, Pairing
• tags: zip, combinator, pair, effect, stream, option, either
  • summary: Use zip to combine two computations, pairing their results together in Effect, Stream, Option, or Either.
• Conditional Branching with if, when, and cond - badges: Composition, Conditional Logic
• tags: conditional, if, when, cond, combinator, effect, stream, option, either
  • summary: Use combinators like if, when, and cond to express conditional logic declaratively across Effect, Stream, Option, and Either.
• Filtering Results with filter - badges: Composition, Conditional Logic
• tags: filter, combinator, predicate, effect, stream, option, either
  • summary: Use filter to keep or discard results based on a predicate, across Effect, Stream, Option, and Either.
• Transforming Values with map - badges: Composition
• tags: map, combinator, functor, effect, stream, option, either
  • summary: Use map to transform the result of an Effect, Stream, Option, or Either in a declarative, type-safe way.

Constructors (6)

• Converting from Nullable, Option, or Either - badges: Interop, Conversion
• tags: fromNullable, fromOption, fromEither, constructor, effect, stream, option, either, interop, conversion
  • summary: Use fromNullable, fromOption, and fromEither to convert nullable values, Option, or Either into Effects or Streams, enabling safe and composable interop.
• Creating from Collections - badges: Collections, Streams, Batch Processing
• tags: fromIterable, fromArray, constructor, stream, effect, collection, batch
  • summary: Use fromIterable and fromArray to create Streams or Effects from arrays, iterables, or other collections, enabling batch and streaming operations.
• Creating from Synchronous and Callback Code - badges: Interop, Async, Callback
• tags: sync, async, constructor, effect, interop, callback, legacy
  • summary: Use sync and async to lift synchronous or callback-based computations into Effect, enabling safe and composable interop with legacy code.
• Lifting Errors and Absence with fail, none, and left - badges: Lifting, Error Handling, Absence
• tags: fail, none, left, constructor, effect, option, either, error, absence
  • summary: Use fail, none, and left to represent errors or absence in Effect, Option, or Either, making failures explicit and type-safe.
• Lifting Values with succeed, some, and right - badges: Lifting, Composition
• tags: succeed, some, right, constructor, effect, option, either, lifting
  • summary: Use succeed, some, and right to lift plain values into Effect, Option, or Either, making them composable and type-safe.
• Wrapping Synchronous and Asynchronous Computations - badges: Error Handling, Async, Interop
• tags: try, tryPromise, constructor, effect, error, async, interop
  • summary: Use try and tryPromise to safely wrap synchronous or asynchronous computations that may throw or reject, capturing errors in the Effect world.

Core Concepts (9)

• Create Pre-resolved Effects with succeed and fail - tags: creation, succeed, fail, sync
  • summary: Use Effect.succeed(value) to create an Effect that immediately succeeds with a value, and Effect.fail(error) for an Effect that immediately fails.
• Solve Promise Problems with Effect - tags: promise
  • summary: Understand how Effect solves the fundamental problems of native Promises, such as untyped errors, lack of dependency injection, and no built-in cancellation.
• Transform Effect Values with map and flatMap - tags: map, flatMap, composition, transformation, chaining
  • summary: Use Effect.map for synchronous transformations and Effect.flatMap to chain operations that return another Effect.
• Understand that Effects are Lazy Blueprints - tags: laziness, immutability, blueprint, execution, runtime, core-concept
  • summary: An Effect is a lazy, immutable blueprint describing a computation, which does nothing until it is explicitly executed by a runtime.
• Understand the Three Effect Channels (A, E, R) - tags: effect
  • summary: Learn about the three generic parameters of an Effect: the success value (A), the failure error (E), and the context requirements (R).
• Use .pipe for Composition - tags: pipe, composition, chaining, readability
  • summary: Use the .pipe() method to chain multiple operations onto an Effect in a readable, top-to-bottom sequence.
• Wrap Asynchronous Computations with tryPromise - tags: promise, async, integration, creation, try
  • summary: Use Effect.tryPromise to safely convert a function that returns a Promise into an Effect, capturing rejections in the error channel.
• Wrap Synchronous Computations with sync and try - tags: sync, try, creation, error-handling, integration, exceptions
  • summary: Use Effect.sync for non-throwing synchronous code and Effect.try for synchronous code that might throw an exception.
• Write Sequential Code with Effect.gen - tags: generators, gen, sequential, async-await, readability
  • summary: Use Effect.gen with yield* to write sequential, asynchronous code in a style that looks and feels like familiar async/await.

Data Types (5)

• Accumulate Multiple Errors with Either - badges: Error Handling, Domain Modeling
• tags: Either, error-handling, data-type, domain, effect
  • summary: Use Either<E, A> to represent computations that can fail, allowing you to accumulate multiple errors instead of short-circuiting on the first one.
• Comparing Data by Value with Data.struct - badges: Structural Equality, Domain Modeling
• tags: Data.struct, structural-equality, immutable, data-type, effect
  • summary: Use Data.struct to create immutable, structurally-typed objects that can be compared by value, not by reference.
• Model Optional Values Safely with Option - badges: Domain Modeling, Optional Values
• tags: Option, optional, data-type, domain, effect
  • summary: Use Option to explicitly represent a value that may or may not exist, eliminating null and undefined errors.
• Working with Immutable Arrays using Data.array - badges: Arrays, Structural Equality, Collections
• tags: Data.array, array, structural-equality, immutable, data-type, effect
  • summary: Use Data.array to create immutable, type-safe arrays that support value-based equality and safe functional operations.
• Working with Tuples using Data.tuple - badges: Tuples, Structural Equality, Domain Modeling
• tags: Data.tuple, tuple, structural-equality, immutable, data-type, effect
  • summary: Use Data.tuple to create immutable, type-safe tuples that support value-based equality and pattern matching.

Modeling Data (1)

• Comparing Data by Value with Structural Equality - tags: equality
  • summary: Use Data.struct and Equal.equals to safely compare objects by their value instead of their reference, avoiding common JavaScript pitfalls.

Pattern Matching (2)

• Checking Option and Either Cases - badges: Option, Either, Branching, Checks
• tags: isSome, isNone, isLeft, isRight, pattern-matching, option, either, checks
  • summary: Use isSome, isNone, isLeft, and isRight to check Option and Either cases for simple, type-safe branching.
• Matching on Success and Failure with match - badges: Error Handling, Branching
• tags: match, pattern-matching, effect, option, either, error-handling, branching
  • summary: Use match to handle both success and failure cases in a single, declarative place for Effect, Option, and Either.

Project Setup & Execution (3)

• Execute Asynchronous Effects with Effect.runPromise - tags: execution, runtime, promise, async, end-of-world
  • summary: Use Effect.runPromise at the 'end of the world' to execute an asynchronous Effect and get its result as a JavaScript Promise.
• Execute Synchronous Effects with Effect.runSync - tags: execution, runtime, sync, end-of-world
  • summary: Use Effect.runSync at the 'end of the world' to execute a purely synchronous Effect and get its value directly.
• Set Up a New Effect Project - tags: project-setup, getting-started, typescript, tsconfig, npm, pnpm, bun
  • summary: Initialize a new Node.js project with the necessary TypeScript configuration and Effect dependencies to start building.

Resource Management (1)

• Safely Bracket Resource Usage with acquireRelease - badges: File Handling, Database Connections, Network Requests
• tags: resource, scope, acquire, release, bracket, finalizer, try-finally, interruption
  • summary: Use Effect.acquireRelease to guarantee a resource's cleanup logic runs, even if errors or interruptions occur.

---

Intermediate

Application Architecture (1)

• Compose Resource Lifecycles with Layer.merge - badges: Resource Management, Dependency Injection
• tags: resource, layer, scope, compose, merge, dependency-graph, architecture
  • summary: Combine multiple resource-managing layers, letting Effect automatically handle the acquisition and release order.

Application Configuration (3)

• Access Configuration from the Context - tags: configuration, config, context, generators, business-logic
  • summary: Access your type-safe configuration within an Effect.gen block by yielding the Config object you defined.
• Define a Type-Safe Configuration Schema - tags: configuration, config, schema, type-safety
  • summary: Use Effect.Config primitives to define a schema for your application's configuration, ensuring type-safety and separation from code.
• Provide Configuration to Your App via a Layer - tags: configuration, config, layers, dependency-injection
  • summary: Use Config.layer(schema) to create a Layer that provides your configuration schema to the application's context.

Branded Types (2)

• Modeling Validated Domain Types with Brand - badges: Domain Modeling, Type Safety
• tags: Brand, domain, type-safety, validation, effect
  • summary: Use Brand to create domain-specific types from primitives, making illegal states unrepresentable and preventing accidental misuse.
• Validating and Parsing Branded Types - badges: Domain Modeling, Validation, Parsing
• tags: Brand, Schema, validation, parsing, domain, type-safety, effect
  • summary: Use Schema and Brand together to validate and parse branded types at runtime, ensuring only valid values are constructed.

Building APIs (4)

• Handle API Errors - tags: http
  • summary: Translate application-specific errors from the Effect failure channel into meaningful HTTP error responses.
• Make an Outgoing HTTP Client Request - tags: http
  • summary: Use the built-in Effect HTTP client to make safe and composable requests to external services from within your API.
• Provide Dependencies to Routes - tags: http
  • summary: Inject services like database connections into HTTP route handlers using Layer and Effect.Service.
• Validate Request Body - tags: http
  • summary: Safely parse and validate an incoming JSON request body against a predefined Schema.

Building Data Pipelines (6)

• Automatically Retry Failed Operations - tags: stream
  • summary: Build a self-healing pipeline that can automatically retry failed processing steps using a configurable backoff strategy.
• Process a Large File with Constant Memory - tags: stream
  • summary: Create a data pipeline from a file on disk, processing it line-by-line without loading the entire file into memory.
• Process collections of data asynchronously - tags: stream
  • summary: Process collections of data asynchronously in a lazy, composable, and resource-safe manner using Effect's Stream.
• Process Items Concurrently - tags: stream
  • summary: Perform an asynchronous action for each item in a stream with controlled parallelism to dramatically improve performance.
• Process Items in Batches - tags: stream
  • summary: Group items into chunks for efficient bulk operations, like database inserts or batch API calls.
• Turn a Paginated API into a Single Stream - tags: stream
  • summary: Convert a paginated API into a continuous, easy-to-use stream, abstracting away the complexity of fetching page by page.

Combinators (3)

• Handling Errors with catchAll, orElse, and match - badges: Error Handling, Composition
• tags: error-handling, catchAll, orElse, match, combinator, effect, either, option
  • summary: Use catchAll, orElse, and match to recover from errors, provide fallbacks, or transform errors in Effect, Either, and Option.
• Mapping and Chaining over Collections with forEach and all - badges: Collections, Parallelism, Batch Processing
• tags: forEach, all, collections, parallelism, batch, combinator, effect, stream, option, either
  • summary: Use forEach and all to apply effectful functions to collections and combine the results, enabling batch and parallel processing.
• Sequencing with andThen, tap, and flatten - badges: Sequencing, Composition, Side Effects
• tags: sequencing, andThen, tap, flatten, combinator, effect, stream, option, either
  • summary: Use andThen, tap, and flatten to sequence computations, run side effects, and flatten nested structures in Effect, Stream, Option, and Either.

Concurrency (3)

• Process a Collection in Parallel with Effect.forEach - tags: concurrency
  • summary: Use Effect.forEach with the concurrency option to process a collection of items in parallel with a fixed limit, preventing resource exhaustion.
• Race Concurrent Effects for the Fastest Result - tags: concurrency
  • summary: Use Effect.race to run multiple effects concurrently and proceed with the result of the one that succeeds first, automatically interrupting the others.
• Run Independent Effects in Parallel with Effect.all - tags: concurrency
  • summary: Use Effect.all to run multiple independent effects concurrently and collect all their results into a single tuple.

Core Concepts (7)

• Conditionally Branching Workflows - tags: predicate
  • summary: Use predicate-based operators like Effect.filter and Effect.if to make decisions and control the flow of your application based on runtime values.
• Control Flow with Conditional Combinators - tags: control-flow, conditional, if, when, cond, declarative
  • summary: Use combinators like Effect.if, Effect.when, and Effect.cond to handle conditional logic in a declarative, composable way.
• Control Repetition with Schedule - tags: schedule
  • summary: Use Schedule to create composable, stateful policies that define precisely how an effect should be repeated or retried.
• Manage Shared State Safely with Ref - tags: ref
  • summary: Use Ref to model shared, mutable state in a concurrent environment, ensuring all updates are atomic and free of race conditions.
• Process Streaming Data with Stream - tags: stream
  • summary: Use Stream<A, E, R> to represent and process data that arrives over time, such as file reads, WebSocket messages, or paginated API results.
• Understand Layers for Dependency Injection - tags: layer
  • summary: A Layer is a blueprint that describes how to build a service, detailing its own requirements and any potential errors during its construction.
• Use Chunk for High-Performance Collections - tags: chunk
  • summary: Use Chunk as a high-performance, immutable alternative to JavaScript's Array, especially for data processing pipelines.

Data Types (10)

• Manage Shared State Safely with Ref - badges: State, Concurrency, Mutable State
• tags: Ref, state, concurrency, mutable, data-type, effect
  • summary: Use Ref to model shared, mutable state in a concurrent environment, ensuring all updates are atomic and free of race conditions.
• Modeling Effect Results with Exit - badges: Effect Results, Error Handling, Concurrency
• tags: Exit, effect, result, error-handling, concurrency, data-type
  • summary: Use Exit<E, A> to represent the result of running an Effect, capturing both success and failure (including defects) in a type-safe way.
• Modeling Tagged Unions with Data.case - badges: Tagged Unions, ADTs, Domain Modeling
• tags: Data.case, tagged-union, ADT, domain-modeling, pattern-matching, data-type, effect
  • summary: Use Data.case to create tagged unions (algebraic data types) for robust, type-safe domain modeling and pattern matching.
• Redact and Handle Sensitive Data - badges: Security, Sensitive Data, Logging
• tags: Redacted, security, sensitive-data, logging, data-type, effect
  • summary: Use Redacted to securely handle sensitive data, ensuring secrets are not accidentally logged or exposed.
• Representing Time Spans with Duration - badges: Time, Duration, Domain Modeling
• tags: Duration, time, interval, data-type, effect
  • summary: Use Duration to represent time intervals in a type-safe, human-readable, and composable way.
• Type Classes for Equality, Ordering, and Hashing with Data.Class - badges: Type Classes, Equality, Ordering, Hashing
• tags: Data.Class, type-class, equality, ordering, hashing, data-type, effect
  • summary: Use Data.Class to derive and implement type classes for equality, ordering, and hashing, enabling composable and type-safe abstractions.
• Use Chunk for High-Performance Collections - badges: Collections, Performance
• tags: Chunk, collection, performance, immutable, data-type, effect
  • summary: Use Chunk as a high-performance, immutable alternative to JavaScript's Array, especially for data processing pipelines.
• Work with Arbitrary-Precision Numbers using BigDecimal - badges: Numeric Precision, Financial, Scientific
• tags: BigDecimal, numeric, precision, decimal, data-type, effect
  • summary: Use BigDecimal for arbitrary-precision decimal arithmetic, avoiding rounding errors and loss of precision in financial or scientific calculations.
• Work with Dates and Times using DateTime - badges: Time, Date, Domain Modeling
• tags: DateTime, date, time, timezone, data-type, effect
  • summary: Use DateTime for immutable, time-zone-aware date and time values, enabling safe and precise time calculations.
• Work with Immutable Sets using HashSet - badges: Collections, Set Operations
• tags: HashSet, set, collection, immutable, data-type, effect
  • summary: Use HashSet to model immutable, high-performance sets for efficient membership checks and set operations.

Domain Modeling (7)

• Avoid Long Chains of .andThen; Use Generators Instead - tags: andThen, generators, readability, composition, anti-pattern
  • summary: Prefer Effect.gen over long chains of .andThen for sequential logic to improve readability and maintainability.
• Define Contracts Upfront with Schema - tags: schema, design, architecture, type-safety, contract-first, data-modeling
  • summary: Use Schema to define the types for your data models and function signatures before writing the implementation, creating clear, type-safe contracts.
• Model Optional Values Safely with Option - tags: option
  • summary: Use Option to explicitly represent a value that may or may not exist, eliminating null and undefined errors.
• Model Validated Domain Types with Brand - tags: branded-types, domain-modeling, type-safety, validation, invariants, data
  • summary: Use Brand to turn primitive types like string or number into specific, validated domain types like Email or PositiveInt, making illegal states unrepresentable.
• Parse and Validate Data with Schema.decode - tags: schema, validation, parsing, data
  • summary: Use Schema.decode(schema) to create an Effect that parses and validates unknown data, which integrates seamlessly with Effect's error handling.
• Transform Data During Validation with Schema - tags: schema
  • summary: Use Schema.transform to safely convert data from one type to another during the parsing phase, such as from a string to a Date.
• Use Effect.gen for Business Logic - tags: generators, business-logic, control-flow, readability
  • summary: Encapsulate sequential business logic, control flow, and dependency access within Effect.gen for improved readability and maintainability.

Error Management (8)

• Accumulate Multiple Errors with Either - tags: either
  • summary: Use Either<E, A> to represent computations that can fail, allowing you to accumulate multiple errors instead of short-circuiting on the first one.
• Define Type-Safe Errors with Data.TaggedError - badges: Domain Modeling
• tags: error-handling, tagged-error, type-safety, Data.TaggedError, errors
  • summary: Create custom, type-safe error classes by extending Data.TaggedError to make error handling robust, predictable, and self-documenting.
• Distinguish 'Not Found' from Errors - tags: option
  • summary: Use Effect<Option> to clearly distinguish between a recoverable 'not found' case (None) and a true failure (Fail).
• Handle Errors with catchTag, catchTags, and catchAll - tags: error-handling, catch, tagged-error, recovery
  • summary: Use catchTag for type-safe recovery from specific tagged errors, and catchAll to recover from any possible failure.
• Handle Flaky Operations with Retries and Timeouts - tags: retry
  • summary: Use Effect.retry and Effect.timeout to build resilience against slow or intermittently failing operations, such as network requests.
• Leverage Effect's Built-in Structured Logging - tags: logging, logger, structured-logging, observability, debug
  • summary: Use Effect's built-in logging functions (Effect.log, Effect.logInfo, etc.) for structured, configurable, and context-aware logging.
• Mapping Errors to Fit Your Domain - tags: error-handling
  • summary: Use Effect.mapError to transform specific, low-level errors into more general domain errors, creating clean architectural boundaries.
• Retry Operations Based on Specific Errors - tags: retry
  • summary: Use Effect.retry and predicate functions to selectively retry an operation only when specific, recoverable errors occur.

Making HTTP Requests (2)

• Create a Testable HTTP Client Service - tags: http-client
  • summary: Define an HttpClient service with separate 'Live' and 'Test' layers to enable robust, testable interactions with external APIs.
• Model Dependencies as Services - badges: Testing
• tags: service, architecture, dependency-injection, layers, testing, decoupling
  • summary: Abstract external dependencies and capabilities into swappable, testable services using Effect's dependency injection system.

Modeling Time (3)

• Accessing the Current Time with Clock - tags: clock
  • summary: Use the Clock service to access the current time in a testable, deterministic way, avoiding direct calls to Date.now().
• Beyond the Date Type - Real World Dates, Times, and Timezones - tags: time
  • summary: Use the Clock service for testable access to the current time and prefer immutable primitives for storing and passing timestamps.
• Representing Time Spans with Duration - tags: duration
  • summary: Use the Duration data type to represent time intervals in a type-safe, human-readable, and composable way.

Observability (6)

• Add Custom Metrics to Your Application - tags: metrics
  • summary: Use Effect's Metric module to instrument your code with counters, gauges, and histograms to track key business and performance indicators.
• Add Custom Metrics to Your Application - badges: Metrics, Monitoring, Performance
• tags: metrics, observability, monitoring, performance, effect
  • summary: Use Effect's Metric module to instrument your code with counters, gauges, and histograms to track key business and performance indicators.
• Instrument and Observe Function Calls with Effect.fn - badges: Instrumentation, Function Calls, Debugging
• tags: Effect.fn, observability, instrumentation, function, logging, metrics, tracing
  • summary: Use Effect.fn to wrap, instrument, and observe function calls, enabling composable logging, metrics, and tracing at function boundaries.
• Leverage Effect's Built-in Structured Logging - badges: Logging, Debugging
• tags: logging, observability, debugging, effect, structured-logging
  • summary: Use Effect's built-in logging functions for structured, configurable, and context-aware logging.
• Trace Operations Across Services with Spans - badges: Tracing, Performance, Debugging
• tags: tracing, spans, observability, performance, debugging, effect
  • summary: Use Effect.withSpan to create custom tracing spans, providing detailed visibility into the performance and flow of your application's operations.
• Trace Operations Across Services with Spans - tags: tracing
  • summary: Use Effect.withSpan to create custom tracing spans, providing detailed visibility into the performance and flow of your application's operations.

Pattern Matching (3)

• Effectful Pattern Matching with matchEffect - badges: Effectful Branching, Error Handling
• tags: matchEffect, pattern-matching, effect, branching, error-handling
  • summary: Use matchEffect to perform effectful branching based on success or failure, enabling rich workflows in the Effect world.
• Handling Specific Errors with catchTag and catchTags - badges: Error Handling, Tagged Unions
• tags: catchTag, catchTags, pattern-matching, effect, error-handling, tagged-union
  • summary: Use catchTag and catchTags to recover from or handle specific error types in the Effect failure channel, enabling precise and type-safe error recovery.
• Matching Tagged Unions with matchTag and matchTags - badges: Tagged Unions, Error Handling, Branching
• tags: matchTag, matchTags, pattern-matching, tagged-union, effect, error-handling, branching
  • summary: Use matchTag and matchTags to pattern match on specific tagged union cases, enabling precise and type-safe branching.

Resource Management (1)

• Create a Service Layer from a Managed Resource - badges: Dependency Injection, Application Architecture
• tags: resource, layer, scope, service, dependency-injection, context, acquire-release
  • summary: Use Layer.scoped with Effect.Service to transform a managed resource into a shareable, application-wide service.

Testing (3)

• Mocking Dependencies in Tests - tags: testing
  • summary: Use a test-specific Layer to provide mock implementations of services your code depends on, enabling isolated and deterministic unit tests.
• Use the Auto-Generated .Default Layer in Tests - tags: testing, service, layers, dependency-injection
  • summary: When testing, always use the MyService.Default layer that is automatically generated by the Effect.Service class for dependency injection.
• Write Tests That Adapt to Application Code - tags: testing, philosophy, best-practice, architecture
  • summary: A cardinal rule of testing: Tests must adapt to the application's interface, not the other way around. Never modify application code solely to make a test pass.

Tooling and Debugging (1)

• Supercharge Your Editor with the Effect LSP - tags: lsp
  • summary: Install the Effect Language Server (LSP) extension for your editor to get rich, inline type information and enhanced error checking for your Effect code.

---

Advanced

Building Data Pipelines (1)

• Manage Resources Safely in a Pipeline - tags: stream
  • summary: Ensure resources like file handles or connections are safely acquired at the start of a pipeline and always released at the end, even on failure.

Concurrency (5)

• Decouple Fibers with Queues and PubSub - tags: queue
  • summary: Use Queue for point-to-point work distribution and PubSub for broadcast messaging to enable safe, decoupled communication between concurrent fibers.
• Implement Graceful Shutdown for Your Application - tags: graceful-shutdown
  • summary: Use Effect.runFork and listen for OS signals (SIGINT, SIGTERM) to trigger a Fiber.interrupt, ensuring all resources are safely released.
• Poll for Status Until a Task Completes - tags: polling
  • summary: Use Effect.race to run a repeating polling effect alongside a main task, automatically stopping the polling when the main task finishes.
• Run Background Tasks with Effect.fork - tags: concurrency
  • summary: Use Effect.fork to start a computation in a background fiber, allowing the parent fiber to continue its work without waiting.
• Understand Fibers as Lightweight Threads - tags: fiber
  • summary: A Fiber is a lightweight, virtual thread managed by the Effect runtime, enabling massive concurrency on a single OS thread without the overhead of traditional threading.

Data Types (1)

• Handle Unexpected Errors by Inspecting the Cause - badges: Error Handling, Debugging, Effect Results
• tags: Cause, error-handling, debugging, effect, failure, data-type
  • summary: Use Cause to get rich, structured information about errors and failures, including defects, interruptions, and error traces.

Error Management (1)

• Handle Unexpected Errors by Inspecting the Cause - tags: error-handling, cause, exit, defect, die, unexpected-error, runtime
  • summary: Use Effect.catchAllCause or Effect.runFork to inspect the Cause of a failure, distinguishing between expected errors (Fail) and unexpected defects (Die).

Making HTTP Requests (2)

• Add Caching by Wrapping a Layer - tags: caching
  • summary: Implement caching by creating a new layer that wraps a live service, intercepting method calls to add caching logic without modifying the original service.
• Build a Basic HTTP Server - tags: http
  • summary: Combine Layer, Runtime, and Effect to create a simple, robust HTTP server using Node.js's built-in http module.

Observability (1)

• Integrate Effect Tracing with OpenTelemetry - badges: Tracing, OpenTelemetry, Distributed Systems
• tags: tracing, opentelemetry, observability, effect, distributed-tracing
  • summary: Connect Effect's tracing spans to OpenTelemetry for end-to-end distributed tracing and visualization.

Project Setup & Execution (3)

• Create a Managed Runtime for Scoped Resources - badges: Making HTTP Requests, Resource Management
• tags: runtime, scope, resource-management, layers, scoped, finalizer, launch
  • summary: Use Layer.launch to safely manage the lifecycle of layers containing scoped resources, ensuring finalizers are always run.
• Create a Reusable Runtime from Layers - tags: runtime, layers, execution, dependency-injection, performance
  • summary: Compile your application's layers into a reusable Runtime object to efficiently execute multiple effects that share the same context.
• Execute Long-Running Apps with Effect.runFork - tags: runFork
  • summary: Use Effect.runFork at the application's entry point to launch a long-running process as a detached fiber, allowing for graceful shutdown.

Resource Management (2)

• Manage Resource Lifecycles with Scope - tags: scope
  • summary: Use Scope for fine-grained, manual control over resource lifecycles, ensuring cleanup logic (finalizers) is always executed.
• Manually Manage Lifecycles with Scope - badges: Advanced Dependency Injection, Custom Layers
• tags: resource, scope, finalizer, layer, advanced, lifecycle
  • summary: Use Scope directly to manage complex resource lifecycles or when building custom layers.

Testing (1)

• Organize Layers into Composable Modules - tags: layer
  • summary: Structure a large application by grouping related services into 'module' layers, which are then composed together with a shared base layer.

Tooling and Debugging (1)

• Teach your AI Agents Effect with the MCP Server - tags: mcp
  • summary: Use the Effect MCP server to provide live, contextual information about your application's structure directly to AI coding agents.

---

Notes:

• Primary useCase is the first element in the useCase array.
• Remaining useCase values appear as badges under each item.
• Ordering within each bucket is title A–Z.