Add dispatch codecs

6 files changed, 137 insertions, 95 deletions

diff --git a/genrecord.ts b/genrecord.ts
index a700dc9..ba3d0e2 100644
--- a/genrecord.ts
+++ b/genrecord.ts
@@ -35,19 +35,18 @@ function argFor(va: string): string {
 function genRecordJoiner(elements: number) {
     if (!elements) return
     const vars = [...new Array(elements)].map((_, idx) => "T" + idx)
-    console.log(`\tpublic static ${typArgs([...vars, 'O', 'Format'])} JsonCodec<O, Format> join(`)
+    console.log(`\tpublic static ${typArgs([...vars, 'O', 'Format'])} MapCodec<O, Format> join(`)
     for (let var1 of vars) {
         console.log(`\t\tRecordCodec<O, ${var1}, Format> ${argFor(var1)},`)
     }
     console.log(`\t\tTuple.Func${elements}${typArgs(['O', ...vars])} joiner`)
     console.log("\t) {")
-    console.log("\t\treturn new RecordCompleteCodec<>() {")
+    console.log("\t\treturn new MapCodec<>() {")
 
     console.log("\t\t\t@Override")
-    console.log("\t\t\tpublic Result<Format, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) {")
+    console.log("\t\t\tpublic Result<RecordBuilder<Format>, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) {")
     console.log(`\t\t\t\treturn Stream.of(${vars.map(it => argFor(it) + ".enc(data, ops)").join(", ")})`)
-    console.log(`\t\t\t\t\t.reduce(Result.ok(ops.createObject()), RecordCodec::merge)`)
-    console.log(`\t\t\t\t\t.map(RecordBuilder::complete);`)
+    console.log(`\t\t\t\t\t.reduce(Result.ok(ops.createObject()), RecordCodec::merge);`)
     console.log("\t\t\t}")
 
     console.log("\t\t\t@Override")
@@ -65,7 +64,6 @@ function genRecords(maxI: number) {
     console.log("package moe.nea.pcj.json;")
     console.log(`
 import moe.nea.pcj.*;
-import moe.nea.pcj.json.RecordCodec.*;
 import java.util.stream.*;`)
     console.log()
     console.log("@SuppressWarnings(\"unused\")")
diff --git a/gson/src/test/java/moe/nea/jcp/gson/test/TestBasic.java b/gson/src/test/java/moe/nea/jcp/gson/test/TestBasic.java
index 70c4345..628518c 100644
--- a/gson/src/test/java/moe/nea/jcp/gson/test/TestBasic.java
+++ b/gson/src/test/java/moe/nea/jcp/gson/test/TestBasic.java
@@ -91,10 +91,17 @@ public class TestBasic {
 		           new UnexpectedJsonElement("number", mkPrim("1")));
 	}
 
+	sealed interface Parent permits OtherTestObject, TestObject {
+	}
+
+	record OtherTestObject(
+			String test
+	) implements Parent {}
+
 	record TestObject(
 			String foo,
 			int bar
-	) {}
+	) implements Parent {}
 
 
 	@Test
@@ -109,7 +116,7 @@ public class TestBasic {
 				codecs.STRING.fieldOf("foo").withGetter(TestObject::foo),
 				codecs.INTEGER.fieldOf("bar").withGetter(TestObject::bar),
 				TestObject::new
-		);
+		).codec();
 		assertSuccess(decode(codec, mkJsonObject("foo", "fooValue", "bar", -10)),
 		              new TestObject("fooValue", -10));
 		assertFail(decode(codec, mkJsonObject("foo", "fooValue")),
@@ -124,7 +131,7 @@ public class TestBasic {
 				codecs.STRING.fieldOf("foo").withGetter(TestObject::foo),
 				codecs.INTEGER.fieldOf("foo").withGetter(TestObject::bar),
 				TestObject::new
-		);
+		).codec();
 		// TODO: add test for decoding with duplicate keys warning (esp. optional fields)
 		assertFail(codec.encode(new TestObject("", 0), GsonOperations.INSTANCE),
 		           new DuplicateJsonKey("foo"));
