[data] remove Row (#1471)

Author: fwbrasil

kyo-data/shared/src/main/scala/kyo/Record.scala

@@ -18,23 +18,6 @@ import scala.language.implicitConversions
   * combinations with static type checking, making them ideal for configuration, data transformation, and API integrations where the shape
   * of data needs to be flexible but still type-safe.
   *
-  * =Record vs Row=
-  * Record and [[Row]] both provide type-safe named fields, but represent different abstractions:
-  *
-  * '''Record''' is a '''labeled set''' — fields are unordered, a record with more fields can be used where fewer are expected (structural
-  * subtyping), and the same name can appear with different types. Use Record when different consumers need different field subsets or when
-  * composing fields from multiple sources.
-  *
-  * '''Row''' is a '''labeled sequence''' — fields have a fixed order, each name is unique, and the type must match exactly. Use Row when
-  * field order matters, when you need positional operations (head/tail/take/drop), or when working with case classes.
-  *
-  * The two interconvert freely:
-  * {{{
-  * val record = "name" ~ "Alice" & "age" ~ 30
-  * val row  = Row.fromRecord(record)    // Record -> Row (rejects duplicate field names)
-  * val back = row.toRecord               // Row -> Record
-  * }}}
-  *
   * =Creation=
   * Records can be created through direct field construction using the `~` operator and combined with `&`:
   * {{{
@@ -183,6 +166,10 @@ object Record:
         case (n *: EmptyTuple, v *: EmptyTuple) => n ~ v
         case (n *: ns, v *: vs)                 => (n ~ v) & FieldsOf[ns, vs]
 
+    type FieldValues[T <: Tuple] <: Tuple = T match
+        case EmptyTuple              => EmptyTuple
+        case Record.`~`[n, v] *: rest => v *: FieldValues[rest]
+
     type ZipLookup[N <: String, T <: Tuple] = T match
         case (N ~ v) *: _ => v
         case _ *: rest    => ZipLookup[N, rest]
@@ -196,11 +183,6 @@ object Record:
       */
     def fromProduct[A](value: A)(using ar: AsRecord[A]): Record[ar.Fields] = ar.asRecord(value)
 
-    /** Creates a Record from a Row.
-      */
-    inline def fromRow[A <: NamedTuple.AnyNamedTuple](row: Row[A]): Record[Row.ToRecordFields[Row.Names[A], Row.Values[A]]] =
-        row.toRecord
-
     /** A field in a Record, containing a name and associated type information.
       *
       * @param name
@@ -217,8 +199,8 @@ object Record:
         inline def fields(using ti: TypeIntersection[Fields]): List[String] =
             collectFieldNames[ti.AsTuple]
 
-        inline def values(using ti: TypeIntersection[Fields]): Row.FieldValues[ti.AsTuple] =
-            collectValues[ti.AsTuple](self.toMap).asInstanceOf[Row.FieldValues[ti.AsTuple]]
+        inline def values(using ti: TypeIntersection[Fields]): FieldValues[ti.AsTuple] =
+            collectValues[ti.AsTuple](self.toMap).asInstanceOf[FieldValues[ti.AsTuple]]
 
         def update[Name <: String & Singleton, Value](name: Name, value: Value)(using
             @implicitNotFound("""

kyo-data/shared/src/main/scala/kyo/Row.scala

@@ -105,13 +105,6 @@ class RecordTest extends Test:
             assert(record.value == 42)
         }
 
-        "fromRow" in {
-            val row    = Row((name = "Alice", age = 30))
-            val record = Record.fromRow(row)
-            typeCheck("""val _: Record["name" ~ String & "age" ~ Int] = record""")
-            assert(record.name == "Alice")
-            assert(record.age == 30)
-        }
     }
 
     "map" in {
@@ -1077,23 +1070,6 @@ class RecordTest extends Test:
         }
     }
 
-    "fromRow edge cases" - {
-        "single field" in {
-            val row    = Row((name = "Alice"))
-            val record = Record.fromRow(row)
-            typeCheck("""val _: Record["name" ~ String] = record""")
-            assert(record.name == "Alice")
-        }
-
-        "three fields with complex types" in {
-            val row    = Row((name = "Alice", scores = List(1, 2, 3), active = true))
-            val record = Record.fromRow(row)
-            assert(record.name == "Alice")
-            assert(record.scores == List(1, 2, 3))
-            assert(record.active == true)
-        }
-    }
-
     "Render edge cases" - {
         "render with duplicate field names" in {
             val record   = "x" ~ 1 & "x" ~ "hello"