Reuse Field

Author: filosganga

modules/core/jvm/src/main/scala/internal/decoding.scala

@@ -177,17 +177,30 @@ object decoding {
           var error: ReadError = null
 
           while (i < record.fields.length && error == null) {
-            val field = record.fields(i)
-            map.get(field.name) match {
-              case None =>
-                error = ReadError(
-                  s"required field ${field.name} does not contain a value"
-                )
-              case Some(value) =>
-                field.schema.read(value) match {
-                  case Left(err) => error = err
-                  case Right(v) => decodedValues(i) = v
+            record.fields(i) match {
+              case Field.Optional(name, schema, get) =>
+                map.get(name) match {
+                  case None => decodedValues(i) = None
+                  case Some(value) =>
+                    schema.read(value) match {
+                      case Left(err) => error = err
+                      case Right(v) => decodedValues(i) = Some(v)
+                    }
                 }
+
+              case Field.Required(name, schema, get) =>
+                map.get(name) match {
+                  case None =>
+                    error = ReadError(
+                      s"required field $name does not contain a value"
+                    )
+                  case Some(value) =>
+                    schema.read(value) match {
+                      case Left(err) => error = err
+                      case Right(v) => decodedValues(i) = v
+                    }
+                }
+
             }
             i += 1
           }

modules/core/jvm/src/main/scala/internal/encoding.scala

@@ -111,13 +111,24 @@ object encoding {
 
         val map =
           new java.util.IdentityHashMap[String, AttributeValue](fieldCount)
+
         while (i < record.fields.length && error == null) {
-          val field = record.fields(i)
-          val fieldValue = field.get(value)
-          field.schema.write(fieldValue.asInstanceOf[field.A]) match {
-            case Left(err) => error = err
-            case Right(v) => map.put(fieldNames(i), v.value)
+          record.fields(i) match {
+            case Field.Required(name, schema, get) =>
+              schema.write(get(value)) match {
+                case Left(err) => error = err
+                case Right(v) => map.put(name, v.value)
+              }
+            case Field.Optional(name, schema, get) =>
+              val fieldValue = get(value)
+              if (fieldValue != None) {
+                schema.write(fieldValue.get) match {
+                  case Left(err) => error = err
+                  case Right(v) => map.put(name, v.value)
+                }
+              }
           }
+
           i += 1
         }
 

modules/core/shared/src/main/scala/Schema.scala

@@ -171,29 +171,8 @@ object Schema {
 
   def nullable[A](implicit s: Schema[A]): Schema[Option[A]] = s.nullable
 
-  sealed trait RecordField[R] {
-    type A
-    def name: String
-    def schema: Schema[A]
-    def get: R => A
-  }
-
-  object RecordField {
-    def apply[R, A0](
-        name0: String,
-        schema0: Schema[A0],
-        get0: R => A0
-    ): RecordField[R] =
-      new RecordField[R] {
-        type A = A0
-        def name = name0
-        def schema = schema0
-        def get = get0
-      }
-  }
-
   case class OptimizedRecord[R, A](
-      fields: List[RecordField[R]],
+      fields: List[Field[R, _]],
       build: List[Any] => A
   )
 
@@ -217,9 +196,7 @@ object Schema {
 
         def ap[X, Y](
             ff: OptimizedRecord[R, X => Y]
-        )(
-            fa: OptimizedRecord[R, X]
-        ): OptimizedRecord[R, Y] = {
+        )(fa: OptimizedRecord[R, X]): OptimizedRecord[R, Y] =
           OptimizedRecord(
             ff.fields ++ fa.fields,
             values => {
@@ -230,19 +207,18 @@ object Schema {
               f(x)
             }
           )
-        }
       }
 
     fa.foldMap(new (Field[R, *] ~> λ[α => OptimizedRecord[R, α]]) {
       def apply[X](field: Field[R, X]): OptimizedRecord[R, X] = field match {
-        case Field.Required(name, schema, get) =>
+        case f @ Field.Required(name, schema, get) =>
           OptimizedRecord(
-            List(RecordField(name, schema, get)),
+            List(f),
             values => values.head.asInstanceOf[X]
           )
-        case Field.Optional(name, schema, get) =>
+        case f @ Field.Optional(name, schema, get) =>
           OptimizedRecord(
-            List(RecordField(name, schema.nullable, get)),
+            List(f),
             values => values.head.asInstanceOf[X]
           )
       }
@@ -316,15 +292,16 @@ object Schema {
     case object StrSet extends Schema[NonEmptySet[String]]
     case class Dictionary[A](value: Schema[A]) extends Schema[Map[String, A]]
     case class Sequence[A](value: Schema[A]) extends Schema[List[A]]
+
     case class Record[R](
-        fields: List[RecordField[R]],
+        fields: List[Field[R, ?]],
         build: List[Any] => R,
         fieldNames: Array[String]
     ) extends Schema[R]
 
     object Record {
       def apply[R](
-          fields: List[RecordField[R]],
+          fields: List[Field[R, ?]],
           build: List[Any] => R
       ): Record[R] = {
         val fieldNames = fields.map(_.name).toArray
@@ -336,7 +313,10 @@ object Schema {
     case class Isos[A](value: XMap[A]) extends Schema[A]
     case class Defer[A](value: () => Schema[A]) extends Schema[A]
 
-    sealed trait Field[R, E]
+    sealed trait Field[R, E] {
+      def name: String
+    }
+
     object Field {
       case class Required[R, E](
           name: String,

modules/core/shared/src/test/scala/SchemaSuite.scala

@@ -91,15 +91,14 @@ class SchemaSuite extends ScalaCheckSuite {
 
     val output = schema
       .write(data)
-      .toOption
 
-    assertEquals(output, expected.some, clue(data))
+    assertEquals(output, expected.asRight, clue(data))
 
     val roundTrip = output.flatMap { output =>
-      schema.read(output).toOption
+      schema.read(output)
     }
 
-    assertEquals(roundTrip, data.some)
+    assertEquals(roundTrip, data.asRight)
   }
 
   def checkNotFail[A](schema: Schema[A], data: A) = {