@@ -138,5 +145,30 @@ public class TestBasic {
 		assertFail(decode(codec, mkJsonArray("foo", mkJsonObject("hello", "bar"))),
 		           new AtIndex(0, new UnexpectedJsonElement("object", mkPrim("foo"))));
 	}
+
+	@Test
+	void testDispatched() {
+		var testObjectCodec = RecordJoiners.join(
+				codecs.STRING.fieldOf("foo").withGetter(TestObject::foo),
+				codecs.INTEGER.fieldOf("bar").withGetter(TestObject::bar),
+				TestObject::new
+		);
+		var otherObjectCodec = RecordJoiners.join(
+				codecs.STRING.fieldOf("test").withGetter(OtherTestObject::test),
+				OtherTestObject::new
+		);
+		codecs.STRING.fieldOf("type")
+		             .<Parent>dispatch(
+				             obj -> switch (obj) {
+					             case OtherTestObject ignored -> "other";
+					             case TestObject ignored -> "normal";
+				             },
+				             key -> switch (key) {
+					             case "other" -> otherObjectCodec;
+					             case "normal" -> testObjectCodec;
+					             default -> throw new AssertionError("Unknown thing");
+				             }
+		             );
+	}
 }
 
diff --git a/src/main/java/moe/nea/pcj/Result.java b/src/main/java/moe/nea/pcj/Result.java
index af5398e..a9c2494 100644
--- a/src/main/java/moe/nea/pcj/Result.java
+++ b/src/main/java/moe/nea/pcj/Result.java
@@ -7,7 +7,6 @@ import java.util.Collections;
 import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
