effect.website Open in urlscan Pro
2606:4700:3031::6815:45bd  Public Scan

Form analysis
0 forms found in the DOM

Text Content

Get your ticket for Effect Days 2024 in Vienna, Austria →

DocumentationDocumentationExamplesExamplesEffect DaysEffect Days (opens in a new
tab)
CTRL K
GitHubGitHub (opens in a new tab)DiscordDiscord (opens in a new tab)
CTRL K
 * Documentation
    * Introduction
    * Why Effect?
    * Getting Started
    * Quickstart
    * Guides
    * Effect Essentials
       * Importing Effect
       * The Effect Type
       * Creating Effects
       * Running Effects
       * Using Generators
       * Building Pipelines
   
    * Error Management
       * Two Types of Errors
       * Expected Errors
       * Unexpected Errors
       * Fallback
       * Matching
       * Retrying
       * Timing Out
       * Sandboxing
       * Error Accumulation
       * Error Channel Operations
       * Parallel and Sequential Errors
       * Yieldable Errors
   
    * Context Management
       * Managing Services
       * Managing Service Dependencies (Layers)
       * Default services
       * Dependency Memoization
   
    * Resource Management
    * Observability
       * Logging
       * Supervisor
       * Telemetry
          * Introduction to Telemetry
          * Metrics
          * Tracing
   
    * Configuration
    * Introduction to Runtime
    * Scheduling
       * Introduction to Scheduling
       * Repetition
       * Built-in Schedules
       * Schedule Combinators
   
    * State Management
       * Ref
       * SynchronizedRef
   
    * Batching & Caching
    * Concurrency
       * Concurrency Options
       * Fibers
       * Interruption Model
       * Deferred
       * Queue
       * PubSub
       * Semaphore
   
    * Streaming
       * Stream
          * Introduction to Streams
          * Creating Streams
          * Resourceful Streams
          * Operations
          * Consuming Streams
          * Error Handling
          * Scheduling
      
       * Sink
          * Introduction to Sinks
          * Creating Sinks
          * Sink Operations
          * Parallel Operators
          * Leftovers
      
       * SubscriptionRef
   
    * Testing
       * TestClock
   
    * Control Flow
    * Code Style
       * Dual APIs
       * Branded Types
       * Pattern Matching
       * Simplifying Excessive Nesting
   
    * Integrations
    * Express
    * Concepts
    * Immutability
    * What is Dependency Injection?
    * Other
    * FAQ
    * Glossary
    * Data types
       * Cause
       * Chunk
       * Data
       * Duration
       * Either
       * Exit
       * Option
   
    * Traits
       * Equal
       * Hash
   
    * Behaviours
       * Equivalence
       * Order
       * Higher-Kinded Types
   
    * API Reference
       * effect ↗ (opens in a new tab)
       * @effect/cli ↗ (opens in a new tab)
       * @effect/match ↗ (opens in a new tab)
       * @effect/opentelemetry ↗ (opens in a new tab)
       * @effect/platform ↗ (opens in a new tab)
       * @effect/printer ↗ (opens in a new tab)
       * @effect/schema
          * Getting Started ↗ (opens in a new tab)
          * API Reference ↗ (opens in a new tab)
   
    * Coming From ZIO
    * Effect vs fp-ts
    * Effect vs Promise

 * Examples
    * Node Scripts
    * Starter
    * Starter Vite Tsc

 * Effect Days (opens in a new tab)

System




WELCOME TO EFFECT

Effect is a powerful TypeScript library designed to help developers easily
create complex, synchronous, and asynchronous programs.

One of the key features that sets Effect apart is how it leverages structured
concurrency (opens in a new tab) to provide features such as async cancellation
and safe resource management, making it easier to build robust, scalable, and
efficient programs.

Quickstart


Some of the main Effect features include:

FeatureDescriptionConcurrencyAchieve highly-scalable, ultra low-latency
applications through Effect's fiber-based concurrency
model.ComposabilityConstruct highly maintainable, readable, and flexible
software through the use of small, reusable building blocks.Resource
SafetySafely manage acquisition and release of resources, even when your program
fails.Type SafetyLeverage the TypeScript type system to the fullest with
Effect's focus on type inference and type safety.Error HandlingHandle errors in
a structured and reliable manner using Effect's built-in error handling
capabilities.AsynchronicityWrite code that looks the same, whether it is
synchronous or asynchronous.ObservabilityWith full tracing capabilities, you can
easily debug and monitor the execution of your Effect program.

We are working hard to create comprehensive and approachable documentation that
will guide you through various aspects of using Effect. We hope that you will
find what you are looking for here - but if you don't, reach out to us on
Discord (opens in a new tab) or Twitter (opens in a new tab)!

Last updated on November 4, 2023
System

--------------------------------------------------------------------------------

MIT 2023 © Effectful Technologies Inc.