zio/zio

Features

• Effect Modeling - Models computations as pure, composable values with typed errors and dependencies.
• Fiber-Based Concurrent Execution - Runs millions of lightweight, non-blocking fibers with structured lifecycle management.
• Schedule-Based Repetitions - ZIO re-executes a successful effect at intervals defined by a configurable schedule, continuing until the schedule halts.
• Schedule-Based Retries - ZIO re-attempts a failed effect at intervals defined by a configurable schedule, continuing until the schedule halts or the effect succeeds.
• Channel FlatMap Sequencings - Provides flatMap-based channel sequencing that uses completion values to determine the next channel.
• Terminal Value Channel Sequencings - Uses the completion value of one channel to determine the next channel to execute.
• Inner Channel Concatenations - Flattens channels that emit other channels into a single sequential output stream.
• Sequential Channel Pipings - Pipes output from one channel as input to the next, enabling sequential data transformation.
• Sequential Channel Zippings - Combines two channels sequentially, pairing their outputs into a tuple.
• Concurrent Stream Merging - Implements concurrent merging of multiple channels, emitting values as they become available.
• Schedule Composition - ZIO combines multiple schedules using combinators to create complex timing policies for repeating or retrying effects.
• Automatic Resolution & Parallel Initialization - Application dependencies are constructed as typed layers that compose horizontally and vertically, with automatic resolution and parallel initialization at startup.
• Infallible Dependency Layers - ZIO constructs a reusable dependency that requires no inputs and cannot fail, producing a service for injection into an application.
• Layer-Based Graph Constructions - ZIO constructs the application's dependency graph by composing ZLayer values manually or automatically to satisfy service requirements.
• Retry-on-Change Coordination - Aborts and re-executes a transaction when a condition is unmet, retrying only after underlying data changes.
• Software Transactional Memory Retries - ZIO automatically re-executes a transaction from the start when a conflicting change is detected, ensuring eventual success without busy-waiting.
• Sequential Channel Map Concatenations - Maps each element to a new channel and concatenates the inner channels in order.
• Atomic Transaction Execution - Executes blocks of operations as atomic, indivisible units with automatic rollback on failure.
• Stream Processing - Provides asynchronous stream processing for handling continuous data flows without blocking.
• Transactional Data Structures - ZIO provides transactional data structures like references, queues, maps, and arrays that participate in atomic, lock-free concurrent operations.
• Scoped Context Managers - ZIO scopes a capability like file access or state to a specific region of code and eliminates it automatically when the region completes.
• Parallel Channel Map Merges - Maps each element to a new channel and runs all inner channels concurrently, merging their outputs.
• Environment Service Accessors - ZIO reads a specific member of a service from the environment, returning either a plain value or an effectful result.
• Reactive Stream Processing - Provides pull-based reactive streams with integrated backpressure and composable sinks.
• Service Lifecycle Managers - ZIO controls the creation and release lifecycle of services, ensuring proper resource cleanup.
• Messaging Queues - ZIO transfers data between concurrent producers and consumers using an asynchronous, non-blocking queue.
• Infallible Stream Definitions - Provides infallible stream creation as a fundamental part of its reactive stream processing capabilities.
• Infallible Effect Aliases - Provides a type alias for effects that cannot fail and require no environment.
• Combined Filtering and Transformation - Provides a combined filtering and transformation operation on stream elements via pattern matching.
• Pull-Based Processing - Streams emit elements on demand with integrated backpressure, using a pull model where consumers control the flow and producers respond to downstream demand.
• Effect Zipping - Zips two effects into a tuple, combining their success values while preserving error handling.
• Effect-Based - ZIO starts an application from a main entry point, executing the top-level effect and managing the runtime lifecycle.
• Task Racing - Runs two effects in parallel and returns the first successful result.
• Compile-Time Dependency Resolution - ZIO verifies all required services are provided during compilation, preventing runtime errors from missing dependencies.
• Configuration Readers - ZIO reads configuration values of common types like integers, strings, and booleans from environment variables and system properties.
• Horizontal Layer Compositions - Provides horizontal layer composition as a fundamental part of its dependency injection system.
• Non-Blocking Sleep - Provides a non-blocking sleep primitive that pauses fibers without blocking threads.
• Parallel Task Execution - Executes multiple effects concurrently and combines results, interrupting on failure.
• Service Dependency Wiring - Provides a type-safe, layer-based dependency injection system for composing service dependencies.
• Pure Interface Definitions - ZIO defines service traits that never include implementation dependencies in their type signature, keeping the interface pure and reusable.
• Typed Service Recipes - ZIO assembles a service from its required inputs using a typed recipe that can produce the service or fail during construction.
• Stream Retries - Provides mechanisms for resetting data streams and restarting requests when network errors occur.
• Fiber-Based Background Tasks - Forks fibers to run tasks in the background, returning handles for awaiting or cancellation.
• Fiber Terminations - Terminates a fiber immediately with guaranteed resource cleanup.
• Safe Fiber Interruptions - Provides a safe, reliable mechanism for terminating running fibers.
• Interface-Based Decoupling - ZIO programs to interfaces rather than concrete classes so different implementations can be swapped in without changing dependent code.
• Type-Level Dependency Declarations - Declares service dependencies at the type level for compile-time safety and automatic tracking.
• Resilient Application Patterns - Provides application-level patterns that use automatic retries to handle intermittent failures in logic.
• Environment Service Retrieval - Retrieves service implementations from the execution environment using type-safe accessors.
• In-Memory Queue Capacity Strategies - ZIO creates bounded or unbounded queues with back-pressure, dropping, or sliding strategies to manage memory and flow.
• Sequential - Chains effects sequentially with flatMap, passing results and short-circuiting on failure.
• In-Memory Publish-Subscribe Hubs - ZIO publishes values from one or more producers to many subscribers through an asynchronous, non-blocking message hub.
• In-Memory Queue Batch Enqueueing - ZIO adds multiple values to a queue in a single operation, suspending only when the queue is full.
• Callback Wrapping - ZIO wraps legacy callback-based asynchronous code into a composable effect that supports error handling and for-comprehension syntax.
• Daemon Fibers - Spawns fibers that run as daemons, outliving their parent scope until application shutdown.
• Blocking I/O Offloading - Ships a dedicated blocking thread pool to offload synchronous I/O and CPU-heavy calls.
• Concurrency Primitives - Provides low-level synchronization primitives like semaphores and mutexes for building concurrent applications.
• Effectful Comprehensions - Enables imperative-style composition of asynchronous effects using Scala's for-comprehension syntax.
• Untyped Defect Terminations - Provides a mechanism to immediately terminate an effect with an untyped defect for non-recoverable errors.
• Typed Failure Recovery - Attempts a primary effect and runs a fallback effect to produce a result when the primary fails.
• Effectful Stream Modeling - Models streams as effectful programs that emit values with typed errors and environment requirements.
• Infallible Effect Execution - Executes effects with a Nothing error type, guaranteeing at compile time that no error will occur.
• Infallible Effect Execution with Environment - Executes infallible computations that require an environment, guaranteeing no failure.
• Custom Environment Execution - ZIO builds a runtime that holds a user-supplied environment and uses it to execute effects that depend on that context.
• Effect Repetition Policies - Re-executes a failing effect according to a configurable schedule until success or policy exhaustion.
• Fixed Count Repetitions - ZIO repeats an effect a specified number of times and then stops.
• Infinite Repetitions - ZIO repeats an effect indefinitely, producing the current repetition count.
• Transparent Async Composition - ZIO writes sequential-looking code that transparently handles both synchronous and asynchronous execution paths.
• Fiber-Based Virtual Threads - Executes lightweight virtual threads that scale to hundreds of thousands of instances.
• Fiber Executions - Launches lightweight fibers that execute tasks in parallel with safe concurrency guarantees.
• Fiber Lifecycle Managers - Manages concurrent work units as fibers with supervision, interruption, and composition.
• Typed Concurrent Computations - Models concurrent work with typed error and success values for safe composition.
• Lazy Effect Modeling - Represents programs as lazy data structures that describe computations, interpreted later by a runtime.
• Service Layer Initializers - Provides parallel initialization of service layers to shorten application startup time.
• Program Entry Points - ZIO defines a class with a run method that the JVM calls automatically, turning a ZIO effect into a standalone executable.
• Runtime Effect Execution - Implements operators that directly execute side effects when called, producing results immediately.
• Default Runtime Execution - ZIO creates a runtime from a shared default and calls its synchronous or asynchronous execution methods to run effects anywhere in legacy code.
• Transactional Alternatives - Provides compositional alternative logic for STM transactions, falling back on retry.
• Service Replacements - Provides service replacement within dependency injection layers as part of its DI system.
• Dependency Requirement Pass-Through - Preserves intermediate service dependencies through composed layers in its dependency injection system.
• Algebraic Data Types - Models domain data using product and sum types for type-safe, boilerplate-free representations.
• Type-Level Service Maps - Maintains a type-safe mapping from service interfaces to implementations for on-demand retrieval.
• Asynchronous Service Initialization - ZIO creates service instances from asynchronous or effectful computations using ZLayer.fromZIO or ZLayer.apply.
• Asynchronous Workflow Management - Describes a unit of computation as a typed blueprint that either fails with an error or succeeds with a value.
• Transactional Memory Compositions - Combines multiple memory operations into atomic, isolated units for lock-free concurrent state management.
• Concurrency Semaphores - ZIO limits concurrent access to a resource by acquiring and releasing permits, suspending fibers when permits are unavailable.
• Fiber Context Propagation - ZIO passes the parent fiber's FiberRef value to a newly forked child, giving it an independent copy to modify.
• FiberRef State Inheritances - ZIO preserves the parent fiber's current FiberRef value in child fibers, keeping the ThreadLocal synchronized for each forked fiber.
• Fiber Data Exchange - ZIO transfers values between concurrent fibers through an in-memory queue with back-pressure, offer, and take operations.
• Fiber Interruptions - Provides non-blocking fiber interruption that lets the caller proceed immediately.
• Fiber Outcome Capture - Retrieves the full exit status of a fiber, distinguishing success, failure, and interruption.
• Promise-Based - ZIO allows one fiber to produce a value that many other fibers can await, enabling safe one-time synchronization points.
• Concurrent Effect Combinators - Builds complex concurrent logic by combining small transactional steps with combinators.
• Conditional Retry Policies - Repeats a failing effect until its error satisfies a predicate, with optional effectful checks.
• Predicate-Based Retries - Provides a retry mechanism that repeats a failing effect while its error satisfies a predicate.
• Constructor Injection - ZIO accepts all service dependencies through the class constructor rather than pulling them from the environment at runtime.
• Effectful Constructor Wiring - ZIO passes dependencies into a service's class constructor and creates a ZLayer that effectfully retrieves those dependencies from the environment.
• Contextual Capability Composition - ZIO combines workflows that require local capabilities as first-class values that naturally compose without explicit parameter passing.
• Domain Type Definitions - Extracts core domain models and packages them with orthogonal operators into single data types.
• Dynamic Dependency Overriding - ZIO replaces a subset of global dependencies for a specific part of the application, similar to method overriding in OOP.
• Global Dependency Provision - ZIO supplies all required services to the entire application at once at the program's entry point.
• Dependency-Free Stream Definitions - Provides dependency-free stream creation as a fundamental part of its reactive stream processing capabilities.
• Deterministic Simulation Environments - Ships a deterministic simulation environment with controlled time and injectable services.
• Domain Error Mapping - Provides translation of error types between different logical domains to ensure exhaustive failure handling.
• Dual-Channel Error Models - Expected business failures and unexpected system defects are separated into distinct type channels, enabling compile-time tracking and targeted recovery without exception handling.
• Channel Type Conversions - Ships a full set of channel-to-stream, channel-to-sink, and channel-to-queue conversions for interoperability.
• Effect State Management - ZIO reads and writes a typed value during an effect's execution, providing a state monad-like experience built on fiber-local storage.
• Effectful State Updates - Enables atomic state changes that depend on side effects like database queries within functional effects.
• Expected and Unexpected Failure Separation - Separates recoverable errors from unrecoverable defects at compile time using a dual-channel model.
• Defect Signaling - Provides mechanisms for triggering untyped errors that bypass standard recovery channels to indicate non-recoverable system failures.
• Expected Error Handling - Provides expected error handling to catch and recover from anticipated failures using typed channels.
• Defect to Failure Conversion - Converts untyped system defects into typed failures for recovery within the effect system.
• Defect Sandboxing - Provides defect sandboxing to isolate unrecoverable failures within bounded application regions.
• Fallback Defect Unrefinement - Provides fallback defect unrefinement to convert selected defects into typed errors with a fallback mapping.
• Failure to Defect Conversion - ZIO translates an effect's typed failure into an unchecked defect that terminates the running fiber, for errors that cannot be recovered from.
• Defect to Typed Error Unrefinement - Ships a mechanism to convert specific defects into typed, recoverable errors.
• Error Type Transformations - Ships error type transformations to align error types across composed effects.
• Exhausted Retry Fallbacks - Runs a fallback effect when all retry attempts fail, using the last error and schedule output.
• Error Type Refinement - Provides filtering logic that allows specific error types to propagate while terminating the fiber for others.
• Effect Error to Either Exposures - Converts a fallible effect into an infallible one that produces a Scala Either, moving errors into the success channel.
• Cumulative Error Collection - Runs effects concurrently and gathers all failures into a combined cause without interrupting other effects.
• Error Propagation Systems - Implements typed error propagation through effect pipelines without handling.
• Error Recovery - Provides error recovery with retry, fallback, and alternative logic for declared failures.
• All Error Catchers - Catches every recoverable error from an effect and runs a fallback effect, potentially changing the error type.
• Specific Error Catchers - Catches only specific types of recoverable errors from an effect and runs a fallback effect for those cases.
• Success and Failure Processing - Provides operators that consume both success and failure channels of an effect to determine a final result.
• Failure Cause Extraction - Provides extraction of the detailed cause of a failure from the error channel into the success channel for analysis.
• All Cause Recoveries - Provides operators that catch failures, defects, and fiber interruptions together and run a fallback effect.
• Error Cause Mapping - Provides error cause mapping to transform failure causes without exposing them in the success channel.
• Failure-to-Success Lifting - Lifts potential failures into the success channel as Either values, making effects infallible.
• Fiber Lifecycle Management - ZIO monitors the creation and termination of fibers, collecting their status into a visible value for inspection.
• Fiber Result Awaiting - Waits for a forked fiber to complete and retrieves its success value.
• Fiber-local State Management - Isolates state per lightweight fiber to prevent interference between concurrent execution units.
• Fiber State Merging - ZIO combines a child fiber's state with its parent's state when the child fiber joins, using a merge strategy defined by the state type.
• Cross-Fiber State Sharings - Provides mutable references that multiple concurrent fibers can safely read and update.
• Automatic Graph Resolutions - ZIO assembles a tree of service layers by declaring their inter-dependencies, then resolves the graph automatically at startup.
• Composable Graph Operators - ZIO combines service constructors with operators like ++ and >>> to build typed, composable dependency graphs.
• Effectful Dependency Builders - ZIO uses ZLayer to create services that require effectful initialization, supporting concurrency and resource safety during construction.
• Macro-Based Graph Resolvers - ZIO generates the full dependency graph from provided layers using macros, eliminating manual assembly of services.
• Automatic Layer Resolutions - ZIO combines multiple service layers into a single dependency graph that resolves automatically at startup.
• Layered - ZIO constructs higher-level services from lower-level ones using a layered dependency injection mechanism that hides implementation details.
• Test Service Injections - Swaps real service dependencies with test implementations for deterministic, type-safe testing.
• Service Layer Composition - Provides a type-safe, composable layer system for wiring service dependencies.
• Resource Acquisition and Release - Guarantees resource acquisition and release even on failure, interruption, or defects.
• Composable Scopes - Provides composable scoped resource handles with guaranteed cleanup on scope exit.
• Scoped Resource Lifting - ZIO acquires and releases resources safely by lifting scoped ZIO effects into layers with ZLayer.scoped.
• Resource Lifecycle Management - Defines resource lifetimes through scopes with guaranteed finalizer cleanup on scope close.
• Resource Management Patterns - Automatically acquires and releases resources to prevent leaks on failure or interruption.
• Guaranteed Finalizers - Guarantees cleanup actions execute when a fiber finishes or is interrupted.
• Automatic Computation Cancellation - Automatically cancels fibers whose results are no longer needed, preventing resource leaks.
• Layer-Based Configuration Overrides - ZIO overrides runtime configuration for a region of code by providing configuration layers through provideXYZ operators.
• Service Implementation Overriding - ZIO supplies distinct concrete instances of the same abstract service to different consumers within the same application.
• Interface-Based Service Swapping - ZIO defines service interfaces and injects different concrete implementations through layers, enabling modular and testable code without changing application logic.
• Fallible Effect Execution with Environment - Executes fallible effects that require an environment, handling errors and dependencies.
• Fallible Task Execution - Runs fallible tasks with no dependencies, simplifying error handling for general-purpose workflows.
• Discarding Side Effects - Provides operators to zip effects while discarding the result of one side.
• Recursive State Passing - Passes updated state as arguments to recursive function calls, eliminating mutable variables.
• Software Transactional Memory - Atomic, lock-free transactions compose memory operations across fibers with automatic retry on conflict, providing consistent shared state without manual synchronization.
• Fiber Execution Scopes - Attaches fibers to scopes that outlive parents but terminate when the scope closes.
• Global Daemon Fibers - Forks fibers in the global scope that persist until application shutdown.
• Parent-Scoped Child Fibers - Automatically interrupts child fibers when the parent completes, preventing leaks.
• Stream Failure Recovery - Provides mechanisms for handling errors during asynchronous data stream processing by switching to fallbacks.
• Success Value Filtering - Applies a pure function to the success value of an effect, producing a new effect with the transformed result.
• Type-Safe Dependency Resolution - Wires service layers into a composable dependency graph resolved at compile time.
• Effect-Typed Dependency Injections - Services are wired into a composable graph resolved at compile time through type-safe layers that track dependencies in the effect's environment type parameter.
• Typed Error Management - ZIO catches and recovers from typed errors in a ZIO effect, allowing the program to continue with an alternative value or effect.
• Uninterruptible Critical Sections - Prevents fiber interruption during critical sections, delaying interruption until completion.
• Service Layer Initializers - Provides parallel initialization of service layers to shorten application startup time.
• Application Metric Tracking - ZIO captures counters, gauges, histograms, summaries, and frequencies as ZIO aspects to monitor application health and performance.
• Automatic Error Logging - ZIO logs every error that escapes a ZIO effect through the runtime system, and allows a custom logging backend to intercept and format those errors.
• Effect Timeouts - Ships a built-in timeout mechanism that interrupts effects exceeding a configurable duration.
• Full Cause Inspectors - Provides operators that inspect the complete cause of a failure including typed errors, defects, and interruptions.
• All Failure Cause Inspectors - ZIO exposes the full cause of an effect—failure, defect, or interruption—as typed data so each can be handled separately.
• Channel Executors - Provides channel execution primitives that return only the done value.
• Channel Output Collectors - Provides channel output collection returning both values and done value.
• Blocking Code Offloading - Offloads blocking operations to a dedicated thread pool to keep the main fiber pool responsive.
• Blocking Work Offloaders - ZIO runs CPU-heavy or blocking input/output tasks on a separate thread pool so they do not slow down the main execution threads.
• Retry Policies - Retries failed dependency layer construction with configurable schedules for resilience.
• Failure Trace Handlers - Provides operators that access the execution trace alongside the failure value for context-aware error handling.
• Stream Separator Insertions - Provides stream operators that insert separators between elements.
• Collection Element Transformations - Provides collection element transformations that filter and map elements in a single step.
• Channel Element Collectors - Provides channel element collection into a single output or terminal value.
• Collection Constructions - Constructs immutable collections from arrays, iterables, or filling functions without boxing.
• Timeout Result Producers - ZIO returns a user-specified value instead of None when an effect times out, allowing flexible result types.
• Patch-Based Concurrent Updates - ZIO uses a Differ to combine independent modifications from multiple fibers into a single, conflict-free result.
• Channel Output Buffers - Provides configurable output buffering for channel data flow.
• Batch Stream Processors - Provides batch stream processing that handles elements as chunks for performance.
• Scoped Channel Executions - Executes channels within scopes to ensure finalizers run before channel closure.
• Stream Deduplication - Provides stream deduplication by tracking seen values and passing only unique items downstream.
• Recursive Channel Composers - Provides recursive channel composition for building complex streaming pipelines.
• Deep Equality Checks - Checks whether two collections contain the same elements in the same order using structural equality.
• Automatic Resource Replacement - Provides atomic scoped references that automatically release old resources on update.
• Safe Swaps - Swaps resources safely in an uninterruptible block, releasing old only after new acquisition.
• Fiber-Safe Counters - ZIO creates a thread-safe counter that multiple fibers can increment and decrement atomically without race conditions.
• Concurrent Sink Racing - Provides concurrent sink racing that returns the result of the first sink to complete.
• Fibonacci Delay Repetitions - ZIO repeats an effect with delays that grow according to the Fibonacci sequence.
• Stream Fan-Outs - Provides stream broadcasting with backpressure to multiple consumers.
• Transactional Hubs - Publishes messages to a hub within STM transactions, ensuring atomic delivery to all subscribers.
• Transactional Subscriptions - Subscribes to a transactional hub to receive messages as a stream within STM transactions.
• Reentrant Locks - Acquires reentrant locks that the same fiber can re-enter multiple times.
• Non-Blocking Lock Attempts - Attempts to acquire locks without blocking, returning immediately with success or failure.
• Reentrant Lock Releases - Releases reentrant locks, decrementing hold counts and waking waiting fibers.
• Deterministic Time Simulation - The testing environment provides a virtual clock that controls time passage, enabling deterministic validation of asynchronous logic and schedule-based effects without real delays.
• Callback-to-Effect Adapters - Wraps callback-based asynchronous APIs into composable effects with error handling.
• Custom Runtime Builds - ZIO builds a custom top-level runtime by unsafely converting a configuration layer for full application-wide customization.
• Pure Value Effects - Lifts pure values and lazy expressions into the effect system for uniform composition.
• Fixed Delay Repetitions - ZIO repeats an effect continuously with a fixed delay between each execution.
• Fixed Interval Repetitions - ZIO repeats an effect at a constant time interval, producing the count of repetitions so far.
• Effect Type Conversions - Converts standard functional types like Either into managed asynchronous effects.
• Exponential Backoff Retries - Implements exponential backoff retry with configurable schedules and optional time limits.
• Fiber-Based - ZIO configures the runtime to use Java virtual threads for the main executor or the blocking executor on JDK 21+.
• Fiber Status Inspections - ZIO checks whether a fiber is done, running, or suspended to understand its execution state.
• Collection Format Conversions - Transforms immutable collections into mutable arrays or standard sequences for interoperability.
• Unsafe Effect Execution - ZIO executes a ZIO effect by feeding it directly into the runtime's unsafe run method for integrating with legacy code.
• Stream Sinks - Provides stream sinks that process all elements and produce a final result.
• Parallel Sink Processing - Provides parallel sink processing with concurrent execution and result aggregation into tuples.
• Conditional Element Droppings - Removes elements from the start of a collection based on count or a predicate.
• Atomic MVar Updates - Provides atomic updates on single-element blocking buffers for fiber synchronization.
• Automatic Permit Management - Automatically acquires and releases permits for concurrency control within functional effects.
• Transactional Permit Acquisitions - ZIO acquires and releases permits atomically within a single transaction to coordinate access to a shared resource.
• Automatic Permit Wrapping - Wraps arbitrary actions with automatic permit acquisition and release to prevent manual errors.
• Fiber Synchronization - Synchronizes fibers with single-element buffers that block on put when full and take when empty.
• Execution Coordination - Coordinates fibers with latches that block until a signal is received.
• Permit-Based Fiber Blocking - Suspends fibers when permits are unavailable and resumes them once permits become free.
• Channel Pipers - Provides channel piping for sequential data transformation and flow.
• Channel Readers - Provides channel primitives for reading data from input ports.
• Channel Writers - Provides channel primitives for writing data to output ports.
• Unique Instance Provisioning - Supports creating fresh, independent instances of dependencies on demand.
• Selective Defect Resurrections - ZIO converts only die causes into typed failures, leaving interruptions untouched for separate handling.
• Partial Function Unrefinements - ZIO converts selected defects into typed errors using a partial function, leaving unmatched defects unrecoverable.
• Error Channel Chaining - Provides operators for chaining effects on the error channel, enabling error-driven workflows.
• Fatal Error Handlers - Provides specialized logic for managing critical system failures and forced shutdowns.
• Partial Function Refinements - ZIO converts selected typed errors into defects using a partial function, keeping only matched errors in the typed channel.
• Stream Error Type Conversion - Ships built-in conversion between stream-level error channels and value-level error types like Either.
• Sequential Error Collections - ZIO combines failures from multiple chained effects into a single cause instead of stopping at the first error.
• Timeout Error Producers - ZIO produces a specific error or failure cause when an effect exceeds its time limit, enabling precise error handling.
• Stream Merging - Provides deterministic stream interleaving operators that alternate elements in a fixed order.
• Cause Exposure Reversals - Provides operators that restore a cause from the success channel back to the error channel.
• Success and Failure Partitioning - ZIO separates the outcomes of an effectful transformation into a tuple of collected errors and successes without failing the overall effect.
• Either Submersions - ZIO converts an Either value in the success channel back into a potential failure in the error channel.
• Fiber Failure Tracing - Captures the complete chain of errors, defects, and interruptions that caused a fiber to fail.
• Keyed Resource Pools - Manages reusable resource pools indexed by keys with retrieval and invalidation per key.
• Dynamic-Size Pools - Creates dynamic-size keyed resource pools with idle expiration and configurable limits.
• Fixed-Size Pools - Creates fixed-size keyed resource pools with per-key capacity configuration.
• Singleton Instance Sharing - Reuses a single dependency instance across all consumers to avoid redundant initialization.
• Multiple Permit Acquisitions - Acquires multiple permits atomically before task execution and releases them automatically.
• Bounded Stream Buffers - Provides bounded stream buffering with backpressure between producers and consumers.
• In-Memory Communication Channels - Implements in-memory communication channels with backpressure for producer-consumer data exchange.
• Execution Order Controls - Controls finalizer execution order with reverse acquisition or parallel execution options.
• Scoped Lock Execution - Acquires locks for scoped effects and automatically releases them when the scope ends.
• Scoped Service Instances - Creates isolated service instances to prevent shared mutable state across consumers.
• Fallback Policies - Switches to alternative service implementations when primary dependency layers fail.
• Side-Channel Data Accumulation - Provides side-channel data accumulation for tracking state across channel operations.
• Synchronous Effect Wrapping - Wraps synchronous code that may throw exceptions into safe, composable effects.
• Stack Trace Recoveries - ZIO catches a typed error along with its stack trace and runs a fallback effect that can inspect the trace.
• Lifetime Extensions - Extends resource lifetimes across scopes by providing scoped workflows without immediate closure.
• Stream Aggregation - Groups stream elements into batches, balancing throughput and latency with configurable schedules.
• Synchronous Aggregators - Provides synchronous stream aggregation using transducers for batching.
• Stream Element Consumption - Provides stream sinks that consume elements and produce a final result.
• Stream Element Debouncing - Provides stream debouncing that suppresses elements followed by another within a time window.
• Stream Element Distribution - Ships a stream element distribution primitive that routes elements to downstream queues via a decision function.
• Distinct Element Filtering - Provides stream operators that filter out consecutive duplicate elements based on equality.
• Predicate-Based Filters - Provides stream filtering operators that keep elements matching a predicate.
• Stream Element Grouping - Provides stream element grouping by key-extraction functions.
• Stream Element Limiting - Provides stream element limiting operators for taking or skipping elements.
• Element Batching - Provides stream element batching grouped by size or time intervals.
• Element Mappings - Provides stream element transformation via pure or effectful functions.
• Stream Element Observation - Provides stream observation that runs side-effects on each element without altering the stream.
• Emission Timeouts - Provides time-based constraints on the production of elements within a data stream, failing or switching sources on timeout.
• Stream Output Discarding - Provides stream output discarding that executes effects while removing all values.
• Stream Splitting - Ships a stream splitting operator that divides a stream by a predicate.
• Stream State Accumulation - Provides stream state accumulation that emits every intermediate fold result.
• Multi-Level Message Emission - ZIO emits log entries at debug, info, warning, error, or fatal severity so developers can filter messages by importance.
• Fiber Supervision - ZIO attaches a supervisor to a ZIO effect so that all child fibers report their lifecycle events to it.
• Fiber-Scoped - ZIO attaches custom key-value pairs to log entries to correlate messages across fibers or services.
• Metric Tagging Utilities - ZIO attaches key-value pairs to a metric so it can be sliced, filtered, and aggregated by those dimensions in monitoring dashboards.
• JVM Metrics Collectors - ZIO collects standard JVM metrics such as memory usage, garbage collection, thread counts, and class loading for monitoring.
• Multi-Backend Metric Exporters - ZIO sends captured metric snapshots to external services like Prometheus, Datadog, New Relic, or StatsD for centralized analysis.
• Prometheus-Formatted HTTP Endpoints - ZIO exposes collected JVM metrics as a Prometheus-formatted endpoint for external scraping and monitoring.
• Distributed Tracing - ZIO traces a request's path through multiple services in a distributed system to identify bottlenecks and latency hotspots.
• Automatic Span Timing - ZIO measures the duration of a named code block and includes the elapsed time in every log entry emitted inside it.
• Test Retry Strategies - Re-executes failing tests up to a configurable number of times to tolerate intermittent failures.
• Test Environment Provisioning - Sets up a controlled test environment with configurable services and dependencies for isolation.
• Parallel Test Execution - Executes all tests within a suite concurrently to reduce total execution time.
• Stream Combinators - Provides stream concatenation and flattening operators for sequential composition.
• Effect State Inspection - Inspects the outcome of an effect as either a success value or a failure with a full cause chain.
• Stream Error Cleanups - Provides operators for running cleanup side-effects when a stream fails, without altering the stream's output.
• Schedule-Based - ZIO re-executes a successful effect on a schedule, but runs a fallback handler if the schedule itself fails.
• Test Aspects - Provides reusable test aspects that modify test behavior without changing test logic.
• Functional Reactive Programming - Type-safe library for async and concurrent programming.

Star history