@zio.dev/zio-blocks 0.0.27 → 0.0.29

package/reference/schema-expr.md

@@ -70,13 +70,13 @@ val result: Either[OpticCheck, Seq[Boolean]] = combined.eval(alice)
 ## Installation
 
 ```scala
-libraryDependencies += "dev.zio" %% "zio-blocks-schema" % "0.0.27"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema" % "0.0.29"
 ```
 
 For cross-platform (Scala.js):
 
 ```scala
-libraryDependencies += "dev.zio" %%% "zio-blocks-schema" % "0.0.27"
+libraryDependencies += "dev.zio" %%% "zio-blocks-schema" % "0.0.29"
 ```
 
 Supported Scala versions: 2.13.x and 3.x.

package/reference/structural-types.md

@@ -0,0 +1,369 @@
+---
+id: structural-types
+title: "Structural Types"
+---
+
+<!--
+BLOCKING ISSUE: Scala 3.7.4 Compiler Crash
+============================================
+
+This file uses structural type syntax ({ def field: Type }) which triggers a compiler
+crash in Scala 3.7.4 during the erasure phase. Therefore, code blocks here are marked
+as plain `scala` instead of `mdoc:compile-only` to allow the documentation build to pass.
+
+WORKAROUND: Code examples are NOT compiled/type-checked until Scala 3.8.x is adopted.
+
+TODO (When Scala 3.8.x is adopted):
+1. Change all `\`\`\`scala` blocks back to `\`\`\`scala mdoc:compile-only`
+2. Run `sbt docs/mdoc` to verify compilation succeeds
+3. Delete this comment
+
+Reference:
+- Scala 3.7.4 compiler issue: https://github.com/scala/scala3/issues/24598 (or similar)
+- Scala 3.8.x migration: PR #1169 "Preparing to migration on Scala 3.8.x"
+- This PR: Addresses structural-types.md CI failures
+-->
+
+Structural types enable **duck typing** with ZIO Blocks schemas. Instead of requiring a nominal type name (like `class Person`), a structural schema validates based on the **shape** of an object — the fields it provides, regardless of how it was defined.
+
+## Motivation
+
+Consider a common integration scenario:
+
+```scala
+// Your system
+case class Person(name: String, age: Int)
+
+// External system (same data, different class)
+case class User(name: String, age: Int)
+```
+
+Without structural types, converting between `Person` and `User` requires manual translation. With structural types, they both have the same structural schema:
+
+```scala
+import scala.language.reflectiveCalls
+import zio.blocks.schema.Schema
+
+case class Person(name: String, age: Int)
+case class User(name: String, age: Int)
+
+val personSchema = Schema.derived[Person]
+val personStructural = personSchema.structural
+// Schema[{ def name: String; def age: Int }]
+
+val userSchema = Schema.derived[User]
+val userStructural = userSchema.structural
+// Schema[{ def name: String; def age: Int }]
+
+// Both schemas accept the same data shape
+```
+
+## Construction: `Schema#structural`
+
+Use the `Schema#structural` method on any schema to get the corresponding structural schema.
+
+**Scala 3:** Using transparent inline — the return type is inferred to the full refinement type:
+
+```scala
+import zio.blocks.schema.Schema
+
+case class Person(name: String, age: Int)
+object Person {
+  implicit val schema: Schema[Person] = Schema.derived[Person]
+}
+
+val personSchema: Schema[Person] = Schema.derived[Person]
+val structuralSchema: Schema[{ def name: String; def age: Int }] = personSchema.structural
+```
+
+**Scala 2:** Implicit derivation — returns `Schema[ts.StructuralType]` (path-dependent type):
+
+```scala
+import zio.blocks.schema.Schema
+
+case class Person(name: String, age: Int)
+object Person {
+  implicit val schema: Schema[Person] = Schema.derived[Person]
+}
+
+val personSchema: Schema[Person] = Schema.derived[Person]
+val structuralSchema = personSchema.structural
+// Type: Schema[ts.StructuralType] (structural type inferred from macro)
+```
+
+## Supported Conversions
+
+The following type categories can be converted to structural schemas:
+
+### Product Types (Case Classes)
+
+Both Scala 2 and 3 support structural conversion of case classes:
+
+```scala
+import zio.blocks.schema.Schema
+
+case class Address(street: String, city: String, zipCode: Int)
+object Address {
+  implicit val schema: Schema[Address] = Schema.derived[Address]
+}
+
+val schema = Schema.derived[Address]
+val structural = schema.structural
+// Schema[{ def street: String; def city: String; def zipCode: Int }]
+```
+
+### Tuples
+
+Tuples convert to structural records with field names derived from positions:
+
+```scala
+import zio.blocks.schema.Schema
+
+type StringIntBool = (String, Int, Boolean)
+implicit val schema: Schema[StringIntBool] = Schema.derived[StringIntBool]
+
+val tupleSchema = Schema.derived[(String, Int, Boolean)]
+val structuralSchema = tupleSchema.structural
+// Schema[{ def _1: String; def _2: Int; def _3: Boolean }]
+```
+
+### Nested Products
+
+Nested product fields keep their nominal types; only the outer product is structuralized:
+
+```scala
+import zio.blocks.schema.Schema
+
+case class Address(street: String, city: String)
+object Address {
+  implicit val schema: Schema[Address] = Schema.derived[Address]
+}
+
+case class Person(name: String, age: Int, address: Address)
+object Person {
+  implicit val schema: Schema[Person] = Schema.derived[Person]
+}
+
+val personSchema = Schema.derived[Person]
+val structuralSchema = personSchema.structural
+// Schema[{
+//   def name: String
+//   def age: Int
+//   def address: Address
+// }]
+```
+
+### Opaque Types (Scala 3)
+
+Opaque type aliases are unwrapped to their underlying type:
+
+```scala
+import zio.blocks.schema.Schema
+
+opaque type UserId = String
+
+case class User(id: UserId, name: String)
+object User {
+  implicit val schema: Schema[User] = Schema.derived[User]
+}
+
+val schema = Schema.derived[User]
+val structural = schema.structural
+// Schema[{ def id: String; def name: String }]
+// (UserId unwrapped to String)
+```
+
+### Sum Types / Sealed Traits (Scala 3)
+
+Sealed traits and enums convert to union types with nested method syntax:
+
+```scala
+import zio.blocks.schema.Schema
+
+sealed trait Shape
+object Shape {
+  case class Circle(radius: Double) extends Shape
+  case class Rectangle(width: Double, height: Double) extends Shape
+  implicit val schema: Schema[Shape] = Schema.derived[Shape]
+}
+
+val schema = Schema.derived[Shape]
+val structural = schema.structural
+// Schema[
+//   { def Circle: { def radius: Double } } |
+//   { def Rectangle: { def height: Double; def width: Double } }
+// ]
+// (cases sorted alphabetically)
+```
+
+**Enum syntax** (Scala 3):
+
+```scala
+import zio.blocks.schema.Schema
+
+enum Color {
+  case Red, Green, Blue
+}
+object Color {
+  implicit val schema: Schema[Color] = Schema.derived[Color]
+}
+
+val schema = Schema.derived[Color]
+val structural = schema.structural
+// Schema[
+//   { def Blue: {} } |
+//   { def Green: {} } |
+//   { def Red: {} }
+// ]
+```
+
+Cases appear in **alphabetical order** in the union type. This alphabetical ordering (applied to fields in products and case names in unions) ensures **deterministic, normalized type identity**: two structural types with the same fields but different declaration order produce the same structural type and normalized name. This is essential for predictable schema evolution and cross-system interop.
+
+## Direct Structural Derivation (Scala 3)
+
+Create a schema directly for a structural type without a nominal base:
+
+```scala
+import zio.blocks.schema.Schema
+
+// No case class needed — define the schema for the shape directly
+val personStructural = Schema.derived[{ def name: String; def age: Int }]
+
+// The schema is ready to use with values matching that structural shape
+```
+
+This is only supported in **Scala 3** with the right macro machinery.
+
+## Round-tripping Through DynamicValue
+
+Structural schemas enable **cross-type conversion through `DynamicValue`** — encode a value of one nominal type and decode it as a *different* nominal type with the same structural shape. This is the core benefit of structural types for system integration.
+
+### Motivation
+
+In real integrations, you often receive data from an external system shaped like one type, but you need to work with it as a different type in your system. Without structural types, field-by-field translation is required. With structural types, if both types have identical shape, `DynamicValue` acts as the seamless bridge.
+
+Common scenarios:
+- **API gateways** — receive a `PersonDTO` from an external API, decode as your internal `Person` type
+- **Message brokers** — consume an event shaped like `UserEvent`, convert to your domain `Account` type
+- **Data pipelines** — records with identical fields but different class names from different services
+
+### Cross-type conversion in action
+
+Set up two types with identical structural shape:
+
+```scala
+import zio.blocks.schema.Schema
+import zio.blocks.schema.SchemaError
+
+case class Person(name: String, age: Int)
+object Person {
+  implicit val schema: Schema[Person] = Schema.derived[Person]
+}
+
+case class Employee(name: String, age: Int)
+object Employee {
+  implicit val schema: Schema[Employee] = Schema.derived[Employee]
+}
+
+val personSchema = Schema.derived[Person]
+val employeeSchema = Schema.derived[Employee]
+```
+
+Now encode a `Person` to `DynamicValue` and decode it as an `Employee`:
+
+```scala
+val person = Person("Alice", 30)
+// person: Person = Person(name = "Alice", age = 30)
+val dynamic = personSchema.toDynamicValue(person)
+// dynamic: DynamicValue = Record(
+//   IndexedSeq(("name", Primitive(String("Alice"))), ("age", Primitive(Int(30))))
+// )
+
+val employee: Either[SchemaError, Employee] =
+  employeeSchema.fromDynamicValue(dynamic)
+// employee: Either[SchemaError, Employee] = Right(
+//   Employee(name = "Alice", age = 30)
+// )
+```
+
+The structural shape guarantee ensures type-safe conversion: at compile time, you know both schemas accept the same fields, so round-tripping through `DynamicValue` is safe and zero-cost.
+
+## Integration
+
+Structural types integrate seamlessly with ZIO Blocks' broader ecosystem:
+
+### With Schema Evolution Macros
+
+Structural schemas work with [Schema Evolution](./schema-evolution/into.md) macros for cross-type conversion. When two types share the same structural shape, the conversion machinery can work across type boundaries:
+
+```scala
+import zio.blocks.schema.Schema
+
+case class Person(name: String, age: Int)
+object Person {
+  implicit val schema: Schema[Person] = Schema.derived[Person]
+}
+
+case class PersonDTO(name: String, age: Int)
+object PersonDTO {
+  implicit val schema: Schema[PersonDTO] = Schema.derived[PersonDTO]
+}
+
+// Both types have identical structural schemas
+val personSchema = Schema.derived[Person]
+val dtoSchema = Schema.derived[PersonDTO]
+
+// They share the same structural shape:
+// Schema[{ def name: String; def age: Int }]
+```
+
+### With Binding.of (Serialization)
+
+Structural types are also supported by the `Binding.of` macro for high-performance serialization via register-based encoding:
+
+```scala
+import zio.blocks.schema.binding.Binding
+
+// Direct structural type serialization (JVM only)
+val binding = Binding.of[{ def name: String; def age: Int }]
+
+// Works with nested structural types
+val nestedBinding = Binding.of[{
+  def name: String
+  def address: { def street: String; def city: String }
+}]
+
+// Works with containers
+val containerBinding = Binding.of[{
+  def name: String
+  def emails: List[String]
+}]
+```
+
+This enables anonymous structural types to benefit from ZIO Blocks' high-performance serialization without requiring nominal case class definitions. Like `Schema#structural`, this is **JVM-only**.
+
+See [Binding](./binding.md) for detailed serialization documentation.
+
+## Running the Examples
+
+Example applications demonstrating structural types are available in `schema-examples`:
+
+```sh
+# Simple product type
+sbt "schema-examples/runMain structural.StructuralSimpleProductExample"
+
+# Nested products
+sbt "schema-examples/runMain structural.StructuralNestedProductExample"
+
+# Sealed trait (Scala 3)
+sbt "schema-examples/runMain structural.StructuralSealedTraitExample"
+
+# Enum (Scala 3)
+sbt "schema-examples/runMain structural.StructuralEnumExample"
+
+# Tuples
+sbt "schema-examples/runMain structural.StructuralTupleExample"
+
+# Integration with Into macro
+sbt "schema-examples/runMain structural.StructuralIntoExample"
+```

