@zio.dev/zio-blocks 0.0.1 → 0.0.21

package/reference/optics.md

@@ -218,7 +218,7 @@ It takes a `Reflect.Variant.Bound[S]` representing the schema of the sum type `S
 
 Assume you have a `Notification` sealed trait representing different notification types:
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.schema._
 
 sealed trait Notification
@@ -234,7 +234,7 @@ object Notification {
 
 First, we need to define schemas for each case class and then write a prism for each case (here we define a prism for the `Email` case):
 
-```scala mdoc:silent
+```scala
 import zio.blocks.schema._
 
 sealed trait Notification
@@ -281,7 +281,7 @@ object Notification {
 
 The `optic` macro inside the `CompanionOptics` trait creates a prism using intuitive selector syntax with the `when[CaseType]` method:
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.schema._
 
 sealed trait Notification
@@ -304,7 +304,7 @@ The macro inspects the selector expression `_.when[Email]`, validates that `Emai
 
 For nested structures, the `optic` macro can compose prisms with lenses by chaining case selection with field access:
 
-```scala mdoc:silent
+```scala
 sealed trait Response
 object Response extends CompanionOptics[Response] {
   case class Success(data: Data)    extends Response
@@ -325,7 +325,7 @@ object Response extends CompanionOptics[Response] {
 
 When you compose a prism with a lens using the `optic` macro, the result is an `Optional`—an optic that may fail to focus (because the sum type might be a different case) but if it succeeds, always finds the field:
 
-```scala mdoc:compile-only
+```scala
 val response = Response.Success(Response.Data(1, "hello"))
 
 Response.successValue.getOption(response)
@@ -339,11 +339,25 @@ Response.successValue.getOption(Response.Failure("error"))
 
 Now let's explore prism operations. Assume we have some sample notifications:
 
-```scala mdoc
+```scala
 // Sample notifications
 val emailNotif: Notification = Notification.Email("user@example.com", "Hello", "Welcome!")
+// emailNotif: Notification = Email(
+//   to = "user@example.com",
+//   subject = "Hello",
+//   body = "Welcome!"
+// )
 val smsNotif: Notification   = Notification.SMS("+1234567890", "Your code is 1234")
+// smsNotif: Notification = SMS(
+//   phoneNumber = "+1234567890",
+//   message = "Your code is 1234"
+// )
 val pushNotif: Notification  = Notification.Push("device-abc", "Alert", Map("action" -> "open"))
+// pushNotif: Notification = Push(
+//   deviceId = "device-abc",
+//   title = "Alert",
+//   payload = Map("action" -> "open")
+// )
 ```
 
 1. **`Prism#getOption`** — Extract the case if it matches, otherwise None
@@ -557,7 +571,7 @@ Beside the above composition methods, `Optional` provides specialized constructo
 
 The most common way to manually construct an `Optional` is by composing a `Lens` with a `Prism`. Assume you have a `PaymentMethod` sum type which has multiple cases, and we have written a prism for one of its cases, e.g., `CreditCard`:
 
-```scala mdoc:silent
+```scala
 import zio.blocks.schema._
 
 sealed trait PaymentMethod
@@ -574,7 +588,7 @@ object PaymentMethod extends CompanionOptics[PaymentMethod] {
 
 And also assume we have a `Customer` record that has a `payment` field of type `PaymentMethod` and we have written a lens for that field:
 
-```scala mdoc:silent
+```scala
 case class Customer(name: String, payment: PaymentMethod)
 object Customer extends CompanionOptics[Customer] {
   implicit val schema: Schema[Customer] = Schema.derived
@@ -586,7 +600,7 @@ object Customer extends CompanionOptics[Customer] {
 
 We can now compose the `payment` lens with the `creditCard` prism to create an `Optional` that focuses on the `CreditCard` details within a `Customer`:
 
-```scala mdoc:compile-only
+```scala
 // Compose lens and prism manually to get Optional
 val creditCard: Optional[Customer, PaymentMethod.CreditCard] =
   Optional(Customer.payment, PaymentMethod.creditCard)
@@ -596,7 +610,7 @@ val creditCard: Optional[Customer, PaymentMethod.CreditCard] =
 
 For accessing elements at specific indices in sequences:
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.schema._
 
 case class Order(id: String, items: List[String])
@@ -624,7 +638,7 @@ The `optic` macro inside the `CompanionOptics` trait creates optionals automatic
 
 By combining the `.when[Case]` (prism) and `.field-name` (lens) syntax of optic macro, you can create optionals that focus on the inner values of ADTs:
 
-```scala mdoc:silent:nest
+```scala
 import zio.blocks.schema._
 
 case class ApiResponse(
@@ -673,7 +687,7 @@ object Response extends CompanionOptics[Response] {
 
 We can access elements at specific indices in sequences using `.at(index)` syntax in `optic` macro:
 
-```scala mdoc:silent
+```scala
 import zio.blocks.schema._
 
 case class OrderItem(sku: String, quantity: Int)
@@ -697,7 +711,7 @@ object Order extends CompanionOptics[Order] {
 
 Usage:
 
-```scala mdoc:compile-only
+```scala
 val order = Order("ord-1", List(
   OrderItem("SKU-A", 2),
   OrderItem("SKU-B", 1)
@@ -715,7 +729,7 @@ Order.firstItemSku.getOption(order)    // => Some("SKU-A")
 
 To access values at a specific key, we can use `.atKey(key)` syntax in `optic` macro:
 
-```scala mdoc:silent
+```scala
 import zio.blocks.schema._
 
 case class Config(settings: Map[String, String])
@@ -733,7 +747,7 @@ object Config extends CompanionOptics[Config] {
 
 Here is how you can use these optionals:
 
-```scala mdoc:compile-only
+```scala
 val config = Config(Map("host" -> "localhost", "port" -> "8080"))
 
 Config.hostSetting.getOption(config)        // => Some("localhost")
@@ -744,7 +758,7 @@ Config.setting("timeout").getOption(config) // => None (key not present)
 
 To access the inner value of wrapper types (newtypes, opaque types) you can use the `.wrapped[T]` syntax in `optic` macro:
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.schema._
 
 // Assume Email is a wrapper around String with validation
@@ -812,7 +826,7 @@ object Traversal {
 
 For example, to create a traversal over all items in a shopping cart represented as a list and quantities as a vector, you can do the following:
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.schema._
 
 case class ShoppingCart(items: List[String], quantities: Vector[Int])
@@ -848,7 +862,7 @@ object Traversal {
 
 Let's say you have an inventory represented as a map of product names to stock counts. You can create traversals for both keys and values as follows:
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.schema._
 
 case class Inventory(stock: Map[String, Int])
@@ -871,7 +885,7 @@ The `optic` macro inside the `CompanionOptics` trait creates traversals using in
 
 1. Use `.each` to traverse all elements in a sequence (List, Vector, Set, ArraySeq):
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.schema._
 
 case class Order(id: String, items: List[String], prices: Vector[Double])
@@ -888,7 +902,7 @@ object Order extends CompanionOptics[Order] {
 
 2. Use `.eachKey` to traverse all keys and `.eachValue` to traverse all values in a map:
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.schema._
 
 case class UserScores(scores: Map[String, Int])
@@ -905,7 +919,7 @@ object UserScores extends CompanionOptics[UserScores] {
 
 3. Use `.atIndices(indices)` to traverse elements at specific indices:
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.schema._
 
 case class Matrix(rows: Vector[Vector[Int]])
@@ -919,7 +933,7 @@ object Matrix extends CompanionOptics[Matrix] {
 
 4. Use `.atKeys(keys)` to traverse values at specific keys:
 
-```scala mdoc:silent
+```scala
 import zio.blocks.schema._
 
 case class Environment(variables: Map[String, String])
@@ -933,7 +947,7 @@ object Environment extends CompanionOptics[Environment] {
 
 Please note that the `optic` macro supports chaining traversals with field access for deep navigation:
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.schema._
 
 case class LineItem(sku: String, price: Double, quantity: Int)
@@ -960,7 +974,7 @@ object Invoice extends CompanionOptics[Invoice] {
 
 Let's explore traversal operations with a practical example. Assume we have a `Team` case class with a list of members and a map of scores:
 
-```scala mdoc:silent
+```scala
 import zio.blocks.schema._
 
 case class Team(name: String, members: List[String], scores: Map[String, Int])
@@ -981,7 +995,7 @@ val team = Team(
 
 1. `Traversal#fold` aggregates all focused values:
 
-```scala mdoc:compile-only
+```scala
 // Count all members
 Team.allMembers.fold(team)(0, (count, _) => count + 1)
 // => 3
@@ -997,7 +1011,7 @@ Team.allMembers.fold(team)("", (acc, name) => if (acc.isEmpty) name else s"$acc,
 
 2. `Traversal#reduceOrFail` reduces with error handling:
 
-```scala mdoc:compile-only
+```scala
 // Find the maximum score
 Team.allScores.reduceOrFail(team)(math.max)
 // => Right(100)
@@ -1030,7 +1044,7 @@ Team.allPlayerNames.modify(team, name => s"Player: $name")
 
 4. `Traversal#modifyOption` — Modify returning Option
 
-```scala mdoc:compile-only
+```scala
 // Modify non-empty collection
 Team.allMembers.modifyOption(team, _.toUpperCase)
 // => Some(Team("Alpha", List("ALICE", "BOB", "CHARLIE"), Map(...)))
@@ -1043,7 +1057,7 @@ Team.allMembers.modifyOption(emptyTeam, _.toUpperCase)
 
 5. `Traversal#modifyOrFail` — Modify with detailed error on failure
 
-```scala mdoc:compile-only
+```scala
 // Successful modification
 Team.allMembers.modifyOrFail(team, _.toUpperCase)
 // => Right(Team("Alpha", List("ALICE", "BOB", "CHARLIE"), Map(...)))
@@ -1138,7 +1152,7 @@ This method takes two lenses: the first from `S` to `T`, and the second from `T`
 
 For example, if we have a `Person` case class that contains an `Address` and we want to create a lens to access the `street` field of the `Address` within `Person`, we can do so as follows:
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.schema._
 
 case class Address(street: String, city: String)
@@ -1186,7 +1200,7 @@ object Person {
 
 The `optic` macro (or its alias `$`) provides a more concise way to derive composed lenses. By extending `CompanionOptics[T]` and using selector syntax, you can derive the same lenses with significantly less boilerplate:
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.schema._
 
 case class Address(street: String, city: String)
@@ -1317,7 +1331,7 @@ Employee.emailAddress.getOption(employee2)
 
 The `optic` macro supports case selection using the `.when[T]` syntax, which makes composing lenses with prisms much more concise:
 
-```scala mdoc:silent:nest
+```scala
 import zio.blocks.schema._
 
 sealed trait ContactInfo
@@ -1364,7 +1378,7 @@ When you compose a `Lens` with an `Optional`, the result is also an `Optional`.
 
 Building on our previous example, suppose we have a `Company` that contains an `Employee`:
 
-```scala mdoc:silent
+```scala
 case class Company(name: String, ceo: Employee)
 object Company {
   implicit val schema: Schema[Company] = Schema.derived[Company]
@@ -1389,7 +1403,7 @@ object Company {
 
 Now you can work with the CEO's email contact through the company:
 
-```scala mdoc:compile-only
+```scala
 val techCorp = Company("TechCorp", Employee("Alice", ContactInfo.Email("alice@tech.com")))
 val retailCo = Company("RetailCo", Employee("Bob", ContactInfo.Phone("555-9999")))
 
@@ -1416,7 +1430,7 @@ This composition pattern is powerful for navigating through complex nested struc
 
 With the `optic` macro, you can express the entire path in a single selector expression:
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.schema._
 
 case class Company(name: String, ceo: Employee)
@@ -1454,7 +1468,7 @@ If you have a record containing a collection field and you want to operate on al
 
 For example, let's create a `Department` that has a list of employees, and we want to access all employee names:
 
-```scala mdoc:compile-only
+```scala
 case class Department(name: String, employees: List[Employee])
 object Department {
   implicit val schema: Schema[Department] = Schema.derived[Department]
@@ -1557,7 +1571,7 @@ This example demonstrates the power of optics composition: you can build complex
 
 The `optic` macro supports collection traversal using the `.each` syntax. This allows you to express traversals over lists, vectors, and other sequences in a concise path expression:
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.schema._
 
 case class Department(name: String, employees: List[Employee])
@@ -1594,7 +1608,7 @@ The result is a `Traversal[Department, String]` that focuses on all email addres
 
 For maps, the macro provides `.eachKey` and `.eachValue` for traversing keys and values, respectively:
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.schema._
 
 case class Inventory(items: Map[String, Int])

package/reference/reflect.md

@@ -84,7 +84,7 @@ case class Record[F[_, _], A](
 
 The following example shows a `Person` case class represented as a `Reflect.Record`:
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.schema._
 import zio.blocks.schema.binding.RegisterOffset._
 import zio.blocks.schema.binding._
@@ -387,7 +387,7 @@ case class Tree(value: Int, children: List[Tree])
 
 We can define its schema using `Reflect.Deferred` as follows:
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.schema._
 import zio.blocks.schema.binding.RegisterOffset.RegisterOffset
 import zio.blocks.schema.binding._
@@ -508,7 +508,7 @@ The auto-derivation mechanism inspects the structure of your data types at compi
 
 To leverage auto-derivation, simply define an implicit `Schema` for your type using `Schema.derived`:
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.schema.Schema
 
 case class Person(name: String, age: Int)

package/reference/registers.md

@@ -10,13 +10,13 @@ The register system is one of the key innovations in ZIO Blocks (ZIO Schema 2) t
 
 When building generic abstractions over data types (like serialization libraries), you need to describe all possible constructions and deconstructions uniformly. The traditional approach uses tuples and boxed primitives. For example assume we have a simple record data type:
 
-```scala mdoc:compile-only
+```scala
 case class Person(name: String, age: Int)
 ```
 
 A traditional library might represent it as tuple when serializing/deserializing:
 
-```scala mdoc:compile-only
+```scala
 trait Tuple
 case class Tuple2[A, B]( _1: A, _2: B)          extends Tuple
 case class Tuple3[A, B, C](_1: A, _2: B, _3: C) extends Tuple
@@ -25,7 +25,7 @@ case class Tuple3[A, B, C](_1: A, _2: B, _3: C) extends Tuple
 
 Tuple is generic data structure that can hold values of any type. So serializing `Person` would involve converting it to/from `Tuple2[String, Int]`:
 
-```scala mdoc:compile-only
+```scala
 case class Person(name: String, age: Int)
 val person = Person("john", 42)
 
@@ -155,7 +155,7 @@ RegisterOffset.getObjects(RegisterOffset(bytes = 4, ints = 2, objects = 3)) // o
 
 `Registers` is a mutable container that holds values. It's created with an initial capacity:
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.schema.binding._
 import zio.blocks.schema.binding.RegisterOffset._
 
@@ -207,7 +207,7 @@ When setting or getting a value, you are required to provide one or two of the f
 
 Encoding data instances into registers involves mapping each field of a data type to its corresponding position in the two register arrays (byte array for primitives and object array for references). For example, assume we have a `Person` data type as below:
 
-```scala mdoc:silent
+```scala
 case class Person(
   name: String,
   email: String,
@@ -219,7 +219,7 @@ case class Person(
 
 We can encode it with registers, as follows:
 
-```scala mdoc:silent
+```scala
 import zio.blocks.schema.binding._
 import zio.blocks.schema.binding.RegisterOffset._
 
@@ -254,7 +254,7 @@ registers.setDouble(
 
 Conversely, to decode the `Person` data type from registers, you would read the values back from their respective positions:
 
-```scala mdoc:silent
+```scala
 import zio.blocks.schema.binding._
 import zio.blocks.schema.binding.RegisterOffset._
 // Decode Person from registers

package/reference/schema.md

@@ -61,7 +61,7 @@ ZIO Blocks provides both automatic schema derivation and also ways to manually c
 
 To leverage auto-derivation, simply define an implicit `Schema` for your type using `Schema.derived`:
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.schema.Schema
 
 case class Person(name: String, age: Int)
@@ -75,7 +75,7 @@ It will automatically derive the schema for `Person` based on its structure. Aft
 
 For sealed traits (ADTs), it will derive the schema for all subtypes as well:
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.schema.Schema
 
 sealed trait Shape
@@ -97,7 +97,7 @@ ZIO Blocks ships with a comprehensive set of pre-defined schemas for standard Sc
 
 The foundational building blocks for all data types. These schemas leverage the [register-based architecture](registers.md) for zero-allocation performance:
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.schema.Schema
 
 Schema[Unit]      // The unit type (singleton value)
@@ -116,7 +116,7 @@ Schema[String]    // Immutable character sequence
 
 For financial calculations and scenarios requiring exact decimal representation:
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.schema.Schema
 
 Schema[BigInt]      // Arbitrary precision integer
@@ -127,7 +127,7 @@ Schema[BigDecimal]  // Arbitrary precision decimal
 
 Complete coverage of the modern Java Time API for robust date/time handling:
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.schema.Schema
 
 // Date components
@@ -159,7 +159,7 @@ Schema[java.time.MonthDay]   // Month and day combination
 
 There are also schemas for frequently used Java utility types, UUID and Currency:
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.schema.Schema
 
 Schema[java.util.UUID]      // 128-bit universally unique identifier
@@ -170,7 +170,7 @@ Schema[java.util.Currency]  // ISO 4217 currency code
 
 ZIO Blocks provides specialized `Option` schemas optimized for primitive types. These avoid boxing overhead by storing primitive values directly in registers:
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.schema.Schema
 
 import zio.blocks.schema.Schema
@@ -207,7 +207,7 @@ To learn how to create custom collection schemas, check out the [`Sequence`](./r
 
 ZIO Blocks includes a built-in schema for `DynamicValue`, a semi-structured data representation that serves as a superset of JSON:
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.schema._
 
 val schema = Schema[DynamicValue]  // Semi-structured data (superset of JSON)
@@ -315,7 +315,7 @@ ZIO Blocks has built-in support for several popular formats, currently `AvroForm
 
 The following example demonstrates encoding and decoding a `Person` case class to/from JSON using the built-in `JsonFormat`:
 
-```scala mdoc:compile-only
+```scala
 import java.nio.ByteBuffer
 
 import zio.blocks.schema._
@@ -387,7 +387,7 @@ ZIO Blocks allows attaching metadata to schemas and their fields, such as docume
 
 Here is an example of how to set and retrieve documentation values:
 
-```scala mdoc:silent
+```scala
 import zio.blocks.schema._
 
 case class Person(name: String, age: Int)
@@ -413,7 +413,7 @@ The important thing to note here is that we can use optics to target specific fi
 
 Similarly, you can set and get example values:
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.schema._
 
 // Add example values
@@ -430,7 +430,7 @@ val fieldExamples: Schema[Person] =
 
 There are also methods for setting and getting default values:
 
-```scala mdoc:silent
+```scala
 // Add default value to schema
 val withDefault: Schema[Person] = Schema[Person]
   .defaultValue(Person("Unknown", 0))
@@ -451,7 +451,7 @@ val ageDefault: Option[Int] =
 
 To access a specific part of a schema, we can use the `Schema#get` method, which takes an optic and returns the reflection of the targeted field. 
 
-```scala mdoc:silent:reset
+```scala
 import zio.blocks.schema._
 
 case class Person(name: String, address: Address)
@@ -479,7 +479,7 @@ val addressSchema: Option[Reflect.Bound[Address]] =
 
 This method enables us to retrieve the schema for any nested field using optics. For example, to get the schema for the `street` field inside the `address` of a `Person`, we can do as follows:
 
-```scala mdoc:compile-only
+```scala
 val streetSchema: Option[Reflect.Bound[String]] =
   Schema[Person].get(Person.address(Address.street))
 ```
@@ -498,7 +498,7 @@ case class Schema[A](reflect: Reflect.Bound[A]) {
 
 Here is an example of updating the documentation of a nested field:
 
-```scala mdoc:compile-only
+```scala
 // Update schema at a specific path
 val updated: Option[Schema[Person]] = Schema[Person]
   .updated(Person.address)(_.doc("Mailing address"))
@@ -526,7 +526,7 @@ case class Schema[A](reflect: Reflect.Bound[A]) {
 
 These methods enable us to use `@@` syntax for applying aspects to either the entire schema or a specific path within the schema using optics:
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.schema._
 
 // Apply aspect to entire schema
@@ -560,7 +560,7 @@ final case class Schema[A](reflect: Reflect.Bound[A]) {
 
 Here is an example of adding modifiers to a schema:
 
-```scala mdoc:compile-only
+```scala
 // Add modifier to schema
   val modified: Schema[Person] = Schema[Person]
     .modifier(Modifier.config("db.table-name", "person_table"))
@@ -590,7 +590,7 @@ The `transform` method allows you to define transformations that can fail by thr
 
 Here are examples of both:
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.schema.{Schema, SchemaError}
 
 // For types with validation (may fail)