# ZIO — Type-Safe Asynchronous Programming Library for Scala

> A zero-dependency Scala library for building concurrent, resilient applications with composable effects, typed errors, and safe resource management.

## Install

Save as a script file and run:

# ZIO — Type-Safe Asynchronous Programming Library for Scala

## Quick Use
```scala
// build.sbt
libraryDependencies += "dev.zio" %% "zio" % "2.1.16"
```
```scala
import zio._

object MyApp extends ZIOAppDefault {
  val run = for {
    _ <- Console.printLine("What is your name?")
    name <- Console.readLine
    _ <- Console.printLine(s"Hello, $name!")
  } yield ()
}
```

## Introduction
ZIO is a Scala library for asynchronous and concurrent programming. It provides a purely functional effect system that makes concurrent code composable, testable, and safe by default. Companies like Stripe, Disney+, eBay, and Zalando run ZIO in production.

## What ZIO Does
- Models side effects as values (ZIO[R, E, A]) that are composable with for-comprehensions
- Provides lightweight fibers for massive concurrency without thread overhead
- Tracks error types at compile time, separating recoverable from fatal errors
- Manages resources safely with Scope, guaranteeing cleanup on any exit path
- Offers built-in retries, timeouts, interruption, and supervision

## Architecture Overview
ZIO represents effects as data: a ZIO[R, E, A] describes a program that requires environment R, can fail with E, or succeed with A. The runtime interprets this data structure by scheduling fibers on a work-stealing thread pool. Fibers are cooperative green threads that yield automatically at async boundaries. The Scope mechanism tracks resource lifetimes and guarantees finalizers run even on fiber interruption.

## Self-Hosting & Configuration
- Add ZIO to build.sbt: `"dev.zio" %% "zio" % "2.1.16"`
- Extend ZIOAppDefault for the main entry point
- Use ZLayer for dependency injection and service configuration
- Configure the runtime with custom thread pools, loggers, or metrics
- Add zio-test for property-based and effect-aware testing

## Key Features
- Typed errors: the compiler prevents unhandled failure modes
- Structured concurrency: child fibers are supervised by parents
- ZLayer: compile-time verified dependency injection
- Built-in streaming via ZStream for backpressure-aware pipelines
- Interop with Cats Effect, Future, and Java CompletableFuture

## Comparison with Similar Tools
- **Cats Effect** — Typelevel's effect system; ZIO provides a more opinionated, batteries-included approach
- **Akka** — actor-based concurrency; ZIO uses fiber-based structured concurrency
- **Kotlin Coroutines** — language-level coroutines; ZIO adds typed errors and dependency injection
- **Project Loom (Virtual Threads)** — JVM-level threads; ZIO adds composability, typed errors, and resource safety
- **Monix** — Scala async library; ZIO offers a broader ecosystem (HTTP, SQL, streaming, testing)

## FAQ
**Q: Does ZIO work with existing Scala libraries?**
A: Yes. ZIO interops with Cats Effect, Akka, and standard Scala Futures, so you can adopt it incrementally.

**Q: Is ZIO hard to learn for developers new to functional programming?**
A: ZIO is designed to be approachable. The for-comprehension syntax reads like imperative code, and the library documentation includes beginner-friendly tutorials.

**Q: What JVM version does ZIO require?**
A: ZIO 2.x supports Java 11+. It also compiles to Scala.js for browser targets and Scala Native for ahead-of-time compilation.

**Q: How does ZIO handle blocking code?**
A: Use `ZIO.attemptBlocking` to run blocking code on a dedicated thread pool, keeping the main fiber pool responsive.

## Sources
- https://github.com/zio/zio
- https://zio.dev

---
Source: https://tokrepo.com/en/workflows/asset-cff0db1a
Author: Script Depot