package/reference/type-class-derivation.md

@@ -107,7 +107,7 @@ trait Deriver[TC[_]] {
   def deriveRecord[F[_, _], A](
     fields: IndexedSeq[Term[F, A, ?]],
     typeId: TypeId[A],
-    binding: Binding[BindingType.Record, A],
+    binding: Binding.Record[A],
     doc: Doc,
     modifiers: Seq[Modifier.Reflect],
     defaultValue: Option[A],
@@ -194,7 +194,7 @@ object DeriveShow extends Deriver[Show] {
   override def derivePrimitive[A](
     primitiveType: PrimitiveType[A],
     typeId: TypeId[A],
-    binding: Binding[BindingType.Primitive, A],
+    binding: Binding.Primitive[A],
     doc: Doc,
     modifiers: Seq[Modifier.Reflect],
     defaultValue: Option[A],
@@ -213,7 +213,7 @@ object DeriveShow extends Deriver[Show] {
   override def deriveRecord[F[_, _], A](
     fields: IndexedSeq[Term[F, A, ?]],
     typeId: TypeId[A],
-    binding: Binding[BindingType.Record, A],
+    binding: Binding.Record[A],
     doc: Doc,
     modifiers: Seq[Modifier.Reflect],
     defaultValue: Option[A],
@@ -255,7 +255,7 @@ object DeriveShow extends Deriver[Show] {
   override def deriveVariant[F[_, _], A](
     cases: IndexedSeq[Term[F, A, ?]],
     typeId: TypeId[A],
-    binding: Binding[BindingType.Variant, A],
+    binding: Binding.Variant[A],
     doc: Doc,
     modifiers: Seq[Modifier.Reflect],
     defaultValue: Option[A],
@@ -289,7 +289,7 @@ object DeriveShow extends Deriver[Show] {
   override def deriveSequence[F[_, _], C[_], A](
     element: Reflect[F, A],
     typeId: TypeId[C[A]],
-    binding: Binding[BindingType.Seq[C], C[A]],
+    binding: Binding.Seq[C, A],
     doc: Doc,
     modifiers: Seq[Modifier.Reflect],
     defaultValue: Option[C[A]],
@@ -315,7 +315,7 @@ object DeriveShow extends Deriver[Show] {
     key: Reflect[F, K],
     value: Reflect[F, V],
     typeId: TypeId[M[K, V]],
-    binding: Binding[BindingType.Map[M], M[K, V]],
+    binding: Binding.Map[M, K, V],
     doc: Doc,
     modifiers: Seq[Modifier.Reflect],
     defaultValue: Option[M[K, V]],
@@ -341,7 +341,7 @@ object DeriveShow extends Deriver[Show] {
   }
 
   override def deriveDynamic[F[_, _]](
-    binding: Binding[BindingType.Dynamic, DynamicValue],
+    binding: Binding.Dynamic,
     doc: Doc,
     modifiers: Seq[Modifier.Reflect],
     defaultValue: Option[DynamicValue],
@@ -380,7 +380,7 @@ object DeriveShow extends Deriver[Show] {
   override def deriveWrapper[F[_, _], A, B](
     wrapped: Reflect[F, B],
     typeId: TypeId[A],
-    binding: Binding[BindingType.Wrapper[A, B], A],
+    binding: Binding.Wrapper[A, B],
     doc: Doc,
     modifiers: Seq[Modifier.Reflect],
     defaultValue: Option[A],
@@ -414,7 +414,7 @@ When the derivation process encounters a primitive type (e.g., `String`, `Int`),
 def derivePrimitive[A](
   primitiveType: PrimitiveType[A],
   typeId: TypeId[A],
-  binding: Binding[BindingType.Primitive, A],
+  binding: Binding.Primitive[A],
   doc: Doc,
   modifiers: Seq[Modifier.Reflect],
   defaultValue: Option[A],
@@ -444,7 +444,7 @@ When the derivation process encounters a record type (e.g., a case class), it ca
 def deriveRecord[F[_, _], A](
   fields: IndexedSeq[Term[F, A, ?]],
   typeId: TypeId[A],
-  binding: Binding[BindingType.Record, A],
+  binding: Binding.Record[A],
   doc: Doc,
   modifiers: Seq[Modifier.Reflect],
   defaultValue: Option[A],
@@ -512,7 +512,7 @@ When the derivation process encounters a variant type (e.g., a sealed trait with
 def deriveVariant[F[_, _], A](
   cases: IndexedSeq[Term[F, A, ?]],
   typeId: TypeId[A],
-  binding: Binding[BindingType.Variant, A],
+  binding: Binding.Variant[A],
   doc: Doc,
   modifiers: Seq[Modifier.Reflect],
   defaultValue: Option[A],
@@ -556,7 +556,7 @@ When the derivation process encounters a sequence type (e.g., `List[A]`), it cal
 def deriveSequence[F[_, _], C[_], A](
   element: Reflect[F, A],
   typeId: TypeId[C[A]],
-  binding: Binding[BindingType.Seq[C], C[A]],
+  binding: Binding.Seq[C, A],
   doc: Doc,
   modifiers: Seq[Modifier.Reflect],
   defaultValue: Option[C[A]],
@@ -590,7 +590,7 @@ def deriveMap[F[_, _], M[_, _], K, V](
   key: Reflect[F, K],
   value: Reflect[F, V],
   typeId: TypeId[M[K, V]],
-  binding: Binding[BindingType.Map[M], M[K, V]],
+  binding: Binding.Map[M, K, V],
   doc: Doc,
   modifiers: Seq[Modifier.Reflect],
   defaultValue: Option[M[K, V]],
@@ -620,11 +620,11 @@ The derivation process for maps is similar to sequences, but we have two child i
 
 ### Dynamic Derivation
 
-When the derivation process encounters a dynamic type (e.g., `DynamicValue`), it calls the `deriveDynamic` method of the `Deriver`. This method receives a `Binding[BindingType.Dynamic, DynamicValue]` representing the dynamic type, along with other metadata such as documentation, modifiers, default values, and examples:
+When the derivation process encounters a dynamic type (e.g., `DynamicValue`), it calls the `deriveDynamic` method of the `Deriver`. This method receives a `Binding.Dynamic` representing the dynamic type, along with other metadata such as documentation, modifiers, default values, and examples:
 
 ```scala
 def deriveDynamic[F[_, _]](
-  binding: Binding[BindingType.Dynamic, DynamicValue],
+  binding: Binding.Dynamic,
   doc: Doc,
   modifiers: Seq[Modifier.Reflect],
   defaultValue: Option[DynamicValue],
@@ -667,7 +667,7 @@ When the derivation process encounters a wrapper type (e.g., a value class, opaq
 def deriveWrapper[F[_, _], A, B](
   wrapped: Reflect[F, B],
   typeId: TypeId[A],
-  binding: Binding[BindingType.Wrapper[A, B], A],
+  binding: Binding.Wrapper[A, B],
   doc: Doc,
   modifiers: Seq[Modifier.Reflect],
   defaultValue: Option[A],
@@ -875,7 +875,7 @@ object DeriveGen extends Deriver[Gen] {
   override def derivePrimitive[A](
     primitiveType: PrimitiveType[A],
     typeId: TypeId[A],
-    binding: Binding[BindingType.Primitive, A],
+    binding: Binding.Primitive[A],
     doc: Doc,
     modifiers: Seq[Modifier.Reflect],
     defaultValue: Option[A],
@@ -913,7 +913,7 @@ object DeriveGen extends Deriver[Gen] {
   override def deriveRecord[F[_, _], A](
     fields: IndexedSeq[Term[F, A, ?]],
     typeId: TypeId[A],
-    binding: Binding[BindingType.Record, A],
+    binding: Binding.Record[A],
     doc: Doc,
     modifiers: Seq[Modifier.Reflect],
     defaultValue: Option[A],
@@ -957,7 +957,7 @@ object DeriveGen extends Deriver[Gen] {
   override def deriveVariant[F[_, _], A](
     cases: IndexedSeq[Term[F, A, ?]],
     typeId: TypeId[A],
-    binding: Binding[BindingType.Variant, A],
+    binding: Binding.Variant[A],
     doc: Doc,
     modifiers: Seq[Modifier.Reflect],
     defaultValue: Option[A],
@@ -990,7 +990,7 @@ object DeriveGen extends Deriver[Gen] {
   override def deriveSequence[F[_, _], C[_], A](
     element: Reflect[F, A],
     typeId: TypeId[C[A]],
-    binding: Binding[BindingType.Seq[C], C[A]],
+    binding: Binding.Seq[C, A],
     doc: Doc,
     modifiers: Seq[Modifier.Reflect],
     defaultValue: Option[C[A]],
@@ -1033,7 +1033,7 @@ object DeriveGen extends Deriver[Gen] {
     key: Reflect[F, K],
     value: Reflect[F, V],
     typeId: TypeId[M[K, V]],
-    binding: Binding[BindingType.Map[M], M[K, V]],
+    binding: Binding.Map[M, K, V],
     doc: Doc,
     modifiers: Seq[Modifier.Reflect],
     defaultValue: Option[M[K, V]],
@@ -1069,7 +1069,7 @@ object DeriveGen extends Deriver[Gen] {
    * content.
    */
   override def deriveDynamic[F[_, _]](
-    binding: Binding[BindingType.Dynamic, DynamicValue],
+    binding: Binding.Dynamic,
     doc: Doc,
     modifiers: Seq[Modifier.Reflect],
     defaultValue: Option[DynamicValue],
@@ -1124,7 +1124,7 @@ object DeriveGen extends Deriver[Gen] {
   override def deriveWrapper[F[_, _], A, B](
     wrapped: Reflect[F, B],
     typeId: TypeId[A],
-    binding: Binding[BindingType.Wrapper[A, B], A],
+    binding: Binding.Wrapper[A, B],
     doc: Doc,
     modifiers: Seq[Modifier.Reflect],
     defaultValue: Option[A],
@@ -1153,7 +1153,7 @@ The `derivePrimitive` method is responsible for deriving a `Gen` instance for pr
 def derivePrimitive[A](
   primitiveType: PrimitiveType[A],
   typeId: TypeId[A],
-  binding: Binding[BindingType.Primitive, A],
+  binding: Binding.Primitive[A],
   doc: Doc,
   modifiers: Seq[Modifier.Reflect],
   defaultValue: Option[A],
@@ -1187,7 +1187,7 @@ The `deriveRecord` method is responsible for deriving a `Gen` instance for recor
 def deriveRecord[F[_, _], A](
   fields: IndexedSeq[Term[F, A, ?]],
   typeId: TypeId[A],
-  binding: Binding[BindingType.Record, A],
+  binding: Binding.Record[A],
   doc: Doc,
   modifiers: Seq[Modifier.Reflect],
   defaultValue: Option[A],
@@ -1233,7 +1233,7 @@ The `deriveVariant` method is responsible for deriving a `Gen` instance for vari
 def deriveVariant[F[_, _], A](
   cases: IndexedSeq[Term[F, A, ?]],
   typeId: TypeId[A],
-  binding: Binding[BindingType.Variant, A],
+  binding: Binding.Variant[A],
   doc: Doc,
   modifiers: Seq[Modifier.Reflect],
   defaultValue: Option[A],
@@ -1268,7 +1268,7 @@ The `deriveSequence` method is responsible for deriving a `Gen` instance for seq
 def deriveSequence[F[_, _], C[_], A](
   element: Reflect[F, A],
   typeId: TypeId[C[A]],
-  binding: Binding[BindingType.Seq[C], C[A]],
+  binding: Binding.Seq[C, A],
   doc: Doc,
   modifiers: Seq[Modifier.Reflect],
   defaultValue: Option[C[A]],
@@ -1313,7 +1313,7 @@ def deriveMap[F[_, _], M[_, _], K, V](
   key: Reflect[F, K],
   value: Reflect[F, V],
   typeId: TypeId[M[K, V]],
-  binding: Binding[BindingType.Map[M], M[K, V]],
+  binding: Binding.Map[M, K, V],
   doc: Doc,
   modifiers: Seq[Modifier.Reflect],
   defaultValue: Option[M[K, V]],
@@ -1352,7 +1352,7 @@ The `deriveDynamic` method is responsible for deriving a `Gen` instance for dyna
 
 ```scala
 def deriveDynamic[F[_, _]](
-  binding: Binding[BindingType.Dynamic, DynamicValue],
+  binding: Binding.Dynamic,
   doc: Doc,
   modifiers: Seq[Modifier.Reflect],
   defaultValue: Option[DynamicValue],
@@ -1415,7 +1415,7 @@ The `deriveWrapper` method is responsible for deriving a `Gen` instance for wrap
 def deriveWrapper[F[_, _], A, B](
   wrapped: Reflect[F, B],
   typeId: TypeId[A],
-  binding: Binding[BindingType.Wrapper[A, B], A],
+  binding: Binding.Wrapper[A, B],
   doc: Doc,
   modifiers: Seq[Modifier.Reflect],
   defaultValue: Option[A],
@@ -1456,7 +1456,7 @@ Now we can use the derived `Gen[Person]` instance to generate random `Person` va
 
 ```scala
 val random = new Random(42) // Seeded for reproducible output
-// random: Random = scala.util.Random@4688d970
+// random: Random = scala.util.Random@1d1d8934
 
 Person.gen.generate(random)
 // res14: Person = Person(name = "p", age = -1360544799)