10 files changed, 549 insertions, 40 deletions
diff --git a/build.gradle.kts b/build.gradle.kts
index 07e279f..29f3043 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -12,7 +12,15 @@ allprojects {
 dependencies {
 	api("org.jspecify:jspecify:1.0.0")
 }
-
-tasks.test {
-	useJUnitPlatform()
+allprojects {
+	afterEvaluate {
+		if (project.plugins.hasPlugin(JavaBasePlugin::class.java))
+			dependencies {
+				testImplementation("org.junit.jupiter:junit-jupiter-api:5.8.1")
+				testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:5.8.1")
+			}
+	}
+	tasks.withType(Test::class) {
+		useJUnitPlatform()
+	}
 }
 \ No newline at end of file
diff --git a/genrecord.ts b/genrecord.ts
index e69de29..a700dc9 100644
--- a/genrecord.ts
+++ b/genrecord.ts
@@ -0,0 +1,80 @@
+#!/usr/bin/env node --experimental-strip-types
+function typArgs(a: string[]): string {
+    if (a.length == 0) return ""
+    return "<" + a.join(", ") + ">"
+}
+
+function argFor(va: string): string {
+    return va.replace("T", "arg")
+}
+
+/*	public static <T1, T2, O, Format> JsonCodec<O, Format> join(
+			RecordCodec<O, T1, Format> arg1,
+			RecordCodec<O, T2, Format> arg2,
+			Tuple.Func2<O, T1, T2> joiner
+	) {
+		return new RecordCompleteCodec<>() {
+
+			@Override
+			public Result<Format, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) {
+				return Stream.of(arg1.enc(data, ops), arg2.enc(data, ops))
+				             .reduce(Result.ok(ops.createObject()), RecordCodec::merge)
+				             .map(RecordBuilder::complete);
+			}
+
+			@Override
+			public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) {
+				return Tuple.Tuple2.collect(new Tuple.Tuple2<>(arg1, arg2)
+						                            .map(it -> it.dec(format, ops), it -> it.dec(format, ops)))
+				                   .map(it -> it.applyTo(joiner));
+			}
+		};
+	}
+*/
+
+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(`)
+    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\t\t@Override")
+    console.log("\t\t\tpublic Result<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}")
+
+    console.log("\t\t\t@Override")
+    console.log("\t\t\tpublic Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) {")
+    console.log(`\t\t\t\treturn Tuple.Tuple${elements}.collect(new Tuple.Tuple${elements}${elements ? '<>' : ''}(${vars.map(it => argFor(it) + ".dec(format, ops)").join(", ")}))`)
+    console.log("\t\t\t\t\t.map(it -> it.applyTo(joiner));")
+    console.log("\t\t\t}")
+
+    console.log("\t\t};")
+    console.log("\t}")
+}
+
+function genRecords(maxI: number) {
+    console.log("// @gen" + "erated by genrecord.ts")
+    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\")")
+    console.log("public class RecordJoiners {")
+    for (let i = 0; i < maxI; i++) {
+        genRecordJoiner(i)
+    }
+    console.log("}")
+}
+
+genRecords(15)
+
diff --git a/gson/src/main/java/moe/nea/jcp/gson/GsonListBuilder.java b/gson/src/main/java/moe/nea/jcp/gson/GsonListBuilder.java
index d1a6302..5e37a87 100644
--- a/gson/src/main/java/moe/nea/jcp/gson/GsonListBuilder.java
+++ b/gson/src/main/java/moe/nea/jcp/gson/GsonListBuilder.java
@@ -4,7 +4,7 @@ import com.google.gson.JsonArray;
 import com.google.gson.JsonElement;
 import moe.nea.pcj.json.ListBuilder;
 
-public class GsonListBuilder extends GsonListView implements ListBuilder<JsonArray, JsonElement> {
+public class GsonListBuilder extends GsonListView implements ListBuilder<JsonElement> {
 
 	public GsonListBuilder() {
 		super(new JsonArray());
diff --git a/gson/src/main/java/moe/nea/jcp/gson/GsonOperations.java b/gson/src/main/java/moe/nea/jcp/gson/GsonOperations.java
index 7957d05..344c9a5 100644
--- a/gson/src/main/java/moe/nea/jcp/gson/GsonOperations.java
+++ b/gson/src/main/java/moe/nea/jcp/gson/GsonOperations.java
@@ -16,6 +16,8 @@ import moe.nea.pcj.Unit;
 import moe.nea.pcj.json.UnexpectedJsonElement;
 
 public class GsonOperations implements JsonLikeOperations<JsonElement> {
+	public static final GsonOperations INSTANCE = new GsonOperations();
+
 	@Override
 	public JsonElement createNull(Unit value) {
 		return JsonNull.INSTANCE;
@@ -80,7 +82,7 @@ public class GsonOperations implements JsonLikeOperations<JsonElement> {
 	}
 
 	@Override
-	public ListBuilder<JsonArray, JsonElement> createList() {
+	public ListBuilder<JsonElement> createList() {
 		return new GsonListBuilder();
 	}
 
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
new file mode 100644
index 0000000..c0e42b6
--- /dev/null
+++ b/gson/src/test/java/moe/nea/jcp/gson/test/TestBasic.java
@@ -0,0 +1,95 @@
+package moe.nea.jcp.gson.test;
+
+import com.google.gson.JsonElement;
+import com.google.gson.JsonNull;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonPrimitive;
+import moe.nea.jcp.gson.GsonCodecs;
+import moe.nea.jcp.gson.GsonOperations;
+import moe.nea.pcj.Decode;
+import moe.nea.pcj.Result;
+import moe.nea.pcj.json.JsonLikeError;
+import moe.nea.pcj.json.JsonLikeOperations;
+import moe.nea.pcj.json.MissingKey;
+import moe.nea.pcj.json.RecordJoiners;
+import moe.nea.pcj.json.UnexpectedJsonElement;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.stream.Collectors;
+
+public class TestBasic {
+	private <T> void assertFail(Result<T, ?> result, JsonLikeError... expectedError) {
+		if (result.isOk())
+			throw new AssertionError("Expected fail");
+		Assertions.assertEquals(
+				Arrays.stream(expectedError).collect(Collectors.toSet()),
+				new HashSet<>(result.errors())
+		);
+	}
+
+	private <T> void assertSuccess(Result<T, ?> result, T expected) {
+		for (Object error : result.errors()) {
+			throw new AssertionError(error.toString());
+		}
+		Assertions.assertEquals(expected, result.valueOrPartial().get());
+	}
+
+	<T> Result<T, JsonLikeError> decode(Decode<T, JsonElement, JsonLikeOperations<JsonElement>, JsonLikeError> decode, JsonElement element) {
+		return Result.cast(decode.decode(element, GsonOperations.INSTANCE));
+	}
+
+	GsonCodecs codecs = GsonCodecs.INSTANCE;
+
+	@Test
+	void testString() {
+		assertSuccess(decode(codecs.STRING, new JsonPrimitive("test")), "test");
+	}
+
+	@Test
+	void testInt() {
+		assertSuccess(decode(codecs.INTEGER, new JsonPrimitive(1000)), 1000);
+		assertFail(decode(codecs.INTEGER, new JsonPrimitive("hehehe")),
+		           new UnexpectedJsonElement("number", mkPrim("hehehe")));
+		assertFail(decode(codecs.INTEGER, new JsonPrimitive("1")),
+		           new UnexpectedJsonElement("number", mkPrim("1")));
+	}
+
+	record TestObject(
+			String foo,
+			int bar
+	) {}
+
+	static JsonElement mkPrim(Object arg) {
+		if (arg instanceof JsonElement el) return el;
+		if (arg instanceof String str) return new JsonPrimitive(str);
+		if (arg instanceof Number num) return new JsonPrimitive(num);
+		if (arg == null) return JsonNull.INSTANCE;
+		if (arg instanceof Boolean b) return new JsonPrimitive(b);
+		throw new IllegalArgumentException("Cannot convert " + arg + " to json object");
+	}
+
+	static JsonObject mkJsonObject(Object... args) {
+		JsonObject obj = new JsonObject();
+		for (int i = 0; i < args.length; i += 2) {
+			obj.add((String) args[i], mkPrim(args[i + 1]));
+		}
+		return obj;
+	}
+
+	@Test
+	void testObject() {
+		var codec = RecordJoiners.join(
+				codecs.STRING.fieldOf("foo").withGetter(TestObject::foo),
+				codecs.INTEGER.fieldOf("bar").withGetter(TestObject::bar),
+				TestObject::new
+		);
+		assertSuccess(decode(codec, mkJsonObject("foo", "fooValue", "bar", -10)),
+		              new TestObject("fooValue", -10));
+		assertFail(decode(codec, mkJsonObject("foo", "fooValue")),
+		           new MissingKey("bar"));
+	}
+}
+
diff --git a/src/main/java/moe/nea/pcj/json/BasicCodecs.java b/src/main/java/moe/nea/pcj/json/BasicCodecs.java
index 8f957f9..565711d 100644
--- a/src/main/java/moe/nea/pcj/json/BasicCodecs.java
+++ b/src/main/java/moe/nea/pcj/json/BasicCodecs.java
@@ -44,8 +44,4 @@ public class BasicCodecs<Format> {
 			return Result.ok(ops.createNumeric(data));
 		}
 	};
-
-	public <T> JsonCodec<T, Format> objectCodec() {
-
-	}
 }
 \ No newline at end of file
diff --git a/src/main/java/moe/nea/pcj/json/JsonLikeOperations.java b/src/main/java/moe/nea/pcj/json/JsonLikeOperations.java
index 7bb0162..ffefeda 100644
--- a/src/main/java/moe/nea/pcj/json/JsonLikeOperations.java
+++ b/src/main/java/moe/nea/pcj/json/JsonLikeOperations.java
@@ -26,7 +26,7 @@ public interface JsonLikeOperations<Format> extends Operation<Format> {
 
 	Result<? extends RecordView<Format>, ? extends JsonLikeError> getObject(Format format);
 
-	ListBuilder<Format, Format> createList();
+	ListBuilder<Format> createList();
 
 	Result<? extends ListView<Format>, ? extends JsonLikeError> getList(Format format);
 }
diff --git a/src/main/java/moe/nea/pcj/json/ListBuilder.java b/src/main/java/moe/nea/pcj/json/ListBuilder.java
index c6e9220..fd2a407 100644
--- a/src/main/java/moe/nea/pcj/json/ListBuilder.java
+++ b/src/main/java/moe/nea/pcj/json/ListBuilder.java
@@ -1,7 +1,7 @@
 package moe.nea.pcj.json;
 
-public interface ListBuilder<Format, ElementFormat> extends ListView<ElementFormat> {
-	Format complete();
+public interface ListBuilder<ElementFormat> extends ListView<ElementFormat> {
+	ElementFormat complete();
 
 	void add(ElementFormat value);
 
diff --git a/src/main/java/moe/nea/pcj/json/RecordCodec.java b/src/main/java/moe/nea/pcj/json/RecordCodec.java
index 7ba8815..cb6d696 100644
--- a/src/main/java/moe/nea/pcj/json/RecordCodec.java
+++ b/src/main/java/moe/nea/pcj/json/RecordCodec.java
@@ -1,26 +1,23 @@
 package moe.nea.pcj.json;
 
-import moe.nea.pcj.Codec;
 import moe.nea.pcj.Result;
-import moe.nea.pcj.Tuple;
 
 import java.util.function.Function;
-import java.util.stream.Stream;
 
 public record RecordCodec<O, T, Format>(
 		MapCodec<T, Format> codec,
 		Function<O, T> getter
 ) {
 
-	private Result<RecordBuilder<Format>, JsonLikeError> enc(O data, JsonLikeOperations<Format> ops) {
+	Result<RecordBuilder<Format>, JsonLikeError> enc(O data, JsonLikeOperations<Format> ops) {
 		return codec().encode(getter().apply(data), ops);
 	}
 
-	private Result<T, JsonLikeError> dec(RecordView<Format> data, JsonLikeOperations<Format> ops) {
+	Result<T, JsonLikeError> dec(RecordView<Format> data, JsonLikeOperations<Format> ops) {
 		return codec().decode(data, ops);
 	}
 
-	private static <Format> Result<RecordBuilder<Format>, JsonLikeError> merge(Result<RecordBuilder<Format>, JsonLikeError> left, Result<RecordBuilder<Format>, JsonLikeError> right) {
+	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));
 	}
 
@@ -34,26 +31,4 @@ public record RecordCodec<O, T, Format>(
 		protected abstract Result<O, JsonLikeError> decode(RecordView<Format> record, JsonLikeOperations<Format> ops);
 	}
 
-	public static <T1, T2, O, Format> JsonCodec<O, Format> join(
-			RecordCodec<O, T1, Format> arg1,
-			RecordCodec<O, T2, Format> arg2,
-			Tuple.Func2<O, T1, T2> joiner
-	) {
-		return new RecordCompleteCodec<>() {
-
-			@Override
-			public Result<Format, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) {
-				return Stream.of(arg1.enc(data, ops), arg2.enc(data, ops))
-				             .reduce(Result.ok(ops.createObject()), RecordCodec::merge)
-				             .map(RecordBuilder::complete);
-			}
-
-			@Override
-			public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) {
-				return Tuple.Tuple2.collect(new Tuple.Tuple2<>(arg1, arg2)
-						                            .map(it -> it.dec(format, ops), it -> it.dec(format, ops)))
-				                   .map(it -> it.applyTo(joiner));
-			}
-		};
-	}
 }
diff --git a/src/main/java/moe/nea/pcj/json/RecordJoiners.java b/src/main/java/moe/nea/pcj/json/RecordJoiners.java
new file mode 100644
index 0000000..3af622d
--- /dev/null
+++ b/src/main/java/moe/nea/pcj/json/RecordJoiners.java
@@ -0,0 +1,353 @@
+// @generated by genrecord.ts
+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(
+			RecordCodec<O, T0, Format> arg0,
+			Tuple.Func1<O, T0> joiner
+	) {
+		return new RecordCompleteCodec<>() {
+			@Override
+			public Result<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);
+			}
+			@Override
+			public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) {
+				return Tuple.Tuple1.collect(new Tuple.Tuple1<>(arg0.dec(format, ops)))
+				                   .map(it -> it.applyTo(joiner));
+			}
+		};
+	}
+	public static <T0, T1, O, Format> JsonCodec<O, Format> join(
+			RecordCodec<O, T0, Format> arg0,
+			RecordCodec<O, T1, Format> arg1,
+			Tuple.Func2<O, T0, T1> joiner
+	) {
+		return new RecordCompleteCodec<>() {
+			@Override
+			public Result<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);
+			}
+			@Override
+			public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) {
+				return Tuple.Tuple2.collect(new Tuple.Tuple2<>(arg0.dec(format, ops), arg1.dec(format, ops)))
+				                   .map(it -> it.applyTo(joiner));
+			}
+		};
+	}
+	public static <T0, T1, T2, O, Format> JsonCodec<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<>() {
+			@Override
+			public Result<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);
+			}
+			@Override
+			public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) {
+				return Tuple.Tuple3.collect(new Tuple.Tuple3<>(arg0.dec(format, ops), arg1.dec(format, ops), arg2.dec(format, ops)))
+				                   .map(it -> it.applyTo(joiner));
+			}
+		};
+	}
+	public static <T0, T1, T2, T3, O, Format> JsonCodec<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<>() {
+			@Override
+			public Result<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);
+			}
+			@Override
+			public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) {
+				return Tuple.Tuple4.collect(new Tuple.Tuple4<>(arg0.dec(format, ops), arg1.dec(format, ops), arg2.dec(format, ops), arg3.dec(format, ops)))
+				                   .map(it -> it.applyTo(joiner));
+			}
+		};
+	}
+	public static <T0, T1, T2, T3, T4, O, Format> JsonCodec<O, Format> join(
+			RecordCodec<O, T0, Format> arg0,
+			RecordCodec<O, T1, Format> arg1,
+			RecordCodec<O, T2, Format> arg2,
+			RecordCodec<O, T3, Format> arg3,
+			RecordCodec<O, T4, Format> arg4,
+			Tuple.Func5<O, T0, T1, T2, T3, T4> joiner
+	) {
+		return new RecordCompleteCodec<>() {
+			@Override
+			public Result<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);
+			}
+			@Override
+			public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) {
+				return Tuple.Tuple5.collect(new Tuple.Tuple5<>(arg0.dec(format, ops), arg1.dec(format, ops), arg2.dec(format, ops), arg3.dec(format, ops), arg4.dec(format, ops)))
+				                   .map(it -> it.applyTo(joiner));
+			}
+		};
+	}
+	public static <T0, T1, T2, T3, T4, T5, O, Format> JsonCodec<O, Format> join(
+			RecordCodec<O, T0, Format> arg0,
+			RecordCodec<O, T1, Format> arg1,
+			RecordCodec<O, T2, Format> arg2,
+			RecordCodec<O, T3, Format> arg3,
+			RecordCodec<O, T4, Format> arg4,
+			RecordCodec<O, T5, Format> arg5,
+			Tuple.Func6<O, T0, T1, T2, T3, T4, T5> joiner
+	) {
+		return new RecordCompleteCodec<>() {
+			@Override
+			public Result<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);
+			}
+			@Override
+			public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) {
+				return Tuple.Tuple6.collect(new Tuple.Tuple6<>(arg0.dec(format, ops), arg1.dec(format, ops), arg2.dec(format, ops), arg3.dec(format, ops), arg4.dec(format, ops), arg5.dec(format, ops)))
+				                   .map(it -> it.applyTo(joiner));
+			}
+		};
+	}
+	public static <T0, T1, T2, T3, T4, T5, T6, O, Format> JsonCodec<O, Format> join(
+			RecordCodec<O, T0, Format> arg0,
+			RecordCodec<O, T1, Format> arg1,
+			RecordCodec<O, T2, Format> arg2,
+			RecordCodec<O, T3, Format> arg3,
+			RecordCodec<O, T4, Format> arg4,
+			RecordCodec<O, T5, Format> arg5,
+			RecordCodec<O, T6, Format> arg6,
+			Tuple.Func7<O, T0, T1, T2, T3, T4, T5, T6> joiner
+	) {
+		return new RecordCompleteCodec<>() {
+			@Override
+			public Result<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);
+			}
+			@Override
+			public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) {
+				return Tuple.Tuple7.collect(new Tuple.Tuple7<>(arg0.dec(format, ops), arg1.dec(format, ops), arg2.dec(format, ops), arg3.dec(format, ops), arg4.dec(format, ops), arg5.dec(format, ops), arg6.dec(format, ops)))
+				                   .map(it -> it.applyTo(joiner));
+			}
+		};
+	}
+	public static <T0, T1, T2, T3, T4, T5, T6, T7, O, Format> JsonCodec<O, Format> join(
+			RecordCodec<O, T0, Format> arg0,
+			RecordCodec<O, T1, Format> arg1,
+			RecordCodec<O, T2, Format> arg2,
+			RecordCodec<O, T3, Format> arg3,
+			RecordCodec<O, T4, Format> arg4,
+			RecordCodec<O, T5, Format> arg5,
+			RecordCodec<O, T6, Format> arg6,
+			RecordCodec<O, T7, Format> arg7,
+			Tuple.Func8<O, T0, T1, T2, T3, T4, T5, T6, T7> joiner
+	) {
+		return new RecordCompleteCodec<>() {
+			@Override
+			public Result<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);
+			}
+			@Override
+			public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) {
+				return Tuple.Tuple8.collect(new Tuple.Tuple8<>(arg0.dec(format, ops), arg1.dec(format, ops), arg2.dec(format, ops), arg3.dec(format, ops), arg4.dec(format, ops), arg5.dec(format, ops), arg6.dec(format, ops), arg7.dec(format, ops)))
+				                   .map(it -> it.applyTo(joiner));
+			}
+		};
+	}
+	public static <T0, T1, T2, T3, T4, T5, T6, T7, T8, O, Format> JsonCodec<O, Format> join(
+			RecordCodec<O, T0, Format> arg0,
+			RecordCodec<O, T1, Format> arg1,
+			RecordCodec<O, T2, Format> arg2,
+			RecordCodec<O, T3, Format> arg3,
+			RecordCodec<O, T4, Format> arg4,
+			RecordCodec<O, T5, Format> arg5,
+			RecordCodec<O, T6, Format> arg6,
+			RecordCodec<O, T7, Format> arg7,
+			RecordCodec<O, T8, Format> arg8,
+			Tuple.Func9<O, T0, T1, T2, T3, T4, T5, T6, T7, T8> joiner
+	) {
+		return new RecordCompleteCodec<>() {
+			@Override
+			public Result<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);
+			}
+			@Override
+			public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) {
+				return Tuple.Tuple9.collect(new Tuple.Tuple9<>(arg0.dec(format, ops), arg1.dec(format, ops), arg2.dec(format, ops), arg3.dec(format, ops), arg4.dec(format, ops), arg5.dec(format, ops), arg6.dec(format, ops), arg7.dec(format, ops), arg8.dec(format, ops)))
+				                   .map(it -> it.applyTo(joiner));
+			}
+		};
+	}
+	public static <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, O, Format> JsonCodec<O, Format> join(
+			RecordCodec<O, T0, Format> arg0,
+			RecordCodec<O, T1, Format> arg1,
+			RecordCodec<O, T2, Format> arg2,
+			RecordCodec<O, T3, Format> arg3,
+			RecordCodec<O, T4, Format> arg4,
+			RecordCodec<O, T5, Format> arg5,
+			RecordCodec<O, T6, Format> arg6,
+			RecordCodec<O, T7, Format> arg7,
+			RecordCodec<O, T8, Format> arg8,
+			RecordCodec<O, T9, Format> arg9,
+			Tuple.Func10<O, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> joiner
+	) {
+		return new RecordCompleteCodec<>() {
+			@Override
+			public Result<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);
+			}
+			@Override
+			public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) {
+				return Tuple.Tuple10.collect(new Tuple.Tuple10<>(arg0.dec(format, ops), arg1.dec(format, ops), arg2.dec(format, ops), arg3.dec(format, ops), arg4.dec(format, ops), arg5.dec(format, ops), arg6.dec(format, ops), arg7.dec(format, ops), arg8.dec(format, ops), arg9.dec(format, ops)))
+				                    .map(it -> it.applyTo(joiner));
+			}
+		};
+	}
+	public static <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, O, Format> JsonCodec<O, Format> join(
+			RecordCodec<O, T0, Format> arg0,
+			RecordCodec<O, T1, Format> arg1,
+			RecordCodec<O, T2, Format> arg2,
+			RecordCodec<O, T3, Format> arg3,
+			RecordCodec<O, T4, Format> arg4,
+			RecordCodec<O, T5, Format> arg5,
+			RecordCodec<O, T6, Format> arg6,
+			RecordCodec<O, T7, Format> arg7,
+			RecordCodec<O, T8, Format> arg8,
+			RecordCodec<O, T9, Format> arg9,
+			RecordCodec<O, T10, Format> arg10,
+			Tuple.Func11<O, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> joiner
+	) {
+		return new RecordCompleteCodec<>() {
+			@Override
+			public Result<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);
+			}
+			@Override
+			public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) {
+				return Tuple.Tuple11.collect(new Tuple.Tuple11<>(arg0.dec(format, ops), arg1.dec(format, ops), arg2.dec(format, ops), arg3.dec(format, ops), arg4.dec(format, ops), arg5.dec(format, ops), arg6.dec(format, ops), arg7.dec(format, ops), arg8.dec(format, ops), arg9.dec(format, ops), arg10.dec(format, ops)))
+				                    .map(it -> it.applyTo(joiner));
+			}
+		};
+	}
+	public static <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, O, Format> JsonCodec<O, Format> join(
+			RecordCodec<O, T0, Format> arg0,
+			RecordCodec<O, T1, Format> arg1,
+			RecordCodec<O, T2, Format> arg2,
+			RecordCodec<O, T3, Format> arg3,
+			RecordCodec<O, T4, Format> arg4,
+			RecordCodec<O, T5, Format> arg5,
+			RecordCodec<O, T6, Format> arg6,
+			RecordCodec<O, T7, Format> arg7,
+			RecordCodec<O, T8, Format> arg8,
+			RecordCodec<O, T9, Format> arg9,
+			RecordCodec<O, T10, Format> arg10,
+			RecordCodec<O, T11, Format> arg11,
+			Tuple.Func12<O, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> joiner
+	) {
+		return new RecordCompleteCodec<>() {
+			@Override
+			public Result<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);
+			}
+			@Override
+			public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) {
+				return Tuple.Tuple12.collect(new Tuple.Tuple12<>(arg0.dec(format, ops), arg1.dec(format, ops), arg2.dec(format, ops), arg3.dec(format, ops), arg4.dec(format, ops), arg5.dec(format, ops), arg6.dec(format, ops), arg7.dec(format, ops), arg8.dec(format, ops), arg9.dec(format, ops), arg10.dec(format, ops), arg11.dec(format, ops)))
+				                    .map(it -> it.applyTo(joiner));
+			}
+		};
+	}
+	public static <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, O, Format> JsonCodec<O, Format> join(
+			RecordCodec<O, T0, Format> arg0,
+			RecordCodec<O, T1, Format> arg1,
+			RecordCodec<O, T2, Format> arg2,
+			RecordCodec<O, T3, Format> arg3,
+			RecordCodec<O, T4, Format> arg4,
+			RecordCodec<O, T5, Format> arg5,
+			RecordCodec<O, T6, Format> arg6,
+			RecordCodec<O, T7, Format> arg7,
+			RecordCodec<O, T8, Format> arg8,
+			RecordCodec<O, T9, Format> arg9,
+			RecordCodec<O, T10, Format> arg10,
+			RecordCodec<O, T11, Format> arg11,
+			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<>() {
+			@Override
+			public Result<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);
+			}
+			@Override
+			public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) {
+				return Tuple.Tuple13.collect(new Tuple.Tuple13<>(arg0.dec(format, ops), arg1.dec(format, ops), arg2.dec(format, ops), arg3.dec(format, ops), arg4.dec(format, ops), arg5.dec(format, ops), arg6.dec(format, ops), arg7.dec(format, ops), arg8.dec(format, ops), arg9.dec(format, ops), arg10.dec(format, ops), arg11.dec(format, ops), arg12.dec(format, ops)))
+				                    .map(it -> it.applyTo(joiner));
+			}
+		};
+	}
+	public static <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, O, Format> JsonCodec<O, Format> join(
+			RecordCodec<O, T0, Format> arg0,
+			RecordCodec<O, T1, Format> arg1,
+			RecordCodec<O, T2, Format> arg2,
+			RecordCodec<O, T3, Format> arg3,
+			RecordCodec<O, T4, Format> arg4,
+			RecordCodec<O, T5, Format> arg5,
+			RecordCodec<O, T6, Format> arg6,
+			RecordCodec<O, T7, Format> arg7,
+			RecordCodec<O, T8, Format> arg8,
+			RecordCodec<O, T9, Format> arg9,
+			RecordCodec<O, T10, Format> arg10,
+			RecordCodec<O, T11, Format> arg11,
+			RecordCodec<O, T12, Format> arg12,
+			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<>() {
+			@Override
+			public Result<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);
+			}
+			@Override
+			public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) {
+				return Tuple.Tuple14.collect(new Tuple.Tuple14<>(arg0.dec(format, ops), arg1.dec(format, ops), arg2.dec(format, ops), arg3.dec(format, ops), arg4.dec(format, ops), arg5.dec(format, ops), arg6.dec(format, ops), arg7.dec(format, ops), arg8.dec(format, ops), arg9.dec(format, ops), arg10.dec(format, ops), arg11.dec(format, ops), arg12.dec(format, ops), arg13.dec(format, ops)))
+				                    .map(it -> it.applyTo(joiner));
+			}
+		};
+	}
+}