-import java.util.function.Consumer;
 import java.util.function.Function;
 
 public sealed interface Result<Good, Bad> permits Result.Ok, Result.Fail {
@@ -37,6 +36,10 @@ public sealed interface Result<Good, Bad> permits Result.Ok, Result.Fail {
 
 	<NextBad> Result<Good, NextBad> mapErrors(Function<List<Bad>, List<NextBad>> mapper);
 
+	default Result<Good, Bad> appendError(Bad error) {
+		return appendErrors(List.of(error));
+	}
+
 	Result<Good, Bad> appendErrors(List<Bad> error);
 
 	record Ok<Good, Bad>(Good okValue) implements Result<Good, Bad> {
diff --git a/src/main/java/moe/nea/pcj/json/MapCodec.java b/src/main/java/moe/nea/pcj/json/MapCodec.java
index 4b76150..b18a639 100644
--- a/src/main/java/moe/nea/pcj/json/MapCodec.java
+++ b/src/main/java/moe/nea/pcj/json/MapCodec.java
@@ -5,14 +5,49 @@ import moe.nea.pcj.Result;
 import java.util.function.Function;
 
 public interface MapCodec<T, Format> {
-	Result<T, JsonLikeError> decode(
+	Result<? extends T, JsonLikeError> decode(
 			RecordView<Format> record,
 			JsonLikeOperations<Format> ops);
 
 	Result<RecordBuilder<Format>, JsonLikeError> encode(T value, JsonLikeOperations<Format> ops);
 
+	default <O> MapCodec<? extends O, Format> dispatch(
+			Function<? super O, ? extends T> keyExtractor,
+			Function<? super T, MapCodec<? extends O, Format>> codecGenerator
+	) {
+		// TODO: the codecGenerator function is not exactly typesafe. there should be some limit on keyExtractor and codecGenerator working in tandem
+		return new MapCodec<>() {
+			@Override
+			public Result<O, JsonLikeError> decode(RecordView<Format> record, JsonLikeOperations<Format> ops) {
+				return MapCodec.this.decode(record, ops)
+				                    .map(codecGenerator::apply)
+				                    .flatMap(codec -> codec.decode(record, ops));
+			}
+
+			@Override
+			public Result<RecordBuilder<Format>, JsonLikeError> encode(O value, JsonLikeOperations<Format> ops) {
+				var key = keyExtractor.apply(value);
+				var codec = codecGenerator.apply(key);
+				return MapCodec.this
+						.encode(key, ops)
+						.flatMap(keyEncoded -> ((MapCodec<O, Format>) codec).encode(value, ops).flatMap(keyEncoded::mergeWith));
+			}
+		};
+	}
+
 	default JsonCodec<T, Format> codec() {
-		return RecordJoiners.join(withGetter(it -> it), it -> it);
+		return new JsonCodec<>() {
+			@Override
+			public Result<? extends T, ? extends JsonLikeError> decode(Format format, JsonLikeOperations<Format> ops) {
+				return Result.<RecordView<Format>, JsonLikeError>cast(ops.getObject(format))
+				             .flatMap(record -> MapCodec.this.decode(record, ops));
+			}
+
+			@Override
+			public Result<? extends Format, ? extends JsonLikeError> encode(T data, JsonLikeOperations<Format> ops) {
+				return Result.cast(MapCodec.this.encode(data, ops)).map(RecordBuilder::complete);
+			}
+		};
 	}
 
 	default <O> RecordCodec<O, T, Format> withGetter(Function<O, T> getter) {
diff --git a/src/main/java/moe/nea/pcj/json/RecordCodec.java b/src/main/java/moe/nea/pcj/json/RecordCodec.java
index cb6d696..fa7aac7 100644
--- a/src/main/java/moe/nea/pcj/json/RecordCodec.java
+++ b/src/main/java/moe/nea/pcj/json/RecordCodec.java
@@ -14,21 +14,10 @@ public record RecordCodec<O, T, Format>(
 	}
 
 	Result<T, JsonLikeError> dec(RecordView<Format> data, JsonLikeOperations<Format> ops) {
-		return codec().decode(data, ops);
+		return Result.cast(codec().decode(data, ops));
 	}
 
 	static <Format> Result<RecordBuilder<Format>, JsonLikeError> merge(Result<RecordBuilder<Format>, JsonLikeError> left, Result<RecordBuilder<Format>, JsonLikeError> right) {
 		return left.flatMap(l -> right.flatMap(l::mergeWith));
 	}
-
-	abstract static class RecordCompleteCodec<O, Format> implements JsonCodec<O, Format> {
-		@Override
-		public Result<O, JsonLikeError> decode(Format format, JsonLikeOperations<Format> ops) {
-			return Result.<RecordView<Format>, JsonLikeError>cast(ops.getObject(format))
-			             .flatMap(record -> (decode(record, ops)));
-		}
-
-		protected abstract Result<O, JsonLikeError> decode(RecordView<Format> record, JsonLikeOperations<Format> ops);
-	}
-
 }
diff --git a/src/main/java/moe/nea/pcj/json/RecordJoiners.java b/src/main/java/moe/nea/pcj/json/RecordJoiners.java
index 3af622d..57bdd63 100644
--- a/src/main/java/moe/nea/pcj/json/RecordJoiners.java
+++ b/src/main/java/moe/nea/pcj/json/RecordJoiners.java
@@ -2,21 +2,19 @@
 package moe.nea.pcj.json;
 
 import moe.nea.pcj.*;
-import moe.nea.pcj.json.RecordCodec.*;
 import java.util.stream.*;
 
 @SuppressWarnings("unused")
 public class RecordJoiners {
-	public static <T0, O, Format> JsonCodec<O, Format> join(
+	public static <T0, O, Format> MapCodec<O, Format> join(
 			RecordCodec<O, T0, Format> arg0,
 			Tuple.Func1<O, T0> joiner
 	) {
-		return new RecordCompleteCodec<>() {
+		return new MapCodec<>() {
 			@Override
-			public Result<Format, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) {
+			public Result<RecordBuilder<Format>, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) {
 				return Stream.of(arg0.enc(data, ops))
-				             .reduce(Result.ok(ops.createObject()), RecordCodec::merge)
-				             .map(RecordBuilder::complete);
+				             .reduce(Result.ok(ops.createObject()), RecordCodec::merge);
 			}
 			@Override
 			public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) {
@@ -25,17 +23,16 @@ public class RecordJoiners {
 			}
 		};
 	}
-	public static <T0, T1, O, Format> JsonCodec<O, Format> join(
+	public static <T0, T1, O, Format> MapCodec<O, Format> join(
 			RecordCodec<O, T0, Format> arg0,
 			RecordCodec<O, T1, Format> arg1,
 			Tuple.Func2<O, T0, T1> joiner
 	) {
-		return new RecordCompleteCodec<>() {
+		return new MapCodec<>() {
 			@Override
-			public Result<Format, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) {
+			public Result<RecordBuilder<Format>, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) {
 				return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops))
-				             .reduce(Result.ok(ops.createObject()), RecordCodec::merge)
-				             .map(RecordBuilder::complete);
+				             .reduce(Result.ok(ops.createObject()), RecordCodec::merge);
 			}
 			@Override
 			public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) {
@@ -44,18 +41,17 @@ public class RecordJoiners {
 			}
 		};
 	}
-	public static <T0, T1, T2, O, Format> JsonCodec<O, Format> join(
+	public static <T0, T1, T2, O, Format> MapCodec<O, Format> join(
 			RecordCodec<O, T0, Format> arg0,
 			RecordCodec<O, T1, Format> arg1,
 			RecordCodec<O, T2, Format> arg2,
 			Tuple.Func3<O, T0, T1, T2> joiner
 	) {
-		return new RecordCompleteCodec<>() {
+		return new MapCodec<>() {
 			@Override
-			public Result<Format, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) {
+			public Result<RecordBuilder<Format>, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) {
 				return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops), arg2.enc(data, ops))
-				             .reduce(Result.ok(ops.createObject()), RecordCodec::merge)
-				             .map(RecordBuilder::complete);
+				             .reduce(Result.ok(ops.createObject()), RecordCodec::merge);
 			}
 			@Override
 			public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) {
@@ -64,19 +60,18 @@ public class RecordJoiners {
 			}
 		};
 	}
-	public static <T0, T1, T2, T3, O, Format> JsonCodec<O, Format> join(
+	public static <T0, T1, T2, T3, O, Format> MapCodec<O, Format> join(
 			RecordCodec<O, T0, Format> arg0,
 			RecordCodec<O, T1, Format> arg1,
 			RecordCodec<O, T2, Format> arg2,
 			RecordCodec<O, T3, Format> arg3,
 			Tuple.Func4<O, T0, T1, T2, T3> joiner
 	) {
-		return new RecordCompleteCodec<>() {
+		return new MapCodec<>() {
 			@Override
-			public Result<Format, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) {
+			public Result<RecordBuilder<Format>, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) {
 				return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops), arg2.enc(data, ops), arg3.enc(data, ops))
-				             .reduce(Result.ok(ops.createObject()), RecordCodec::merge)
-				             .map(RecordBuilder::complete);
+				             .reduce(Result.ok(ops.createObject()), RecordCodec::merge);
 			}
 			@Override
 			public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) {
@@ -85,7 +80,7 @@ public class RecordJoiners {
 			}
 		};
 	}
-	public static <T0, T1, T2, T3, T4, O, Format> JsonCodec<O, Format> join(
+	public static <T0, T1, T2, T3, T4, O, Format> MapCodec<O, Format> join(
 			RecordCodec<O, T0, Format> arg0,
 			RecordCodec<O, T1, Format> arg1,
 			RecordCodec<O, T2, Format> arg2,
@@ -93,12 +88,11 @@ public class RecordJoiners {
 			RecordCodec<O, T4, Format> arg4,
 			Tuple.Func5<O, T0, T1, T2, T3, T4> joiner
 	) {
-		return new RecordCompleteCodec<>() {
+		return new MapCodec<>() {
 			@Override
-			public Result<Format, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) {
+			public Result<RecordBuilder<Format>, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) {
 				return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops), arg2.enc(data, ops), arg3.enc(data, ops), arg4.enc(data, ops))
-				             .reduce(Result.ok(ops.createObject()), RecordCodec::merge)
-				             .map(RecordBuilder::complete);
+				             .reduce(Result.ok(ops.createObject()), RecordCodec::merge);
 			}
 			@Override
 			public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) {
@@ -107,7 +101,7 @@ public class RecordJoiners {
 			}
 		};
 	}
-	public static <T0, T1, T2, T3, T4, T5, O, Format> JsonCodec<O, Format> join(
+	public static <T0, T1, T2, T3, T4, T5, O, Format> MapCodec<O, Format> join(
 			RecordCodec<O, T0, Format> arg0,
 			RecordCodec<O, T1, Format> arg1,
 			RecordCodec<O, T2, Format> arg2,
@@ -116,12 +110,11 @@ public class RecordJoiners {
 			RecordCodec<O, T5, Format> arg5,
 			Tuple.Func6<O, T0, T1, T2, T3, T4, T5> joiner
 	) {
-		return new RecordCompleteCodec<>() {
+		return new MapCodec<>() {
 			@Override
-			public Result<Format, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) {
+			public Result<RecordBuilder<Format>, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) {
 				return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops), arg2.enc(data, ops), arg3.enc(data, ops), arg4.enc(data, ops), arg5.enc(data, ops))
-				             .reduce(Result.ok(ops.createObject()), RecordCodec::merge)
-				             .map(RecordBuilder::complete);
+				             .reduce(Result.ok(ops.createObject()), RecordCodec::merge);
 			}
 			@Override
 			public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) {
@@ -130,7 +123,7 @@ public class RecordJoiners {
 			}
 		};
 	}
-	public static <T0, T1, T2, T3, T4, T5, T6, O, Format> JsonCodec<O, Format> join(
+	public static <T0, T1, T2, T3, T4, T5, T6, O, Format> MapCodec<O, Format> join(
 			RecordCodec<O, T0, Format> arg0,
 			RecordCodec<O, T1, Format> arg1,
 			RecordCodec<O, T2, Format> arg2,
@@ -140,12 +133,11 @@ public class RecordJoiners {
 			RecordCodec<O, T6, Format> arg6,
 			Tuple.Func7<O, T0, T1, T2, T3, T4, T5, T6> joiner
 	) {
-		return new RecordCompleteCodec<>() {
+		return new MapCodec<>() {
 			@Override
-			public Result<Format, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) {
+			public Result<RecordBuilder<Format>, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) {
 				return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops), arg2.enc(data, ops), arg3.enc(data, ops), arg4.enc(data, ops), arg5.enc(data, ops), arg6.enc(data, ops))
-				             .reduce(Result.ok(ops.createObject()), RecordCodec::merge)
-				             .map(RecordBuilder::complete);
+				             .reduce(Result.ok(ops.createObject()), RecordCodec::merge);
 			}
 			@Override
 			public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) {
@@ -154,7 +146,7 @@ public class RecordJoiners {
 			}
 		};
 	}
-	public static <T0, T1, T2, T3, T4, T5, T6, T7, O, Format> JsonCodec<O, Format> join(
+	public static <T0, T1, T2, T3, T4, T5, T6, T7, O, Format> MapCodec<O, Format> join(
 			RecordCodec<O, T0, Format> arg0,
 			RecordCodec<O, T1, Format> arg1,
 			RecordCodec<O, T2, Format> arg2,
@@ -165,12 +157,11 @@ public class RecordJoiners {
 			RecordCodec<O, T7, Format> arg7,
 			Tuple.Func8<O, T0, T1, T2, T3, T4, T5, T6, T7> joiner
 	) {
-		return new RecordCompleteCodec<>() {
+		return new MapCodec<>() {
 			@Override
-			public Result<Format, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) {
+			public Result<RecordBuilder<Format>, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) {
 				return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops), arg2.enc(data, ops), arg3.enc(data, ops), arg4.enc(data, ops), arg5.enc(data, ops), arg6.enc(data, ops), arg7.enc(data, ops))
-				             .reduce(Result.ok(ops.createObject()), RecordCodec::merge)
-				             .map(RecordBuilder::complete);
+				             .reduce(Result.ok(ops.createObject()), RecordCodec::merge);
 			}
 			@Override
 			public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) {
@@ -179,7 +170,7 @@ public class RecordJoiners {
 			}
 		};
 	}
-	public static <T0, T1, T2, T3, T4, T5, T6, T7, T8, O, Format> JsonCodec<O, Format> join(
+	public static <T0, T1, T2, T3, T4, T5, T6, T7, T8, O, Format> MapCodec<O, Format> join(
 			RecordCodec<O, T0, Format> arg0,
 			RecordCodec<O, T1, Format> arg1,
 			RecordCodec<O, T2, Format> arg2,
@@ -191,12 +182,11 @@ public class RecordJoiners {
 			RecordCodec<O, T8, Format> arg8,
 			Tuple.Func9<O, T0, T1, T2, T3, T4, T5, T6, T7, T8> joiner
 	) {
-		return new RecordCompleteCodec<>() {
+		return new MapCodec<>() {
 			@Override
-			public Result<Format, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) {
+			public Result<RecordBuilder<Format>, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) {
 				return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops), arg2.enc(data, ops), arg3.enc(data, ops), arg4.enc(data, ops), arg5.enc(data, ops), arg6.enc(data, ops), arg7.enc(data, ops), arg8.enc(data, ops))
-				             .reduce(Result.ok(ops.createObject()), RecordCodec::merge)
-				             .map(RecordBuilder::complete);
+				             .reduce(Result.ok(ops.createObject()), RecordCodec::merge);
 			}
 			@Override
 			public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) {
@@ -205,7 +195,7 @@ public class RecordJoiners {
 			}
 		};
 	}
-	public static <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, O, Format> JsonCodec<O, Format> join(
+	public static <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, O, Format> MapCodec<O, Format> join(
 			RecordCodec<O, T0, Format> arg0,
 			RecordCodec<O, T1, Format> arg1,
 			RecordCodec<O, T2, Format> arg2,
@@ -218,12 +208,11 @@ public class RecordJoiners {
 			RecordCodec<O, T9, Format> arg9,
 			Tuple.Func10<O, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> joiner
 	) {
-		return new RecordCompleteCodec<>() {
+		return new MapCodec<>() {
 			@Override
-			public Result<Format, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) {
+			public Result<RecordBuilder<Format>, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) {
 				return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops), arg2.enc(data, ops), arg3.enc(data, ops), arg4.enc(data, ops), arg5.enc(data, ops), arg6.enc(data, ops), arg7.enc(data, ops), arg8.enc(data, ops), arg9.enc(data, ops))
-				             .reduce(Result.ok(ops.createObject()), RecordCodec::merge)
-				             .map(RecordBuilder::complete);
+				             .reduce(Result.ok(ops.createObject()), RecordCodec::merge);
 			}
 			@Override
 			public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) {
@@ -232,7 +221,7 @@ public class RecordJoiners {
 			}
 		};
 	}
-	public static <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, O, Format> JsonCodec<O, Format> join(
+	public static <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, O, Format> MapCodec<O, Format> join(
 			RecordCodec<O, T0, Format> arg0,
 			RecordCodec<O, T1, Format> arg1,
 			RecordCodec<O, T2, Format> arg2,
@@ -246,12 +235,11 @@ public class RecordJoiners {
 			RecordCodec<O, T10, Format> arg10,
 			Tuple.Func11<O, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> joiner
 	) {
-		return new RecordCompleteCodec<>() {
+		return new MapCodec<>() {
 			@Override
-			public Result<Format, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) {
+			public Result<RecordBuilder<Format>, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) {
 				return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops), arg2.enc(data, ops), arg3.enc(data, ops), arg4.enc(data, ops), arg5.enc(data, ops), arg6.enc(data, ops), arg7.enc(data, ops), arg8.enc(data, ops), arg9.enc(data, ops), arg10.enc(data, ops))
-				             .reduce(Result.ok(ops.createObject()), RecordCodec::merge)
-				             .map(RecordBuilder::complete);
+				             .reduce(Result.ok(ops.createObject()), RecordCodec::merge);
 			}
 			@Override
 			public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) {
@@ -260,7 +248,7 @@ public class RecordJoiners {
 			}
 		};
 	}
-	public static <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, O, Format> JsonCodec<O, Format> join(
+	public static <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, O, Format> MapCodec<O, Format> join(
 			RecordCodec<O, T0, Format> arg0,
 			RecordCodec<O, T1, Format> arg1,
 			RecordCodec<O, T2, Format> arg2,
@@ -275,12 +263,11 @@ public class RecordJoiners {
 			RecordCodec<O, T11, Format> arg11,
 			Tuple.Func12<O, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> joiner
 	) {
-		return new RecordCompleteCodec<>() {
+		return new MapCodec<>() {
 			@Override
-			public Result<Format, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) {
+			public Result<RecordBuilder<Format>, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) {
 				return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops), arg2.enc(data, ops), arg3.enc(data, ops), arg4.enc(data, ops), arg5.enc(data, ops), arg6.enc(data, ops), arg7.enc(data, ops), arg8.enc(data, ops), arg9.enc(data, ops), arg10.enc(data, ops), arg11.enc(data, ops))
-				             .reduce(Result.ok(ops.createObject()), RecordCodec::merge)
-				             .map(RecordBuilder::complete);
+				             .reduce(Result.ok(ops.createObject()), RecordCodec::merge);
 			}
 			@Override
 			public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) {
@@ -289,7 +276,7 @@ public class RecordJoiners {
 			}
 		};
 	}
-	public static <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, O, Format> JsonCodec<O, Format> join(
+	public static <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, O, Format> MapCodec<O, Format> join(
 			RecordCodec<O, T0, Format> arg0,
 			RecordCodec<O, T1, Format> arg1,
 			RecordCodec<O, T2, Format> arg2,
@@ -305,12 +292,11 @@ public class RecordJoiners {
 			RecordCodec<O, T12, Format> arg12,
 			Tuple.Func13<O, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> joiner
 	) {
-		return new RecordCompleteCodec<>() {
+		return new MapCodec<>() {
 			@Override
-			public Result<Format, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) {
+			public Result<RecordBuilder<Format>, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) {
 				return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops), arg2.enc(data, ops), arg3.enc(data, ops), arg4.enc(data, ops), arg5.enc(data, ops), arg6.enc(data, ops), arg7.enc(data, ops), arg8.enc(data, ops), arg9.enc(data, ops), arg10.enc(data, ops), arg11.enc(data, ops), arg12.enc(data, ops))
-				             .reduce(Result.ok(ops.createObject()), RecordCodec::merge)
-				             .map(RecordBuilder::complete);
+				             .reduce(Result.ok(ops.createObject()), RecordCodec::merge);
 			}
 			@Override
 			public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) {
@@ -319,7 +305,7 @@ public class RecordJoiners {
 			}
 		};
 	}
-	public static <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, O, Format> JsonCodec<O, Format> join(
+	public static <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, O, Format> MapCodec<O, Format> join(
 			RecordCodec<O, T0, Format> arg0,
 			RecordCodec<O, T1, Format> arg1,
 			RecordCodec<O, T2, Format> arg2,
@@ -336,12 +322,11 @@ public class RecordJoiners {
 			RecordCodec<O, T13, Format> arg13,
 			Tuple.Func14<O, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> joiner
 	) {
-		return new RecordCompleteCodec<>() {
+		return new MapCodec<>() {
 			@Override
-			public Result<Format, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) {
+			public Result<RecordBuilder<Format>, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) {
 				return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops), arg2.enc(data, ops), arg3.enc(data, ops), arg4.enc(data, ops), arg5.enc(data, ops), arg6.enc(data, ops), arg7.enc(data, ops), arg8.enc(data, ops), arg9.enc(data, ops), arg10.enc(data, ops), arg11.enc(data, ops), arg12.enc(data, ops), arg13.enc(data, ops))
-				             .reduce(Result.ok(ops.createObject()), RecordCodec::merge)
-				             .map(RecordBuilder::complete);
+				             .reduce(Result.ok(ops.createObject()), RecordCodec::merge);
 			}
 			@Override
 			public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) {