wip

31 files changed, 1539 insertions, 127 deletions

diff --git a/genrecord.ts b/genrecord.ts
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/genrecord.ts
diff --git a/gentuples.ts b/gentuples.ts
new file mode 100755
index 0000000..ba74c29
--- /dev/null
+++ b/gentuples.ts
@@ -0,0 +1,80 @@
+#!/usr/bin/env node --experimental-strip-types
+
+function nameFor(va: string): string {
+    return va.replace("E", "T").replace("T", "element")
+}
+
+function typArgs(a: string[]): string {
+    if (a.length == 0) return ""
+    return "<" + a.join(", ") + ">"
+}
+
+function genFunc(elementNumber: number, max: number) {
+    console.log("\t@FunctionalInterface")
+    const vars: string[] = [...new Array(elementNumber)].map((_, idx) => `T${idx}`)
+    console.log(`\tinterface Func${elementNumber}${typArgs(['R', ...vars])} {`)
+    console.log(`\t\tR apply(${vars.map(it => it + " " + it.replace("T", "arg")).join(", ")});`)
+    console.log("\t}")
+}
+
+function genTuple(elementNumber: number, max: number) {
+    const vars: string[] = [...new Array(elementNumber)].map((_, idx) => `T${idx}`)
+    if (elementNumber == 0) {
+        console.log("\tclass Tuple0 implements Tuple {")
+    } else {
+        console.log(`\trecord Tuple${elementNumber}${typArgs(vars)}(${vars.map(it => it + " " + nameFor(it)).join(", ")}) {`)
+    }
+    console.log(`\t\tpublic <R> R applyTo(Func${elementNumber}${typArgs(['R', ...vars])} func) {`)
+    console.log(`\t\t\treturn func.apply(${vars.map(it => "this." + nameFor(it)).join(", ")});`)
+    console.log("\t\t}")
+    console.log(`\t\tpublic static ${typArgs(['R', ...vars])} Result<Tuple${elementNumber}${typArgs(vars)}, R> collect(`
+        + `Tuple${elementNumber}${typArgs(vars.map(it => `Result<${it}, R>`))} tuple`
+        + `) {`)
+    console.log("\t\t\treturn")
+    for (const tVar of vars) {
+        console.log(`\t\t\t\ttuple.${nameFor(tVar)}.flatMap(${nameFor(tVar)} ->`)
+    }
+    console.log(`\t\t\t\t\tResult.ok(new Tuple${elementNumber}${elementNumber ? '<>' : ''}(${vars.map(it => nameFor(it)).join(", ")}))`)
+    for (const tVar of vars) {
+        console.log(`\t\t\t\t)`)
+    }
+    console.log("\t\t\t;")
+    console.log("\t\t}")
+
+
+    const newVars = vars.map(it => it.replace("T", "E"))
+    console.log(`\t\tpublic ${typArgs(newVars)} Tuple${elementNumber}${typArgs(newVars)} map(`
+        + newVars.map(it => `Func1<${it}, ${it.replace("E", "T")}> ${it.replace("E", "map")}`).join(", ")
+        + `) {`)
+    console.log(`\t\t\treturn new Tuple${elementNumber}${(elementNumber ? '<>' : '')}(${newVars.map(it => `${it.replace("E", "map")}.apply(this.${nameFor(it)})`).join(", ")});`)
+    console.log("\t\t}")
+
+    for (let extraElements = 0; extraElements < (max - elementNumber); extraElements++) {
+        const extraVars = [...new Array(extraElements)].map((_, idx) => `E${idx}`)
+        const sumElements = extraElements + elementNumber;
+        console.log(`\t\tpublic ${typArgs(extraVars)} Tuple${sumElements}${typArgs([...vars, ...extraVars])} `
+            + `join(Tuple${extraElements}${typArgs(extraVars)} other) {`)
+        console.log(`\t\t\treturn new Tuple${sumElements}${sumElements ? '<>' : ''}(${[
+            ...vars.map(it => "this." + nameFor(it)),
+            ...extraVars.map(it => "other." + nameFor(it))].join(", ")});`)
+        console.log("\t\t}")
+    }
+    console.log("\t}")
+}
+
+
+function genTuples(maxI: number) {
+    console.log("// @gen" + "erated by gentuples.ts")
+    console.log("package moe.nea.pcj;")
+    console.log()
+    console.log("@SuppressWarnings(\"unused\")")
+    console.log("public interface Tuple {")
+    for (let i = 0; i < maxI; i++) {
+        genTuple(i, maxI);
+        genFunc(i, maxI)
+    }
+    console.log("}")
+}
+
+genTuples(15)
+
diff --git a/gson/src/main/java/moe/nea/jcp/gson/GsonCodecs.java b/gson/src/main/java/moe/nea/jcp/gson/GsonCodecs.java
new file mode 100644
index 0000000..616d713
--- /dev/null
+++ b/gson/src/main/java/moe/nea/jcp/gson/GsonCodecs.java
@@ -0,0 +1,10 @@
+package moe.nea.jcp.gson;
+
+import com.google.gson.JsonElement;
+import moe.nea.pcj.json.BasicCodecs;
+
+public class GsonCodecs extends BasicCodecs<JsonElement> {
+	protected GsonCodecs() {}
+
+	public static final GsonCodecs INSTANCE = new GsonCodecs();
+}
diff --git a/gson/src/main/java/moe/nea/jcp/gson/GsonListBuilder.java b/gson/src/main/java/moe/nea/jcp/gson/GsonListBuilder.java
new file mode 100644
index 0000000..d1a6302
--- /dev/null
+++ b/gson/src/main/java/moe/nea/jcp/gson/GsonListBuilder.java
@@ -0,0 +1,27 @@
+package moe.nea.jcp.gson;
+
+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 GsonListBuilder() {
+		super(new JsonArray());
+	}
+
+	@Override
+	public JsonArray complete() {
+		return jsonArray;
+	}
+
+	@Override
+	public void add(JsonElement value) {
+		jsonArray.add(value);
+	}
+
+	@Override
+	public void set(int index, JsonElement value) {
+		jsonArray.set(index, value);
+	}
+}
diff --git a/gson/src/main/java/moe/nea/jcp/gson/GsonListView.java b/gson/src/main/java/moe/nea/jcp/gson/GsonListView.java
new file mode 100644
index 0000000..2a0dcf5
--- /dev/null
+++ b/gson/src/main/java/moe/nea/jcp/gson/GsonListView.java
@@ -0,0 +1,21 @@
+package moe.nea.jcp.gson;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonElement;
+import moe.nea.pcj.json.ListView;
+
+public class GsonListView implements ListView<JsonElement> {
+	final JsonArray jsonArray;
+
+	public GsonListView(JsonArray jsonArray) {this.jsonArray = jsonArray;}
+
+	@Override
+	public int length() {
+		return jsonArray.size();
+	}
+
+	@Override
+	public JsonElement getUnsafe(int index) {
+		return jsonArray.get(index);
+	}
+}
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 7d81b9f..7957d05 100644
--- a/gson/src/main/java/moe/nea/jcp/gson/GsonOperations.java
+++ b/gson/src/main/java/moe/nea/jcp/gson/GsonOperations.java
@@ -1,15 +1,19 @@
 package moe.nea.jcp.gson;
 
+import com.google.gson.JsonArray;
 import com.google.gson.JsonElement;
 import com.google.gson.JsonNull;
-import moe.nea.pcj.JsonLikeError;
-import moe.nea.pcj.JsonLikeOperations;
-import moe.nea.pcj.ListBuilder;
-import moe.nea.pcj.ListView;
-import moe.nea.pcj.RecordBuilder;
-import moe.nea.pcj.RecordView;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonPrimitive;
+import moe.nea.pcj.json.JsonLikeError;
+import moe.nea.pcj.json.JsonLikeOperations;
+import moe.nea.pcj.json.ListBuilder;
+import moe.nea.pcj.json.ListView;
+import moe.nea.pcj.json.RecordBuilder;
+import moe.nea.pcj.json.RecordView;
 import moe.nea.pcj.Result;
 import moe.nea.pcj.Unit;
+import moe.nea.pcj.json.UnexpectedJsonElement;
 
 public class GsonOperations implements JsonLikeOperations<JsonElement> {
 	@Override
@@ -20,56 +24,71 @@ public class GsonOperations implements JsonLikeOperations<JsonElement> {
 	@Override
 	public Result<Unit, ? extends JsonLikeError> getNull(JsonElement element) {
 		if (element.isJsonNull()) return Result.ok(Unit.INSTANCE);
-		return Result.fail();
+		return Result.fail(new UnexpectedJsonElement("null", element));
 	}
 
 	@Override
 	public JsonElement createNumeric(Number value) {
-		return null;
+		return new JsonPrimitive(value);
 	}
 
 	@Override
-	public Result<Number, ? extends JsonLikeError> getInt(JsonElement element) {
-		return null;
+	public Result<Number, ? extends JsonLikeError> getNumeric(JsonElement element) {
+		if (element instanceof JsonPrimitive primitive && primitive.isNumber()) {
+			return Result.ok(primitive.getAsNumber());
+		}
+		return Result.fail(new UnexpectedJsonElement("number", element));
 	}
 
 	@Override
 	public JsonElement createString(String value) {
-		return null;
+		return new JsonPrimitive(value);
 	}
 
 	@Override
 	public Result<String, ? extends JsonLikeError> getString(JsonElement element) {
-		return null;
+		if (element instanceof JsonPrimitive primitive && primitive.isString()) {
+			return Result.ok(primitive.getAsString());
+		}
+		return Result.fail(new UnexpectedJsonElement("string", element));
 	}
 
 	@Override
 	public JsonElement createBoolean(boolean value) {
-		return null;
+		return new JsonPrimitive(value);
 	}
 
 	@Override
 	public Result<Boolean, ? extends JsonLikeError> getBoolean(JsonElement jsonElement) {
-		return null;
+		if (jsonElement instanceof JsonPrimitive primitive && primitive.isBoolean()) {
+			return Result.ok(primitive.getAsBoolean());
+		}
+		return Result.fail(new UnexpectedJsonElement("boolean", jsonElement));
 	}
 
 	@Override
-	public RecordBuilder<? extends JsonElement, JsonElement> createObject() {
-		return null;
+	public RecordBuilder<JsonElement> createObject() {
+		return new GsonRecordBuilder();
 	}
 
 	@Override
-	public Result<RecordView<? extends JsonElement>, ? extends JsonLikeError> getObject(JsonElement jsonElement) {
-		return null;
+	public Result<RecordView<JsonElement>, ? extends JsonLikeError> getObject(JsonElement jsonElement) {
+		if (jsonElement instanceof JsonObject object) {
+			return Result.ok(new GsonRecordView(object));
+		}
+		return Result.fail(new UnexpectedJsonElement("object", jsonElement));
 	}
 
 	@Override
-	public ListBuilder<? extends JsonElement, JsonElement> createList() {
-		return null;
+	public ListBuilder<JsonArray, JsonElement> createList() {
+		return new GsonListBuilder();
 	}
 
 	@Override
-	public Result<ListView<? extends JsonElement>, ? extends JsonLikeError> getList(JsonElement jsonElement) {
-		return null;
+	public Result<ListView<JsonElement>, ? extends JsonLikeError> getList(JsonElement jsonElement) {
+		if (jsonElement instanceof JsonArray array) {
+			return Result.ok(new GsonListView(array));
+		}
+		return Result.fail(new UnexpectedJsonElement("list", jsonElement));
 	}
 }
diff --git a/gson/src/main/java/moe/nea/jcp/gson/GsonRecordBuilder.java b/gson/src/main/java/moe/nea/jcp/gson/GsonRecordBuilder.java
new file mode 100644
index 0000000..ded1953
--- /dev/null
+++ b/gson/src/main/java/moe/nea/jcp/gson/GsonRecordBuilder.java
@@ -0,0 +1,47 @@
+package moe.nea.jcp.gson;
+
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import moe.nea.pcj.Result;
+import moe.nea.pcj.Unit;
+import moe.nea.pcj.json.DuplicateJsonKey;
+import moe.nea.pcj.json.JsonLikeError;
+import moe.nea.pcj.json.RecordBuilder;
+
+import java.util.stream.Stream;
+
+public class GsonRecordBuilder extends GsonRecordView implements RecordBuilder<JsonElement> {
+	public GsonRecordBuilder() {
+		super(new JsonObject());
+	}
+
+	boolean completed = false;
+
+	@Override
+	public Result<RecordBuilder<JsonElement>, JsonLikeError> mergeWith(RecordBuilder<JsonElement> other) {
+		var next = new GsonRecordBuilder();
+		return Result.cast(Stream.of(this.complete(), other.complete())
+		                         .flatMap(it -> ((JsonObject) it).entrySet().stream())
+		                         .map(it -> next.add(it.getKey(), it.getValue()))
+		                         .reduce((left, right) -> left.appendErrors(right.errors()))
+		                         .map(it -> it.map(unit -> next))
+		                         .orElse(Result.ok(next)));
+	}
+
+	@Override
+	public Result<Unit, JsonLikeError> add(String key, JsonElement value) {
+		if (completed) throw new IllegalStateException("JsonObject already completed");
+		if (jsonObject.has(key))
+			return Result.fail(new DuplicateJsonKey(key));
+		jsonObject.add(key, value);
+		return Result.ok(Unit.INSTANCE);
+	}
+
+	@Override
+	public JsonObject complete() {
+		if (completed)
+			throw new IllegalStateException("JsonObject already completed");
+		completed = true;
+		return jsonObject;
+	}
+}
diff --git a/gson/src/main/java/moe/nea/jcp/gson/GsonRecordView.java b/gson/src/main/java/moe/nea/jcp/gson/GsonRecordView.java
new file mode 100644
index 0000000..b20d0a7
--- /dev/null
+++ b/gson/src/main/java/moe/nea/jcp/gson/GsonRecordView.java
@@ -0,0 +1,24 @@
+package moe.nea.jcp.gson;
+
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import moe.nea.pcj.json.RecordView;
+
+import java.util.Collection;
+import java.util.Optional;
+
+public class GsonRecordView implements RecordView<JsonElement> {
+	final JsonObject jsonObject;
+
+	public GsonRecordView(JsonObject jsonObject) {this.jsonObject = jsonObject;}
+
+	@Override
+	public Collection<String> getKeys() {
+		return jsonObject.keySet();
+	}
+
+	@Override
+	public Optional<JsonElement> get(String key) {
+		return Optional.ofNullable(jsonObject.get(key));
+	}
+}
diff --git a/src/main/java/moe/nea/pcj/AppendableError.java b/src/main/java/moe/nea/pcj/AppendableError.java
deleted file mode 100644
index 6ec48fa..0000000
--- a/src/main/java/moe/nea/pcj/AppendableError.java
+++ /dev/null
@@ -1,21 +0,0 @@
-package moe.nea.pcj;
-
-import java.util.List;
-import java.util.Optional;
-
-public interface AppendableError<T extends AppendableError<T>> {
-	/**
-	 * @return an optional Self with getSuppressed containing the argument
-	 */
-	Optional<T> appendError(Object other);
-
-	List<T> getSuppressed();
-
-	static <T> T concatError(T left, T right) {
-		if (left instanceof AppendableError<?> appendable) {
-			var opt = (Optional<T>) appendable.appendError(right);
-			return opt.orElse(left);
-		}
-		return left;
-	}
-}
diff --git a/src/main/java/moe/nea/pcj/Codec.java b/src/main/java/moe/nea/pcj/Codec.java
index 728fbc6..121e05f 100644
--- a/src/main/java/moe/nea/pcj/Codec.java
+++ b/src/main/java/moe/nea/pcj/Codec.java
@@ -1,5 +1,6 @@
 package moe.nea.pcj;
 
-public interface Codec<Typ, Format, DeErr, CoErr> extends Decode<Typ, Format, DeErr>, Encode<Typ, Format, CoErr> {
+public interface Codec<Typ, Format, Op extends Operation<Format>, DeErr, CoErr>
+		extends Decode<Typ, Format, Op, DeErr>, Encode<Typ, Format, Op, CoErr> {
 
 }
diff --git a/src/main/java/moe/nea/pcj/Decode.java b/src/main/java/moe/nea/pcj/Decode.java
index a335849..d10c98a 100644
--- a/src/main/java/moe/nea/pcj/Decode.java
+++ b/src/main/java/moe/nea/pcj/Decode.java
@@ -1,5 +1,5 @@
 package moe.nea.pcj;
 
-public interface Decode<Typ, Format, Err> {
-	Result<Typ, Err> decode(Format format, Operation<Format> op);
+public interface Decode<Typ, Format, Op extends Operation<Format>, Err> {
+	Result<? extends Typ, ? extends Err> decode(Format format, Op ops);
 }
diff --git a/src/main/java/moe/nea/pcj/Encode.java b/src/main/java/moe/nea/pcj/Encode.java
index 0c17097..834ce66 100644
--- a/src/main/java/moe/nea/pcj/Encode.java
+++ b/src/main/java/moe/nea/pcj/Encode.java
@@ -1,5 +1,5 @@
 package moe.nea.pcj;
 
-public interface Encode<Typ, Format, Err> {
-	Result<Format, Err> encode(Typ data, Operation<Format> op);
+public interface Encode<Typ, Format, Op extends Operation<Format>, Err> {
+	Result<? extends Format, ? extends Err> encode(Typ data, Op ops);
 }
diff --git a/src/main/java/moe/nea/pcj/JsonLikeError.java b/src/main/java/moe/nea/pcj/JsonLikeError.java
deleted file mode 100644
index 6d309ab..0000000
--- a/src/main/java/moe/nea/pcj/JsonLikeError.java
+++ /dev/null
@@ -1,29 +0,0 @@
-package moe.nea.pcj;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.Optional;
-
-public abstract class JsonLikeError<Self extends JsonLikeError<?>> implements AppendableError<JsonLikeError<?>> {
-	private final List<JsonLikeError<?>> suppressed = new ArrayList<>();
-
-	protected abstract Self copySelfWithoutSuppressions();
-
-	@Override
-	public List<JsonLikeError<?>> getSuppressed() {
-		return Collections.unmodifiableList(suppressed);
-	}
-
-	@Override
-	public Optional<JsonLikeError<?>> appendError(Object other) {
-		if (other instanceof JsonLikeError<?> jsonLikeOther) {
-			var newSelf = (JsonLikeError<?>) copySelfWithoutSuppressions();
-			newSelf.suppressed.add(jsonLikeOther.copySelfWithoutSuppressions());
-			newSelf.suppressed.addAll(jsonLikeOther.getSuppressed());
-			return Optional.of(newSelf);
-		} else {
-			return Optional.empty();
-		}
-	}
-}
diff --git a/src/main/java/moe/nea/pcj/RecordBuilder.java b/src/main/java/moe/nea/pcj/RecordBuilder.java
deleted file mode 100644
index c28be7b..0000000
--- a/src/main/java/moe/nea/pcj/RecordBuilder.java
+++ /dev/null
@@ -1,6 +0,0 @@
-package moe.nea.pcj;
-
-public interface RecordBuilder<Format, ElementFormat> extends RecordView<ElementFormat> {
-	void add(String key, ElementFormat value); // TODO
-	Format complete();
-}
diff --git a/src/main/java/moe/nea/pcj/Result.java b/src/main/java/moe/nea/pcj/Result.java
index 8bec96a..e43633b 100644
--- a/src/main/java/moe/nea/pcj/Result.java
+++ b/src/main/java/moe/nea/pcj/Result.java
@@ -2,12 +2,15 @@ package moe.nea.pcj;
 
 import org.jspecify.annotations.Nullable;
 
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
 import java.util.Optional;
 import java.util.function.Function;
 
 public sealed interface Result<Good, Bad> permits Result.Ok, Result.Fail {
 	default boolean isOk() {
-		return error().isEmpty();
+		return errors().isEmpty();
 	}
 
 	Optional<Good> value();
@@ -18,26 +21,31 @@ public sealed interface Result<Good, Bad> permits Result.Ok, Result.Fail {
 		return value().or(this::partial);
 	}
 
-	Optional<Bad> error();
+	List<Bad> errors();
 
 	default <Next> Result<Next, Bad> map(Function<Good, Next> mapper) {
 		return flatMap(mapper.andThen(Result::ok));
 	}
 
-	default <Next> Result<Next, Bad> flatMap(Function<Good, Result<Next, Bad>> mapper) {
-		return flatMapBoth(mapper, Result::fail);
+	<Next> Result<Next, Bad> flatMap(Function<Good, Result<? extends Next, ? extends Bad>> mapper);
+
+	default <NextBad> Result<Good, NextBad> mapError(Function<Bad, NextBad> mapper) {
+		return mapErrors(it -> it.stream().map(mapper).toList());
 	}
 
-	<NextGood> Result<NextGood, Bad> flatMapBoth(
-			Function<Good, Result<NextGood, Bad>> mapGood,
-			Function<Bad, Result<NextGood, Bad>> mapBad);
+	<NextBad> Result<Good, NextBad> mapErrors(Function<List<Bad>, List<NextBad>> mapper);
 
-	Result<Good, Bad> appendError(Bad error);
+	Result<Good, Bad> appendErrors(List<Bad> error);
 
 	record Ok<Good, Bad>(Good okValue) implements Result<Good, Bad> {
 		@Override
-		public Result<Good, Bad> appendError(Bad error) {
-			return Result.partial(okValue, error);
+		public Result<Good, Bad> appendErrors(List<Bad> errors) {
+			return new Fail<>(okValue, errors);
+		}
+
+		@Override
+		public <NextBad> Result<Good, NextBad> mapErrors(Function<List<Bad>, List<NextBad>> mapper) {
+			return new Ok<>(okValue);
 		}
 
 		@Override
@@ -46,22 +54,26 @@ public sealed interface Result<Good, Bad> permits Result.Ok, Result.Fail {
 		}
 
 		@Override
-		public Optional<Good> value() {
-			return Optional.of(okValue);
+		public List<Bad> errors() {
+			return List.of();
 		}
 
 		@Override
-		public Optional<Bad> error() {
-			return Optional.empty();
+		public <Next> Result<Next, Bad> flatMap(Function<Good, Result<? extends Next, ? extends Bad>> mapper) {
+			return Result.cast(mapper.apply(okValue));
 		}
 
 		@Override
-		public <NextGood> Result<NextGood, Bad> flatMapBoth(Function<Good, Result<NextGood, Bad>> mapGood, Function<Bad, Result<NextGood, Bad>> mapBad) {
-			return mapGood.apply(okValue);
+		public Optional<Good> value() {
+			return Optional.of(okValue);
 		}
 	}
 
-	record Fail<Good, Bad>(@Nullable Good partialValue, Bad badValue) implements Result<Good, Bad> {
+	record Fail<Good, Bad>(@Nullable Good partialValue, List<Bad> badValue) implements Result<Good, Bad> {
+		public Fail {
+			if (badValue.isEmpty())
+				throw new IllegalArgumentException("Cannot create failure without any error values");
+		}
 
 		@Override
 		public Optional<Good> value() {
@@ -74,22 +86,28 @@ public sealed interface Result<Good, Bad> permits Result.Ok, Result.Fail {
 		}
 
 		@Override
-		public Optional<Bad> error() {
-			return Optional.of(badValue);
+		public List<Bad> errors() {
+			return Collections.unmodifiableList(badValue);
 		}
 
 		@Override
-		public <NextGood> Result<NextGood, Bad> flatMapBoth(Function<Good, Result<NextGood, Bad>> mapGood, Function<Bad, Result<NextGood, Bad>> mapBad) {
+		public <Next> Result<Next, Bad> flatMap(Function<Good, Result<? extends Next, ? extends Bad>> mapper) {
 			if (partialValue != null) {
-				var nextPartial = mapGood.apply(partialValue);
-				return nextPartial.appendError(badValue);
+				return Result.<Next, Bad>cast(mapper.apply(partialValue)).appendErrors(badValue);
 			}
-			return mapBad.apply(badValue);
+			return new Fail<>(null, badValue);
+		}
+
+		@Override
+		public <NextBad> Result<Good, NextBad> mapErrors(Function<List<Bad>, List<NextBad>> mapper) {
+			return new Fail<>(partialValue, mapper.apply(badValue));
 		}
 
 		@Override
-		public Result<Good, Bad> appendError(Bad error) {
-			return Result.partial(partialValue, AppendableError.concatError(badValue, error));
+		public Result<Good, Bad> appendErrors(List<Bad> errors) {
+			var nextErrors = new ArrayList<>(badValue);
+			nextErrors.addAll(errors);
+			return new Fail<>(partialValue, nextErrors);
 		}
 	}
 
@@ -98,10 +116,16 @@ public sealed interface Result<Good, Bad> permits Result.Ok, Result.Fail {
 	}
 
 	static <Good, Bad> Result.Fail<Good, Bad> fail(Bad error) {
-		return new Fail<>(null, error);
+		return new Fail<>(null, List.of(error));
+	}
+
+
+	static <Good, Bad> Result<Good, Bad> cast(Result<? extends Good, ? extends Bad> c) {
+		//noinspection unchecked
+		return (Result<Good, Bad>) c;
 	}
 
 	static <Good, Bad> Result.Fail<Good, Bad> partial(@Nullable Good partial, Bad error) {
-		return new Fail<>(partial, error);
+		return new Fail<>(partial, List.of(error));
 	}
 }
diff --git a/src/main/java/moe/nea/pcj/Tuple.java b/src/main/java/moe/nea/pcj/Tuple.java
index baaceef..e6207ff 100644
--- a/src/main/java/moe/nea/pcj/Tuple.java
+++ b/src/main/java/moe/nea/pcj/Tuple.java
@@ -1,16 +1,1030 @@
+// @generated by gentuples.ts
 package moe.nea.pcj;
 
+@SuppressWarnings("unused")
 public interface Tuple {
-	record Tuple2<A, B>(A first, B second) implements Tuple {}
+	class Tuple0 implements Tuple {
+		public <R> R applyTo(Func0<R> func) {
+			return func.apply();
+		}
 
-	record Tuple3<A, B, C>(A first, B second, C third) implements Tuple {}
+		public static <R> Result<Tuple0, R> collect(Tuple0 tuple) {
+			return
+					Result.ok(new Tuple0())
+					;
+		}
 
-	record Tuple4<A, B, C, D>(A first, B second, C third, D fourth) implements Tuple {}
+		public Tuple0 map() {
+			return new Tuple0();
+		}
 
-	record Tuple5<A, B, C, D, E>(A first, B second, C third, D fourth, E fifth) implements Tuple {}
+		public Tuple0 join(Tuple0 other) {
+			return new Tuple0();
+		}
 
-	record Tuple6<A, B, C, D, E, F>(A first, B second, C third, D fourth, E fifth, F sixth) implements Tuple {}
+		public <E0> Tuple1<E0> join(Tuple1<E0> other) {
+			return new Tuple1<>(other.element0);
+		}
 
-	record Tuple7<A, B, C, D, E, F, G>(A first, B second, C third, D fourth, E fifth, F sixth,
-	                                   G seventh) implements Tuple {}
+		public <E0, E1> Tuple2<E0, E1> join(Tuple2<E0, E1> other) {
+			return new Tuple2<>(other.element0, other.element1);
+		}
+
+		public <E0, E1, E2> Tuple3<E0, E1, E2> join(Tuple3<E0, E1, E2> other) {
+			return new Tuple3<>(other.element0, other.element1, other.element2);
+		}
+
+		public <E0, E1, E2, E3> Tuple4<E0, E1, E2, E3> join(Tuple4<E0, E1, E2, E3> other) {
+			return new Tuple4<>(other.element0, other.element1, other.element2, other.element3);
+		}
+
+		public <E0, E1, E2, E3, E4> Tuple5<E0, E1, E2, E3, E4> join(Tuple5<E0, E1, E2, E3, E4> other) {
+			return new Tuple5<>(other.element0, other.element1, other.element2, other.element3, other.element4);
+		}
+
+		public <E0, E1, E2, E3, E4, E5> Tuple6<E0, E1, E2, E3, E4, E5> join(Tuple6<E0, E1, E2, E3, E4, E5> other) {
+			return new Tuple6<>(other.element0, other.element1, other.element2, other.element3, other.element4, other.element5);
+		}
+
+		public <E0, E1, E2, E3, E4, E5, E6> Tuple7<E0, E1, E2, E3, E4, E5, E6> join(Tuple7<E0, E1, E2, E3, E4, E5, E6> other) {
+			return new Tuple7<>(other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6);
+		}
+
+		public <E0, E1, E2, E3, E4, E5, E6, E7> Tuple8<E0, E1, E2, E3, E4, E5, E6, E7> join(Tuple8<E0, E1, E2, E3, E4, E5, E6, E7> other) {
+			return new Tuple8<>(other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7);
+		}
+
+		public <E0, E1, E2, E3, E4, E5, E6, E7, E8> Tuple9<E0, E1, E2, E3, E4, E5, E6, E7, E8> join(Tuple9<E0, E1, E2, E3, E4, E5, E6, E7, E8> other) {
+			return new Tuple9<>(other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8);
+		}
+
+		public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> Tuple10<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> join(Tuple10<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> other) {
+			return new Tuple10<>(other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9);
+		}
+
+		public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> Tuple11<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> join(Tuple11<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> other) {
+			return new Tuple11<>(other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9, other.element10);
+		}
+
+		public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11> Tuple12<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11> join(Tuple12<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11> other) {
+			return new Tuple12<>(other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9, other.element10, other.element11);
+		}
+
+		public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11, E12> Tuple13<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11, E12> join(Tuple13<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11, E12> other) {
+			return new Tuple13<>(other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9, other.element10, other.element11, other.element12);
+		}
+
+		public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11, E12, E13> Tuple14<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11, E12, E13> join(Tuple14<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11, E12, E13> other) {
+			return new Tuple14<>(other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9, other.element10, other.element11, other.element12, other.element13);
+		}
+	}
+
+	@FunctionalInterface
+	interface Func0<R> {
+		R apply();
+	}
+
+	record Tuple1<T0>(T0 element0) {
+		public <R> R applyTo(Func1<R, T0> func) {
+			return func.apply(this.element0);
+		}
+
+		public static <R, T0> Result<Tuple1<T0>, R> collect(Tuple1<Result<T0, R>> tuple) {
+			return
+					tuple.element0.flatMap(element0 ->
+							                       Result.ok(new Tuple1<>(element0))
+					)
+					;
+		}
+
+		public <E0> Tuple1<E0> map(Func1<E0, T0> map0) {
+			return new Tuple1<>(map0.apply(this.element0));
+		}
+
+		public Tuple1<T0> join(Tuple0 other) {
+			return new Tuple1<>(this.element0);
+		}
+
+		public <E0> Tuple2<T0, E0> join(Tuple1<E0> other) {
+			return new Tuple2<>(this.element0, other.element0);
+		}
+
+		public <E0, E1> Tuple3<T0, E0, E1> join(Tuple2<E0, E1> other) {
+			return new Tuple3<>(this.element0, other.element0, other.element1);
+		}
+
+		public <E0, E1, E2> Tuple4<T0, E0, E1, E2> join(Tuple3<E0, E1, E2> other) {
+			return new Tuple4<>(this.element0, other.element0, other.element1, other.element2);
+		}
+
+		public <E0, E1, E2, E3> Tuple5<T0, E0, E1, E2, E3> join(Tuple4<E0, E1, E2, E3> other) {
+			return new Tuple5<>(this.element0, other.element0, other.element1, other.element2, other.element3);
+		}
+
+		public <E0, E1, E2, E3, E4> Tuple6<T0, E0, E1, E2, E3, E4> join(Tuple5<E0, E1, E2, E3, E4> other) {
+			return new Tuple6<>(this.element0, other.element0, other.element1, other.element2, other.element3, other.element4);
+		}
+
+		public <E0, E1, E2, E3, E4, E5> Tuple7<T0, E0, E1, E2, E3, E4, E5> join(Tuple6<E0, E1, E2, E3, E4, E5> other) {
+			return new Tuple7<>(this.element0, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5);
+		}
+
+		public <E0, E1, E2, E3, E4, E5, E6> Tuple8<T0, E0, E1, E2, E3, E4, E5, E6> join(Tuple7<E0, E1, E2, E3, E4, E5, E6> other) {
+			return new Tuple8<>(this.element0, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6);
+		}
+
+		public <E0, E1, E2, E3, E4, E5, E6, E7> Tuple9<T0, E0, E1, E2, E3, E4, E5, E6, E7> join(Tuple8<E0, E1, E2, E3, E4, E5, E6, E7> other) {
+			return new Tuple9<>(this.element0, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7);
+		}
+
+		public <E0, E1, E2, E3, E4, E5, E6, E7, E8> Tuple10<T0, E0, E1, E2, E3, E4, E5, E6, E7, E8> join(Tuple9<E0, E1, E2, E3, E4, E5, E6, E7, E8> other) {
+			return new Tuple10<>(this.element0, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8);
+		}
+
+		public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> Tuple11<T0, E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> join(Tuple10<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> other) {
+			return new Tuple11<>(this.element0, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9);
+		}
+
+		public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> Tuple12<T0, E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> join(Tuple11<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> other) {
+			return new Tuple12<>(this.element0, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9, other.element10);
+		}
+
+		public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11> Tuple13<T0, E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11> join(Tuple12<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11> other) {
+			return new Tuple13<>(this.element0, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9, other.element10, other.element11);
+		}
+
+		public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11, E12> Tuple14<T0, E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11, E12> join(Tuple13<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11, E12> other) {
+			return new Tuple14<>(this.element0, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9, other.element10, other.element11, other.element12);
+		}
+	}
+
+	@FunctionalInterface
+	interface Func1<R, T0> {
+		R apply(T0 arg0);
+	}
+
+	record Tuple2<T0, T1>(T0 element0, T1 element1) {
+		public <R> R applyTo(Func2<R, T0, T1> func) {
+			return func.apply(this.element0, this.element1);
+		}
+
+		public static <R, T0, T1> Result<Tuple2<T0, T1>, R> collect(Tuple2<Result<T0, R>, Result<T1, R>> tuple) {
+			return
+					tuple.element0.flatMap(element0 ->
+							                       tuple.element1.flatMap(element1 ->
+									                                              Result.ok(new Tuple2<>(element0, element1))
+							                       )
+					)
+					;
+		}
+
+		public <E0, E1> Tuple2<E0, E1> map(Func1<E0, T0> map0, Func1<E1, T1> map1) {
+			return new Tuple2<>(map0.apply(this.element0), map1.apply(this.element1));
+		}
+
+		public Tuple2<T0, T1> join(Tuple0 other) {
+			return new Tuple2<>(this.element0, this.element1);
+		}
+
+		public <E0> Tuple3<T0, T1, E0> join(Tuple1<E0> other) {
+			return new Tuple3<>(this.element0, this.element1, other.element0);
+		}
+
+		public <E0, E1> Tuple4<T0, T1, E0, E1> join(Tuple2<E0, E1> other) {
+			return new Tuple4<>(this.element0, this.element1, other.element0, other.element1);
+		}
+
+		public <E0, E1, E2> Tuple5<T0, T1, E0, E1, E2> join(Tuple3<E0, E1, E2> other) {
+			return new Tuple5<>(this.element0, this.element1, other.element0, other.element1, other.element2);
+		}
+
+		public <E0, E1, E2, E3> Tuple6<T0, T1, E0, E1, E2, E3> join(Tuple4<E0, E1, E2, E3> other) {
+			return new Tuple6<>(this.element0, this.element1, other.element0, other.element1, other.element2, other.element3);
+		}
+
+		public <E0, E1, E2, E3, E4> Tuple7<T0, T1, E0, E1, E2, E3, E4> join(Tuple5<E0, E1, E2, E3, E4> other) {
+			return new Tuple7<>(this.element0, this.element1, other.element0, other.element1, other.element2, other.element3, other.element4);
+		}
+
+		public <E0, E1, E2, E3, E4, E5> Tuple8<T0, T1, E0, E1, E2, E3, E4, E5> join(Tuple6<E0, E1, E2, E3, E4, E5> other) {
+			return new Tuple8<>(this.element0, this.element1, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5);
+		}
+
+		public <E0, E1, E2, E3, E4, E5, E6> Tuple9<T0, T1, E0, E1, E2, E3, E4, E5, E6> join(Tuple7<E0, E1, E2, E3, E4, E5, E6> other) {
+			return new Tuple9<>(this.element0, this.element1, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6);
+		}
+
+		public <E0, E1, E2, E3, E4, E5, E6, E7> Tuple10<T0, T1, E0, E1, E2, E3, E4, E5, E6, E7> join(Tuple8<E0, E1, E2, E3, E4, E5, E6, E7> other) {
+			return new Tuple10<>(this.element0, this.element1, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7);
+		}
+
+		public <E0, E1, E2, E3, E4, E5, E6, E7, E8> Tuple11<T0, T1, E0, E1, E2, E3, E4, E5, E6, E7, E8> join(Tuple9<E0, E1, E2, E3, E4, E5, E6, E7, E8> other) {
+			return new Tuple11<>(this.element0, this.element1, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8);
+		}
+
+		public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> Tuple12<T0, T1, E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> join(Tuple10<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> other) {
+			return new Tuple12<>(this.element0, this.element1, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9);
+		}
+
+		public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> Tuple13<T0, T1, E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> join(Tuple11<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> other) {
+			return new Tuple13<>(this.element0, this.element1, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9, other.element10);
+		}
+
+		public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11> Tuple14<T0, T1, E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11> join(Tuple12<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11> other) {
+			return new Tuple14<>(this.element0, this.element1, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9, other.element10, other.element11);
+		}
+	}
+
+	@FunctionalInterface
+	interface Func2<R, T0, T1> {
+		R apply(T0 arg0, T1 arg1);
+	}
+
+	record Tuple3<T0, T1, T2>(T0 element0, T1 element1, T2 element2) {
+		public <R> R applyTo(Func3<R, T0, T1, T2> func) {
+			return func.apply(this.element0, this.element1, this.element2);
+		}
+
+		public static <R, T0, T1, T2> Result<Tuple3<T0, T1, T2>, R> collect(Tuple3<Result<T0, R>, Result<T1, R>, Result<T2, R>> tuple) {
+			return
+					tuple.element0.flatMap(element0 ->
+							                       tuple.element1.flatMap(element1 ->
+									                                              tuple.element2.flatMap(element2 ->
+											                                                                     Result.ok(new Tuple3<>(element0, element1, element2))
+									                                              )
+							                       )
+					)
+					;
+		}
+
+		public <E0, E1, E2> Tuple3<E0, E1, E2> map(Func1<E0, T0> map0, Func1<E1, T1> map1, Func1<E2, T2> map2) {
+			return new Tuple3<>(map0.apply(this.element0), map1.apply(this.element1), map2.apply(this.element2));
+		}
+
+		public Tuple3<T0, T1, T2> join(Tuple0 other) {
+			return new Tuple3<>(this.element0, this.element1, this.element2);
+		}
+
+		public <E0> Tuple4<T0, T1, T2, E0> join(Tuple1<E0> other) {
+			return new Tuple4<>(this.element0, this.element1, this.element2, other.element0);
+		}
+
+		public <E0, E1> Tuple5<T0, T1, T2, E0, E1> join(Tuple2<E0, E1> other) {
+			return new Tuple5<>(this.element0, this.element1, this.element2, other.element0, other.element1);
+		}
+
+		public <E0, E1, E2> Tuple6<T0, T1, T2, E0, E1, E2> join(Tuple3<E0, E1, E2> other) {
+			return new Tuple6<>(this.element0, this.element1, this.element2, other.element0, other.element1, other.element2);
+		}
+
+		public <E0, E1, E2, E3> Tuple7<T0, T1, T2, E0, E1, E2, E3> join(Tuple4<E0, E1, E2, E3> other) {
+			return new Tuple7<>(this.element0, this.element1, this.element2, other.element0, other.element1, other.element2, other.element3);
+		}
+
+		public <E0, E1, E2, E3, E4> Tuple8<T0, T1, T2, E0, E1, E2, E3, E4> join(Tuple5<E0, E1, E2, E3, E4> other) {
+			return new Tuple8<>(this.element0, this.element1, this.element2, other.element0, other.element1, other.element2, other.element3, other.element4);
+		}
+
+		public <E0, E1, E2, E3, E4, E5> Tuple9<T0, T1, T2, E0, E1, E2, E3, E4, E5> join(Tuple6<E0, E1, E2, E3, E4, E5> other) {
+			return new Tuple9<>(this.element0, this.element1, this.element2, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5);
+		}
+
+		public <E0, E1, E2, E3, E4, E5, E6> Tuple10<T0, T1, T2, E0, E1, E2, E3, E4, E5, E6> join(Tuple7<E0, E1, E2, E3, E4, E5, E6> other) {
+			return new Tuple10<>(this.element0, this.element1, this.element2, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6);
+		}
+
+		public <E0, E1, E2, E3, E4, E5, E6, E7> Tuple11<T0, T1, T2, E0, E1, E2, E3, E4, E5, E6, E7> join(Tuple8<E0, E1, E2, E3, E4, E5, E6, E7> other) {
+			return new Tuple11<>(this.element0, this.element1, this.element2, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7);
+		}
+
+		public <E0, E1, E2, E3, E4, E5, E6, E7, E8> Tuple12<T0, T1, T2, E0, E1, E2, E3, E4, E5, E6, E7, E8> join(Tuple9<E0, E1, E2, E3, E4, E5, E6, E7, E8> other) {
+			return new Tuple12<>(this.element0, this.element1, this.element2, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8);
+		}
+
+		public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> Tuple13<T0, T1, T2, E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> join(Tuple10<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> other) {
+			return new Tuple13<>(this.element0, this.element1, this.element2, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9);
+		}
+
+		public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> Tuple14<T0, T1, T2, E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> join(Tuple11<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> other) {
+			return new Tuple14<>(this.element0, this.element1, this.element2, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9, other.element10);
+		}
+	}
+
+	@FunctionalInterface
+	interface Func3<R, T0, T1, T2> {
+		R apply(T0 arg0, T1 arg1, T2 arg2);
+	}
+
+	record Tuple4<T0, T1, T2, T3>(T0 element0, T1 element1, T2 element2, T3 element3) {
+		public <R> R applyTo(Func4<R, T0, T1, T2, T3> func) {
+			return func.apply(this.element0, this.element1, this.element2, this.element3);
+		}
+
+		public static <R, T0, T1, T2, T3> Result<Tuple4<T0, T1, T2, T3>, R> collect(Tuple4<Result<T0, R>, Result<T1, R>, Result<T2, R>, Result<T3, R>> tuple) {
+			return
+					tuple.element0.flatMap(element0 ->
+							                       tuple.element1.flatMap(element1 ->
+									                                              tuple.element2.flatMap(element2 ->
+											                                                                     tuple.element3.flatMap(element3 ->
+													                                                                                            Result.ok(new Tuple4<>(element0, element1, element2, element3))
+											                                                                     )
+									                                              )
+							                       )
+					)
+					;
+		}
+
+		public <E0, E1, E2, E3> Tuple4<E0, E1, E2, E3> map(Func1<E0, T0> map0, Func1<E1, T1> map1, Func1<E2, T2> map2, Func1<E3, T3> map3) {
+			return new Tuple4<>(map0.apply(this.element0), map1.apply(this.element1), map2.apply(this.element2), map3.apply(this.element3));
+		}
+
+		public Tuple4<T0, T1, T2, T3> join(Tuple0 other) {
+			return new Tuple4<>(this.element0, this.element1, this.element2, this.element3);
+		}
+
+		public <E0> Tuple5<T0, T1, T2, T3, E0> join(Tuple1<E0> other) {
+			return new Tuple5<>(this.element0, this.element1, this.element2, this.element3, other.element0);
+		}
+
+		public <E0, E1> Tuple6<T0, T1, T2, T3, E0, E1> join(Tuple2<E0, E1> other) {
+			return new Tuple6<>(this.element0, this.element1, this.element2, this.element3, other.element0, other.element1);
+		}
+
+		public <E0, E1, E2> Tuple7<T0, T1, T2, T3, E0, E1, E2> join(Tuple3<E0, E1, E2> other) {
+			return new Tuple7<>(this.element0, this.element1, this.element2, this.element3, other.element0, other.element1, other.element2);
+		}
+
+		public <E0, E1, E2, E3> Tuple8<T0, T1, T2, T3, E0, E1, E2, E3> join(Tuple4<E0, E1, E2, E3> other) {
+			return new Tuple8<>(this.element0, this.element1, this.element2, this.element3, other.element0, other.element1, other.element2, other.element3);
+		}
+
+		public <E0, E1, E2, E3, E4> Tuple9<T0, T1, T2, T3, E0, E1, E2, E3, E4> join(Tuple5<E0, E1, E2, E3, E4> other) {
+			return new Tuple9<>(this.element0, this.element1, this.element2, this.element3, other.element0, other.element1, other.element2, other.element3, other.element4);
+		}
+
+		public <E0, E1, E2, E3, E4, E5> Tuple10<T0, T1, T2, T3, E0, E1, E2, E3, E4, E5> join(Tuple6<E0, E1, E2, E3, E4, E5> other) {
+			return new Tuple10<>(this.element0, this.element1, this.element2, this.element3, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5);
+		}
+
+		public <E0, E1, E2, E3, E4, E5, E6> Tuple11<T0, T1, T2, T3, E0, E1, E2, E3, E4, E5, E6> join(Tuple7<E0, E1, E2, E3, E4, E5, E6> other) {
+			return new Tuple11<>(this.element0, this.element1, this.element2, this.element3, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6);
+		}
+
+		public <E0, E1, E2, E3, E4, E5, E6, E7> Tuple12<T0, T1, T2, T3, E0, E1, E2, E3, E4, E5, E6, E7> join(Tuple8<E0, E1, E2, E3, E4, E5, E6, E7> other) {
+			return new Tuple12<>(this.element0, this.element1, this.element2, this.element3, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7);
+		}
+
+		public <E0, E1, E2, E3, E4, E5, E6, E7, E8> Tuple13<T0, T1, T2, T3, E0, E1, E2, E3, E4, E5, E6, E7, E8> join(Tuple9<E0, E1, E2, E3, E4, E5, E6, E7, E8> other) {
+			return new Tuple13<>(this.element0, this.element1, this.element2, this.element3, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8);
+		}
+
+		public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> Tuple14<T0, T1, T2, T3, E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> join(Tuple10<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> other) {
+			return new Tuple14<>(this.element0, this.element1, this.element2, this.element3, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9);
+		}
+	}
+
+	@FunctionalInterface
+	interface Func4<R, T0, T1, T2, T3> {
+		R apply(T0 arg0, T1 arg1, T2 arg2, T3 arg3);
+	}
+
+	record Tuple5<T0, T1, T2, T3, T4>(T0 element0, T1 element1, T2 element2, T3 element3, T4 element4) {
+		public <R> R applyTo(Func5<R, T0, T1, T2, T3, T4> func) {
+			return func.apply(this.element0, this.element1, this.element2, this.element3, this.element4);
+		}
+
+		public static <R, T0, T1, T2, T3, T4> Result<Tuple5<T0, T1, T2, T3, T4>, R> collect(Tuple5<Result<T0, R>, Result<T1, R>, Result<T2, R>, Result<T3, R>, Result<T4, R>> tuple) {
+			return
+					tuple.element0.flatMap(element0 ->
+							                       tuple.element1.flatMap(element1 ->
+									                                              tuple.element2.flatMap(element2 ->
+											                                                                     tuple.element3.flatMap(element3 ->
+													                                                                                            tuple.element4.flatMap(element4 ->
+															                                                                                                                   Result.ok(new Tuple5<>(element0, element1, element2, element3, element4))
+													                                                                                            )
+											                                                                     )
+									                                              )
+							                       )
+					)
+					;
+		}
+
+		public <E0, E1, E2, E3, E4> Tuple5<E0, E1, E2, E3, E4> map(Func1<E0, T0> map0, Func1<E1, T1> map1, Func1<E2, T2> map2, Func1<E3, T3> map3, Func1<E4, T4> map4) {
+			return new Tuple5<>(map0.apply(this.element0), map1.apply(this.element1), map2.apply(this.element2), map3.apply(this.element3), map4.apply(this.element4));
+		}
+
+		public Tuple5<T0, T1, T2, T3, T4> join(Tuple0 other) {
+			return new Tuple5<>(this.element0, this.element1, this.element2, this.element3, this.element4);
+		}
+
+		public <E0> Tuple6<T0, T1, T2, T3, T4, E0> join(Tuple1<E0> other) {
+			return new Tuple6<>(this.element0, this.element1, this.element2, this.element3, this.element4, other.element0);
+		}
+
+		public <E0, E1> Tuple7<T0, T1, T2, T3, T4, E0, E1> join(Tuple2<E0, E1> other) {
+			return new Tuple7<>(this.element0, this.element1, this.element2, this.element3, this.element4, other.element0, other.element1);
+		}
+
+		public <E0, E1, E2> Tuple8<T0, T1, T2, T3, T4, E0, E1, E2> join(Tuple3<E0, E1, E2> other) {
+			return new Tuple8<>(this.element0, this.element1, this.element2, this.element3, this.element4, other.element0, other.element1, other.element2);
+		}
+
+		public <E0, E1, E2, E3> Tuple9<T0, T1, T2, T3, T4, E0, E1, E2, E3> join(Tuple4<E0, E1, E2, E3> other) {
+			return new Tuple9<>(this.element0, this.element1, this.element2, this.element3, this.element4, other.element0, other.element1, other.element2, other.element3);
+		}
+
+		public <E0, E1, E2, E3, E4> Tuple10<T0, T1, T2, T3, T4, E0, E1, E2, E3, E4> join(Tuple5<E0, E1, E2, E3, E4> other) {
+			return new Tuple10<>(this.element0, this.element1, this.element2, this.element3, this.element4, other.element0, other.element1, other.element2, other.element3, other.element4);
+		}
+
+		public <E0, E1, E2, E3, E4, E5> Tuple11<T0, T1, T2, T3, T4, E0, E1, E2, E3, E4, E5> join(Tuple6<E0, E1, E2, E3, E4, E5> other) {
+			return new Tuple11<>(this.element0, this.element1, this.element2, this.element3, this.element4, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5);
+		}
+
+		public <E0, E1, E2, E3, E4, E5, E6> Tuple12<T0, T1, T2, T3, T4, E0, E1, E2, E3, E4, E5, E6> join(Tuple7<E0, E1, E2, E3, E4, E5, E6> other) {
+			return new Tuple12<>(this.element0, this.element1, this.element2, this.element3, this.element4, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6);
+		}
+
+		public <E0, E1, E2, E3, E4, E5, E6, E7> Tuple13<T0, T1, T2, T3, T4, E0, E1, E2, E3, E4, E5, E6, E7> join(Tuple8<E0, E1, E2, E3, E4, E5, E6, E7> other) {
+			return new Tuple13<>(this.element0, this.element1, this.element2, this.element3, this.element4, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7);
+		}
+
+		public <E0, E1, E2, E3, E4, E5, E6, E7, E8> Tuple14<T0, T1, T2, T3, T4, E0, E1, E2, E3, E4, E5, E6, E7, E8> join(Tuple9<E0, E1, E2, E3, E4, E5, E6, E7, E8> other) {
+			return new Tuple14<>(this.element0, this.element1, this.element2, this.element3, this.element4, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8);
+		}
+	}
+
+	@FunctionalInterface
+	interface Func5<R, T0, T1, T2, T3, T4> {
+		R apply(T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4);
+	}
+
+	record Tuple6<T0, T1, T2, T3, T4, T5>(T0 element0, T1 element1, T2 element2, T3 element3, T4 element4,
+	                                      T5 element5) {
+		public <R> R applyTo(Func6<R, T0, T1, T2, T3, T4, T5> func) {
+			return func.apply(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5);
+		}
+
+		public static <R, T0, T1, T2, T3, T4, T5> Result<Tuple6<T0, T1, T2, T3, T4, T5>, R> collect(Tuple6<Result<T0, R>, Result<T1, R>, Result<T2, R>, Result<T3, R>, Result<T4, R>, Result<T5, R>> tuple) {
+			return
+					tuple.element0.flatMap(element0 ->
+							                       tuple.element1.flatMap(element1 ->
+									                                              tuple.element2.flatMap(element2 ->
+											                                                                     tuple.element3.flatMap(element3 ->
+													                                                                                            tuple.element4.flatMap(element4 ->
+															                                                                                                                   tuple.element5.flatMap(element5 ->
+																	                                                                                                                                          Result.ok(new Tuple6<>(element0, element1, element2, element3, element4, element5))
+															                                                                                                                   )
+													                                                                                            )
+											                                                                     )
+									                                              )
+							                       )
+					)
+					;
+		}
+
+		public <E0, E1, E2, E3, E4, E5> Tuple6<E0, E1, E2, E3, E4, E5> map(Func1<E0, T0> map0, Func1<E1, T1> map1, Func1<E2, T2> map2, Func1<E3, T3> map3, Func1<E4, T4> map4, Func1<E5, T5> map5) {
+			return new Tuple6<>(map0.apply(this.element0), map1.apply(this.element1), map2.apply(this.element2), map3.apply(this.element3), map4.apply(this.element4), map5.apply(this.element5));
+		}
+
+		public Tuple6<T0, T1, T2, T3, T4, T5> join(Tuple0 other) {
+			return new Tuple6<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5);
+		}
+
+		public <E0> Tuple7<T0, T1, T2, T3, T4, T5, E0> join(Tuple1<E0> other) {
+			return new Tuple7<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, other.element0);
+		}
+
+		public <E0, E1> Tuple8<T0, T1, T2, T3, T4, T5, E0, E1> join(Tuple2<E0, E1> other) {
+			return new Tuple8<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, other.element0, other.element1);
+		}
+
+		public <E0, E1, E2> Tuple9<T0, T1, T2, T3, T4, T5, E0, E1, E2> join(Tuple3<E0, E1, E2> other) {
+			return new Tuple9<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, other.element0, other.element1, other.element2);
+		}
+
+		public <E0, E1, E2, E3> Tuple10<T0, T1, T2, T3, T4, T5, E0, E1, E2, E3> join(Tuple4<E0, E1, E2, E3> other) {
+			return new Tuple10<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, other.element0, other.element1, other.element2, other.element3);
+		}
+
+		public <E0, E1, E2, E3, E4> Tuple11<T0, T1, T2, T3, T4, T5, E0, E1, E2, E3, E4> join(Tuple5<E0, E1, E2, E3, E4> other) {
+			return new Tuple11<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, other.element0, other.element1, other.element2, other.element3, other.element4);
+		}
+
+		public <E0, E1, E2, E3, E4, E5> Tuple12<T0, T1, T2, T3, T4, T5, E0, E1, E2, E3, E4, E5> join(Tuple6<E0, E1, E2, E3, E4, E5> other) {
+			return new Tuple12<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5);
+		}
+
+		public <E0, E1, E2, E3, E4, E5, E6> Tuple13<T0, T1, T2, T3, T4, T5, E0, E1, E2, E3, E4, E5, E6> join(Tuple7<E0, E1, E2, E3, E4, E5, E6> other) {
+			return new Tuple13<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6);
+		}
+
+		public <E0, E1, E2, E3, E4, E5, E6, E7> Tuple14<T0, T1, T2, T3, T4, T5, E0, E1, E2, E3, E4, E5, E6, E7> join(Tuple8<E0, E1, E2, E3, E4, E5, E6, E7> other) {
+			return new Tuple14<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7);
+		}
+	}
+
+	@FunctionalInterface
+	interface Func6<R, T0, T1, T2, T3, T4, T5> {
+		R apply(T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5);
+	}
+
+	record Tuple7<T0, T1, T2, T3, T4, T5, T6>(T0 element0, T1 element1, T2 element2, T3 element3, T4 element4,
+	                                          T5 element5, T6 element6) {
+		public <R> R applyTo(Func7<R, T0, T1, T2, T3, T4, T5, T6> func) {
+			return func.apply(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6);
+		}
+
+		public static <R, T0, T1, T2, T3, T4, T5, T6> Result<Tuple7<T0, T1, T2, T3, T4, T5, T6>, R> collect(Tuple7<Result<T0, R>, Result<T1, R>, Result<T2, R>, Result<T3, R>, Result<T4, R>, Result<T5, R>, Result<T6, R>> tuple) {
+			return
+					tuple.element0.flatMap(element0 ->
+							                       tuple.element1.flatMap(element1 ->
+									                                              tuple.element2.flatMap(element2 ->
+											                                                                     tuple.element3.flatMap(element3 ->
+													                                                                                            tuple.element4.flatMap(element4 ->
+															                                                                                                                   tuple.element5.flatMap(element5 ->
+																	                                                                                                                                          tuple.element6.flatMap(element6 ->
+																			                                                                                                                                                                 Result.ok(new Tuple7<>(element0, element1, element2, element3, element4, element5, element6))
+																	                                                                                                                                          )
+															                                                                                                                   )
+													                                                                                            )
+											                                                                     )
+									                                              )
+							                       )
+					)
+					;
+		}
+
+		public <E0, E1, E2, E3, E4, E5, E6> Tuple7<E0, E1, E2, E3, E4, E5, E6> map(Func1<E0, T0> map0, Func1<E1, T1> map1, Func1<E2, T2> map2, Func1<E3, T3> map3, Func1<E4, T4> map4, Func1<E5, T5> map5, Func1<E6, T6> map6) {
+			return new Tuple7<>(map0.apply(this.element0), map1.apply(this.element1), map2.apply(this.element2), map3.apply(this.element3), map4.apply(this.element4), map5.apply(this.element5), map6.apply(this.element6));
+		}
+
+		public Tuple7<T0, T1, T2, T3, T4, T5, T6> join(Tuple0 other) {
+			return new Tuple7<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6);
+		}
+
+		public <E0> Tuple8<T0, T1, T2, T3, T4, T5, T6, E0> join(Tuple1<E0> other) {
+			return new Tuple8<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, other.element0);
+		}
+
+		public <E0, E1> Tuple9<T0, T1, T2, T3, T4, T5, T6, E0, E1> join(Tuple2<E0, E1> other) {
+			return new Tuple9<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, other.element0, other.element1);
+		}
+
+		public <E0, E1, E2> Tuple10<T0, T1, T2, T3, T4, T5, T6, E0, E1, E2> join(Tuple3<E0, E1, E2> other) {
+			return new Tuple10<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, other.element0, other.element1, other.element2);
+		}
+
+		public <E0, E1, E2, E3> Tuple11<T0, T1, T2, T3, T4, T5, T6, E0, E1, E2, E3> join(Tuple4<E0, E1, E2, E3> other) {
+			return new Tuple11<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, other.element0, other.element1, other.element2, other.element3);
+		}
+
+		public <E0, E1, E2, E3, E4> Tuple12<T0, T1, T2, T3, T4, T5, T6, E0, E1, E2, E3, E4> join(Tuple5<E0, E1, E2, E3, E4> other) {
+			return new Tuple12<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, other.element0, other.element1, other.element2, other.element3, other.element4);
+		}
+
+		public <E0, E1, E2, E3, E4, E5> Tuple13<T0, T1, T2, T3, T4, T5, T6, E0, E1, E2, E3, E4, E5> join(Tuple6<E0, E1, E2, E3, E4, E5> other) {
+			return new Tuple13<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5);
+		}
+
+		public <E0, E1, E2, E3, E4, E5, E6> Tuple14<T0, T1, T2, T3, T4, T5, T6, E0, E1, E2, E3, E4, E5, E6> join(Tuple7<E0, E1, E2, E3, E4, E5, E6> other) {
+			return new Tuple14<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6);
+		}
+	}
+
+	@FunctionalInterface
+	interface Func7<R, T0, T1, T2, T3, T4, T5, T6> {
+		R apply(T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6);
+	}
+
+	record Tuple8<T0, T1, T2, T3, T4, T5, T6, T7>(T0 element0, T1 element1, T2 element2, T3 element3, T4 element4,
+	                                              T5 element5, T6 element6, T7 element7) {
+		public <R> R applyTo(Func8<R, T0, T1, T2, T3, T4, T5, T6, T7> func) {
+			return func.apply(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7);
+		}
+
+		public static <R, T0, T1, T2, T3, T4, T5, T6, T7> Result<Tuple8<T0, T1, T2, T3, T4, T5, T6, T7>, R> collect(Tuple8<Result<T0, R>, Result<T1, R>, Result<T2, R>, Result<T3, R>, Result<T4, R>, Result<T5, R>, Result<T6, R>, Result<T7, R>> tuple) {
+			return
+					tuple.element0.flatMap(element0 ->
+							                       tuple.element1.flatMap(element1 ->
+									                                              tuple.element2.flatMap(element2 ->
+											                                                                     tuple.element3.flatMap(element3 ->
+													                                                                                            tuple.element4.flatMap(element4 ->
+															                                                                                                                   tuple.element5.flatMap(element5 ->
+																	                                                                                                                                          tuple.element6.flatMap(element6 ->
+																			                                                                                                                                                                 tuple.element7.flatMap(element7 ->
+																					                                                                                                                                                                                        Result.ok(new Tuple8<>(element0, element1, element2, element3, element4, element5, element6, element7))
+																			                                                                                                                                                                 )
+																	                                                                                                                                          )
+															                                                                                                                   )
+													                                                                                            )
+											                                                                     )
+									                                              )
+							                       )
+					)
+					;
+		}
+
+		public <E0, E1, E2, E3, E4, E5, E6, E7> Tuple8<E0, E1, E2, E3, E4, E5, E6, E7> map(Func1<E0, T0> map0, Func1<E1, T1> map1, Func1<E2, T2> map2, Func1<E3, T3> map3, Func1<E4, T4> map4, Func1<E5, T5> map5, Func1<E6, T6> map6, Func1<E7, T7> map7) {
+			return new Tuple8<>(map0.apply(this.element0), map1.apply(this.element1), map2.apply(this.element2), map3.apply(this.element3), map4.apply(this.element4), map5.apply(this.element5), map6.apply(this.element6), map7.apply(this.element7));
+		}
+
+		public Tuple8<T0, T1, T2, T3, T4, T5, T6, T7> join(Tuple0 other) {
+			return new Tuple8<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7);
+		}
+
+		public <E0> Tuple9<T0, T1, T2, T3, T4, T5, T6, T7, E0> join(Tuple1<E0> other) {
+			return new Tuple9<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, other.element0);
+		}
+
+		public <E0, E1> Tuple10<T0, T1, T2, T3, T4, T5, T6, T7, E0, E1> join(Tuple2<E0, E1> other) {
+			return new Tuple10<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, other.element0, other.element1);
+		}
+
+		public <E0, E1, E2> Tuple11<T0, T1, T2, T3, T4, T5, T6, T7, E0, E1, E2> join(Tuple3<E0, E1, E2> other) {
+			return new Tuple11<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, other.element0, other.element1, other.element2);
+		}
+
+		public <E0, E1, E2, E3> Tuple12<T0, T1, T2, T3, T4, T5, T6, T7, E0, E1, E2, E3> join(Tuple4<E0, E1, E2, E3> other) {
+			return new Tuple12<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, other.element0, other.element1, other.element2, other.element3);
+		}
+
+		public <E0, E1, E2, E3, E4> Tuple13<T0, T1, T2, T3, T4, T5, T6, T7, E0, E1, E2, E3, E4> join(Tuple5<E0, E1, E2, E3, E4> other) {
+			return new Tuple13<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, other.element0, other.element1, other.element2, other.element3, other.element4);
+		}
+
+		public <E0, E1, E2, E3, E4, E5> Tuple14<T0, T1, T2, T3, T4, T5, T6, T7, E0, E1, E2, E3, E4, E5> join(Tuple6<E0, E1, E2, E3, E4, E5> other) {
+			return new Tuple14<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5);
+		}
+	}
+
+	@FunctionalInterface
+	interface Func8<R, T0, T1, T2, T3, T4, T5, T6, T7> {
+		R apply(T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7);
+	}
+
+	record Tuple9<T0, T1, T2, T3, T4, T5, T6, T7, T8>(T0 element0, T1 element1, T2 element2, T3 element3, T4 element4,
+	                                                  T5 element5, T6 element6, T7 element7, T8 element8) {
+		public <R> R applyTo(Func9<R, T0, T1, T2, T3, T4, T5, T6, T7, T8> func) {
+			return func.apply(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8);
+		}
+
+		public static <R, T0, T1, T2, T3, T4, T5, T6, T7, T8> Result<Tuple9<T0, T1, T2, T3, T4, T5, T6, T7, T8>, R> collect(Tuple9<Result<T0, R>, Result<T1, R>, Result<T2, R>, Result<T3, R>, Result<T4, R>, Result<T5, R>, Result<T6, R>, Result<T7, R>, Result<T8, R>> tuple) {
+			return
+					tuple.element0.flatMap(element0 ->
+							                       tuple.element1.flatMap(element1 ->
+									                                              tuple.element2.flatMap(element2 ->
+											                                                                     tuple.element3.flatMap(element3 ->
+													                                                                                            tuple.element4.flatMap(element4 ->
+															                                                                                                                   tuple.element5.flatMap(element5 ->
+																	                                                                                                                                          tuple.element6.flatMap(element6 ->
+																			                                                                                                                                                                 tuple.element7.flatMap(element7 ->
+																					                                                                                                                                                                                        tuple.element8.flatMap(element8 ->
+																							                                                                                                                                                                                                               Result.ok(new Tuple9<>(element0, element1, element2, element3, element4, element5, element6, element7, element8))
+																					                                                                                                                                                                                        )
+																			                                                                                                                                                                 )
+																	                                                                                                                                          )
+															                                                                                                                   )
+													                                                                                            )
+											                                                                     )
+									                                              )
+							                       )
+					)
+					;
+		}
+
+		public <E0, E1, E2, E3, E4, E5, E6, E7, E8> Tuple9<E0, E1, E2, E3, E4, E5, E6, E7, E8> map(Func1<E0, T0> map0, Func1<E1, T1> map1, Func1<E2, T2> map2, Func1<E3, T3> map3, Func1<E4, T4> map4, Func1<E5, T5> map5, Func1<E6, T6> map6, Func1<E7, T7> map7, Func1<E8, T8> map8) {
+			return new Tuple9<>(map0.apply(this.element0), map1.apply(this.element1), map2.apply(this.element2), map3.apply(this.element3), map4.apply(this.element4), map5.apply(this.element5), map6.apply(this.element6), map7.apply(this.element7), map8.apply(this.element8));
+		}
+
+		public Tuple9<T0, T1, T2, T3, T4, T5, T6, T7, T8> join(Tuple0 other) {
+			return new Tuple9<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8);
+		}
+
+		public <E0> Tuple10<T0, T1, T2, T3, T4, T5, T6, T7, T8, E0> join(Tuple1<E0> other) {
+			return new Tuple10<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, other.element0);
+		}
+
+		public <E0, E1> Tuple11<T0, T1, T2, T3, T4, T5, T6, T7, T8, E0, E1> join(Tuple2<E0, E1> other) {
+			return new Tuple11<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, other.element0, other.element1);
+		}
+
+		public <E0, E1, E2> Tuple12<T0, T1, T2, T3, T4, T5, T6, T7, T8, E0, E1, E2> join(Tuple3<E0, E1, E2> other) {
+			return new Tuple12<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, other.element0, other.element1, other.element2);
+		}
+
+		public <E0, E1, E2, E3> Tuple13<T0, T1, T2, T3, T4, T5, T6, T7, T8, E0, E1, E2, E3> join(Tuple4<E0, E1, E2, E3> other) {
+			return new Tuple13<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, other.element0, other.element1, other.element2, other.element3);
+		}
+
+		public <E0, E1, E2, E3, E4> Tuple14<T0, T1, T2, T3, T4, T5, T6, T7, T8, E0, E1, E2, E3, E4> join(Tuple5<E0, E1, E2, E3, E4> other) {
+			return new Tuple14<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, other.element0, other.element1, other.element2, other.element3, other.element4);
+		}
+	}
+
+	@FunctionalInterface
+	interface Func9<R, T0, T1, T2, T3, T4, T5, T6, T7, T8> {
+		R apply(T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8);
+	}
+
+	record Tuple10<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(T0 element0, T1 element1, T2 element2, T3 element3,
+	                                                       T4 element4, T5 element5, T6 element6, T7 element7,
+	                                                       T8 element8, T9 element9) {
+		public <R> R applyTo(Func10<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> func) {
+			return func.apply(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, this.element9);
+		}
+
+		public static <R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Result<Tuple10<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>, R> collect(Tuple10<Result<T0, R>, Result<T1, R>, Result<T2, R>, Result<T3, R>, Result<T4, R>, Result<T5, R>, Result<T6, R>, Result<T7, R>, Result<T8, R>, Result<T9, R>> tuple) {
+			return
+					tuple.element0.flatMap(element0 ->
+							                       tuple.element1.flatMap(element1 ->
+									                                              tuple.element2.flatMap(element2 ->
+											                                                                     tuple.element3.flatMap(element3 ->
+													                                                                                            tuple.element4.flatMap(element4 ->
+															                                                                                                                   tuple.element5.flatMap(element5 ->
+																	                                                                                                                                          tuple.element6.flatMap(element6 ->
+																			                                                                                                                                                                 tuple.element7.flatMap(element7 ->
+																					                                                                                                                                                                                        tuple.element8.flatMap(element8 ->
+																							                                                                                                                                                                                                               tuple.element9.flatMap(element9 ->
+																									                                                                                                                                                                                                                                      Result.ok(new Tuple10<>(element0, element1, element2, element3, element4, element5, element6, element7, element8, element9))
+																							                                                                                                                                                                                                               )
+																					                                                                                                                                                                                        )
+																			                                                                                                                                                                 )
+																	                                                                                                                                          )
+															                                                                                                                   )
+													                                                                                            )
+											                                                                     )
+									                                              )
+							                       )
+					)
+					;
+		}
+
+		public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> Tuple10<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> map(Func1<E0, T0> map0, Func1<E1, T1> map1, Func1<E2, T2> map2, Func1<E3, T3> map3, Func1<E4, T4> map4, Func1<E5, T5> map5, Func1<E6, T6> map6, Func1<E7, T7> map7, Func1<E8, T8> map8, Func1<E9, T9> map9) {
+			return new Tuple10<>(map0.apply(this.element0), map1.apply(this.element1), map2.apply(this.element2), map3.apply(this.element3), map4.apply(this.element4), map5.apply(this.element5), map6.apply(this.element6), map7.apply(this.element7), map8.apply(this.element8), map9.apply(this.element9));
+		}
+
+		public Tuple10<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> join(Tuple0 other) {
+			return new Tuple10<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, this.element9);
+		}
+
+		public <E0> Tuple11<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, E0> join(Tuple1<E0> other) {
+			return new Tuple11<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, this.element9, other.element0);
+		}
+
+		public <E0, E1> Tuple12<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, E0, E1> join(Tuple2<E0, E1> other) {
+			return new Tuple12<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, this.element9, other.element0, other.element1);
+		}
+
+		public <E0, E1, E2> Tuple13<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, E0, E1, E2> join(Tuple3<E0, E1, E2> other) {
+			return new Tuple13<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, this.element9, other.element0, other.element1, other.element2);
+		}
+
+		public <E0, E1, E2, E3> Tuple14<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, E0, E1, E2, E3> join(Tuple4<E0, E1, E2, E3> other) {
+			return new Tuple14<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, this.element9, other.element0, other.element1, other.element2, other.element3);
+		}
+	}
+
+	@FunctionalInterface
+	interface Func10<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> {
+		R apply(T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9);
+	}
+
+	record Tuple11<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(T0 element0, T1 element1, T2 element2, T3 element3,
+	                                                            T4 element4, T5 element5, T6 element6, T7 element7,
+	                                                            T8 element8, T9 element9, T10 element10) {
+		public <R> R applyTo(Func11<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> func) {
+			return func.apply(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, this.element9, this.element10);
+		}
+
+		public static <R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Result<Tuple11<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, R> collect(Tuple11<Result<T0, R>, Result<T1, R>, Result<T2, R>, Result<T3, R>, Result<T4, R>, Result<T5, R>, Result<T6, R>, Result<T7, R>, Result<T8, R>, Result<T9, R>, Result<T10, R>> tuple) {
+			return
+					tuple.element0.flatMap(element0 ->
+							                       tuple.element1.flatMap(element1 ->
+									                                              tuple.element2.flatMap(element2 ->
+											                                                                     tuple.element3.flatMap(element3 ->
+													                                                                                            tuple.element4.flatMap(element4 ->
+															                                                                                                                   tuple.element5.flatMap(element5 ->
+																	                                                                                                                                          tuple.element6.flatMap(element6 ->
+																			                                                                                                                                                                 tuple.element7.flatMap(element7 ->
+																					                                                                                                                                                                                        tuple.element8.flatMap(element8 ->
+																							                                                                                                                                                                                                               tuple.element9.flatMap(element9 ->
+																									                                                                                                                                                                                                                                      tuple.element10.flatMap(element10 ->
+																											                                                                                                                                                                                                                                                              Result.ok(new Tuple11<>(element0, element1, element2, element3, element4, element5, element6, element7, element8, element9, element10))
+																									                                                                                                                                                                                                                                      )
+																							                                                                                                                                                                                                               )
+																					                                                                                                                                                                                        )
+																			                                                                                                                                                                 )
+																	                                                                                                                                          )
+															                                                                                                                   )
+													                                                                                            )
+											                                                                     )
+									                                              )
+							                       )
+					)
+					;
+		}
+
+		public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> Tuple11<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> map(Func1<E0, T0> map0, Func1<E1, T1> map1, Func1<E2, T2> map2, Func1<E3, T3> map3, Func1<E4, T4> map4, Func1<E5, T5> map5, Func1<E6, T6> map6, Func1<E7, T7> map7, Func1<E8, T8> map8, Func1<E9, T9> map9, Func1<E10, T10> map10) {
+			return new Tuple11<>(map0.apply(this.element0), map1.apply(this.element1), map2.apply(this.element2), map3.apply(this.element3), map4.apply(this.element4), map5.apply(this.element5), map6.apply(this.element6), map7.apply(this.element7), map8.apply(this.element8), map9.apply(this.element9), map10.apply(this.element10));
+		}
+
+		public Tuple11<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> join(Tuple0 other) {
+			return new Tuple11<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, this.element9, this.element10);
+		}
+
+		public <E0> Tuple12<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, E0> join(Tuple1<E0> other) {
+			return new Tuple12<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, this.element9, this.element10, other.element0);
+		}
+
+		public <E0, E1> Tuple13<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, E0, E1> join(Tuple2<E0, E1> other) {
+			return new Tuple13<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, this.element9, this.element10, other.element0, other.element1);
+		}
+
+		public <E0, E1, E2> Tuple14<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, E0, E1, E2> join(Tuple3<E0, E1, E2> other) {
+			return new Tuple14<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, this.element9, this.element10, other.element0, other.element1, other.element2);
+		}
+	}
+
+	@FunctionalInterface
+	interface Func11<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> {
+		R apply(T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10);
+	}
+
+	record Tuple12<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(T0 element0, T1 element1, T2 element2, T3 element3,
+	                                                                 T4 element4, T5 element5, T6 element6, T7 element7,
+	                                                                 T8 element8, T9 element9, T10 element10,
+	                                                                 T11 element11) {
+		public <R> R applyTo(Func12<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> func) {
+			return func.apply(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, this.element9, this.element10, this.element11);
+		}
+
+		public static <R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Result<Tuple12<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>, R> collect(Tuple12<Result<T0, R>, Result<T1, R>, Result<T2, R>, Result<T3, R>, Result<T4, R>, Result<T5, R>, Result<T6, R>, Result<T7, R>, Result<T8, R>, Result<T9, R>, Result<T10, R>, Result<T11, R>> tuple) {
+			return
+					tuple.element0.flatMap(element0 ->
+							                       tuple.element1.flatMap(element1 ->
+									                                              tuple.element2.flatMap(element2 ->
+											                                                                     tuple.element3.flatMap(element3 ->
+													                                                                                            tuple.element4.flatMap(element4 ->
+															                                                                                                                   tuple.element5.flatMap(element5 ->
+																	                                                                                                                                          tuple.element6.flatMap(element6 ->
+																			                                                                                                                                                                 tuple.element7.flatMap(element7 ->
+																					                                                                                                                                                                                        tuple.element8.flatMap(element8 ->
+																							                                                                                                                                                                                                               tuple.element9.flatMap(element9 ->
+																									                                                                                                                                                                                                                                      tuple.element10.flatMap(element10 ->
+																											                                                                                                                                                                                                                                                              tuple.element11.flatMap(element11 ->
+																													                                                                                                                                                                                                                                                                                      Result.ok(new Tuple12<>(element0, element1, element2, element3, element4, element5, element6, element7, element8, element9, element10, element11))
+																											                                                                                                                                                                                                                                                              )
+																									                                                                                                                                                                                                                                      )
+																							                                                                                                                                                                                                               )
+																					                                                                                                                                                                                        )
+																			                                                                                                                                                                 )
+																	                                                                                                                                          )
+															                                                                                                                   )
+													                                                                                            )
+											                                                                     )
+									                                              )
+							                       )
+					)
+					;
+		}
+
+		public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11> Tuple12<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11> map(Func1<E0, T0> map0, Func1<E1, T1> map1, Func1<E2, T2> map2, Func1<E3, T3> map3, Func1<E4, T4> map4, Func1<E5, T5> map5, Func1<E6, T6> map6, Func1<E7, T7> map7, Func1<E8, T8> map8, Func1<E9, T9> map9, Func1<E10, T10> map10, Func1<E11, T11> map11) {
+			return new Tuple12<>(map0.apply(this.element0), map1.apply(this.element1), map2.apply(this.element2), map3.apply(this.element3), map4.apply(this.element4), map5.apply(this.element5), map6.apply(this.element6), map7.apply(this.element7), map8.apply(this.element8), map9.apply(this.element9), map10.apply(this.element10), map11.apply(this.element11));
+		}
+
+		public Tuple12<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> join(Tuple0 other) {
+			return new Tuple12<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, this.element9, this.element10, this.element11);
+		}
+
+		public <E0> Tuple13<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, E0> join(Tuple1<E0> other) {
+			return new Tuple13<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, this.element9, this.element10, this.element11, other.element0);
+		}
+
+		public <E0, E1> Tuple14<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, E0, E1> join(Tuple2<E0, E1> other) {
+			return new Tuple14<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, this.element9, this.element10, this.element11, other.element0, other.element1);
+		}
+	}
+
+	@FunctionalInterface
+	interface Func12<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> {
+		R apply(T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11);
+	}
+
+	record Tuple13<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(T0 element0, T1 element1, T2 element2,
+	                                                                      T3 element3, T4 element4, T5 element5,
+	                                                                      T6 element6, T7 element7, T8 element8,
+	                                                                      T9 element9, T10 element10, T11 element11,
+	                                                                      T12 element12) {
+		public <R> R applyTo(Func13<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> func) {
+			return func.apply(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, this.element9, this.element10, this.element11, this.element12);
+		}
+
+		public static <R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Result<Tuple13<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, R> collect(Tuple13<Result<T0, R>, Result<T1, R>, Result<T2, R>, Result<T3, R>, Result<T4, R>, Result<T5, R>, Result<T6, R>, Result<T7, R>, Result<T8, R>, Result<T9, R>, Result<T10, R>, Result<T11, R>, Result<T12, R>> tuple) {
+			return
+					tuple.element0.flatMap(element0 ->
+							                       tuple.element1.flatMap(element1 ->
+									                                              tuple.element2.flatMap(element2 ->
+											                                                                     tuple.element3.flatMap(element3 ->
+													                                                                                            tuple.element4.flatMap(element4 ->
+															                                                                                                                   tuple.element5.flatMap(element5 ->
+																	                                                                                                                                          tuple.element6.flatMap(element6 ->
+																			                                                                                                                                                                 tuple.element7.flatMap(element7 ->
+																					                                                                                                                                                                                        tuple.element8.flatMap(element8 ->
+																							                                                                                                                                                                                                               tuple.element9.flatMap(element9 ->
+																									                                                                                                                                                                                                                                      tuple.element10.flatMap(element10 ->
+																											                                                                                                                                                                                                                                                              tuple.element11.flatMap(element11 ->
+																													                                                                                                                                                                                                                                                                                      tuple.element12.flatMap(element12 ->
+																															                                                                                                                                                                                                                                                                                                              Result.ok(new Tuple13<>(element0, element1, element2, element3, element4, element5, element6, element7, element8, element9, element10, element11, element12))
+																													                                                                                                                                                                                                                                                                                      )
+																											                                                                                                                                                                                                                                                              )
+																									                                                                                                                                                                                                                                      )
+																							                                                                                                                                                                                                               )
+																					                                                                                                                                                                                        )
+																			                                                                                                                                                                 )
+																	                                                                                                                                          )
+															                                                                                                                   )
+													                                                                                            )
+											                                                                     )
+									                                              )
+							                       )
+					)
+					;
+		}
+
+		public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11, E12> Tuple13<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11, E12> map(Func1<E0, T0> map0, Func1<E1, T1> map1, Func1<E2, T2> map2, Func1<E3, T3> map3, Func1<E4, T4> map4, Func1<E5, T5> map5, Func1<E6, T6> map6, Func1<E7, T7> map7, Func1<E8, T8> map8, Func1<E9, T9> map9, Func1<E10, T10> map10, Func1<E11, T11> map11, Func1<E12, T12> map12) {
+			return new Tuple13<>(map0.apply(this.element0), map1.apply(this.element1), map2.apply(this.element2), map3.apply(this.element3), map4.apply(this.element4), map5.apply(this.element5), map6.apply(this.element6), map7.apply(this.element7), map8.apply(this.element8), map9.apply(this.element9), map10.apply(this.element10), map11.apply(this.element11), map12.apply(this.element12));
+		}
+
+		public Tuple13<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> join(Tuple0 other) {
+			return new Tuple13<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, this.element9, this.element10, this.element11, this.element12);
+		}
+
+		public <E0> Tuple14<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, E0> join(Tuple1<E0> other) {
+			return new Tuple14<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, this.element9, this.element10, this.element11, this.element12, other.element0);
+		}
+	}
+
+	@FunctionalInterface
+	interface Func13<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> {
+		R apply(T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12);
+	}
+
+	record Tuple14<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(T0 element0, T1 element1, T2 element2,
+	                                                                           T3 element3, T4 element4, T5 element5,
+	                                                                           T6 element6, T7 element7, T8 element8,
+	                                                                           T9 element9, T10 element10,
+	                                                                           T11 element11, T12 element12,
+	                                                                           T13 element13) {
+		public <R> R applyTo(Func14<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> func) {
+			return func.apply(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, this.element9, this.element10, this.element11, this.element12, this.element13);
+		}
+
+		public static <R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Result<Tuple14<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, R> collect(Tuple14<Result<T0, R>, Result<T1, R>, Result<T2, R>, Result<T3, R>, Result<T4, R>, Result<T5, R>, Result<T6, R>, Result<T7, R>, Result<T8, R>, Result<T9, R>, Result<T10, R>, Result<T11, R>, Result<T12, R>, Result<T13, R>> tuple) {
+			return
+					tuple.element0.flatMap(element0 ->
+							                       tuple.element1.flatMap(element1 ->
+									                                              tuple.element2.flatMap(element2 ->
+											                                                                     tuple.element3.flatMap(element3 ->
+													                                                                                            tuple.element4.flatMap(element4 ->
+															                                                                                                                   tuple.element5.flatMap(element5 ->
+																	                                                                                                                                          tuple.element6.flatMap(element6 ->
+																			                                                                                                                                                                 tuple.element7.flatMap(element7 ->
+																					                                                                                                                                                                                        tuple.element8.flatMap(element8 ->
+																							                                                                                                                                                                                                               tuple.element9.flatMap(element9 ->
+																									                                                                                                                                                                                                                                      tuple.element10.flatMap(element10 ->
+																											                                                                                                                                                                                                                                                              tuple.element11.flatMap(element11 ->
+																													                                                                                                                                                                                                                                                                                      tuple.element12.flatMap(element12 ->
+																															                                                                                                                                                                                                                                                                                                              tuple.element13.flatMap(element13 ->
+																																	                                                                                                                                                                                                                                                                                                                                      Result.ok(new Tuple14<>(element0, element1, element2, element3, element4, element5, element6, element7, element8, element9, element10, element11, element12, element13))
+																															                                                                                                                                                                                                                                                                                                              )
+																													                                                                                                                                                                                                                                                                                      )
+																											                                                                                                                                                                                                                                                              )
+																									                                                                                                                                                                                                                                      )
+																							                                                                                                                                                                                                               )
+																					                                                                                                                                                                                        )
+																			                                                                                                                                                                 )
+																	                                                                                                                                          )
+															                                                                                                                   )
+													                                                                                            )
+											                                                                     )
+									                                              )
+							                       )
+					)
+					;
+		}
+
+		public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11, E12, E13> Tuple14<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11, E12, E13> map(Func1<E0, T0> map0, Func1<E1, T1> map1, Func1<E2, T2> map2, Func1<E3, T3> map3, Func1<E4, T4> map4, Func1<E5, T5> map5, Func1<E6, T6> map6, Func1<E7, T7> map7, Func1<E8, T8> map8, Func1<E9, T9> map9, Func1<E10, T10> map10, Func1<E11, T11> map11, Func1<E12, T12> map12, Func1<E13, T13> map13) {
+			return new Tuple14<>(map0.apply(this.element0), map1.apply(this.element1), map2.apply(this.element2), map3.apply(this.element3), map4.apply(this.element4), map5.apply(this.element5), map6.apply(this.element6), map7.apply(this.element7), map8.apply(this.element8), map9.apply(this.element9), map10.apply(this.element10), map11.apply(this.element11), map12.apply(this.element12), map13.apply(this.element13));
+		}
+
+		public Tuple14<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> join(Tuple0 other) {
+			return new Tuple14<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, this.element9, this.element10, this.element11, this.element12, this.element13);
+		}
+	}
+
+	@FunctionalInterface
+	interface Func14<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> {
+		R apply(T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13);
+	}
 }
diff --git a/src/main/java/moe/nea/pcj/json/AtField.java b/src/main/java/moe/nea/pcj/json/AtField.java
new file mode 100644
index 0000000..3780e38
--- /dev/null
+++ b/src/main/java/moe/nea/pcj/json/AtField.java
@@ -0,0 +1,4 @@
+package moe.nea.pcj.json;
+
+public record AtField(String field, JsonLikeError error) implements JsonLikeError {
+}
diff --git a/src/main/java/moe/nea/pcj/json/BasicCodecs.java b/src/main/java/moe/nea/pcj/json/BasicCodecs.java
new file mode 100644
index 0000000..8f957f9
--- /dev/null
+++ b/src/main/java/moe/nea/pcj/json/BasicCodecs.java
@@ -0,0 +1,51 @@
+package moe.nea.pcj.json;
+
+import moe.nea.pcj.Result;
+
+public class BasicCodecs<Format> {
+	protected BasicCodecs() {}
+
+	public static <Format> BasicCodecs<Format> create() {
+		return new BasicCodecs<>();
+	}
+
+	public final JsonCodec<String, Format> STRING = new JsonCodec<>() {
+		@Override
+		public Result<String, ? extends JsonLikeError> decode(Format format, JsonLikeOperations<Format> ops) {
+			return ops.getString(format);
+		}
+
+		@Override
+		public Result<Format, ? extends JsonLikeError> encode(String data, JsonLikeOperations<Format> ops) {
+			return Result.ok(ops.createString(data));
+		}
+	};
+
+	public final JsonCodec<Float, Format> FLOAT = new JsonCodec<Float, Format>() {
+		@Override
+		public Result<? extends Float, ? extends JsonLikeError> decode(Format format, JsonLikeOperations<Format> ops) {
+			return ops.getNumeric(format).map(Number::floatValue);
+		}
+
+		@Override
+		public Result<? extends Format, ? extends JsonLikeError> encode(Float data, JsonLikeOperations<Format> ops) {
+			return Result.ok(ops.createNumeric(data));
+		}
+	};
+
+	public final JsonCodec<Integer, Format> INTEGER = new JsonCodec<>() {
+		@Override
+		public Result<? extends Integer, ? extends JsonLikeError> decode(Format format, JsonLikeOperations<Format> ops) {
+			return ops.getNumeric(format).map(Number::intValue); // TODO: filter for valid ints
+		}
+
+		@Override
+		public Result<? extends Format, ? extends JsonLikeError> encode(Integer data, JsonLikeOperations<Format> ops) {
+			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/DuplicateJsonKey.java b/src/main/java/moe/nea/pcj/json/DuplicateJsonKey.java
new file mode 100644
index 0000000..13d81db
--- /dev/null
+++ b/src/main/java/moe/nea/pcj/json/DuplicateJsonKey.java
@@ -0,0 +1,4 @@
+package moe.nea.pcj.json;
+
+public record DuplicateJsonKey(String key) implements JsonLikeError {
+}
diff --git a/src/main/java/moe/nea/pcj/json/JsonCodec.java b/src/main/java/moe/nea/pcj/json/JsonCodec.java
new file mode 100644
index 0000000..65f4a5e
--- /dev/null
+++ b/src/main/java/moe/nea/pcj/json/JsonCodec.java
@@ -0,0 +1,31 @@
+package moe.nea.pcj.json;
+
+import moe.nea.pcj.Codec;
+import moe.nea.pcj.Result;
+
+public interface JsonCodec<T, Format> extends Codec<
+		T, Format, JsonLikeOperations<Format>,
+		JsonLikeError, JsonLikeError> {
+
+	default MapCodec<T, Format> fieldOf(String key) {
+		return new MapCodec<>() {
+			@Override
+			public Result<T, JsonLikeError> decode(RecordView<Format> record, JsonLikeOperations<Format> ops) {
+				return record.get(key)
+				             .map(element -> Result.<T, JsonLikeError>cast(
+						             JsonCodec.this.decode(element, ops)
+						                           .mapError(it -> new AtField(key, it))))
+				             .orElseGet(() -> Result.fail(new MissingKey(key)));
+			}
+
+			@Override
+			public Result<RecordBuilder<Format>, JsonLikeError> encode(T value, JsonLikeOperations<Format> ops) {
+				var record = ops.createObject();
+				return Result.<Format, JsonLikeError>cast(JsonCodec.this.encode(value, ops))
+				             .<JsonLikeError>mapError(it -> new AtField(key, it))
+				             .flatMap(json -> Result.cast(record.add(key, json).map(unit -> record)));
+			}
+
+		};
+	}
+}
diff --git a/src/main/java/moe/nea/pcj/json/JsonLikeError.java b/src/main/java/moe/nea/pcj/json/JsonLikeError.java
new file mode 100644
index 0000000..609bd84
--- /dev/null
+++ b/src/main/java/moe/nea/pcj/json/JsonLikeError.java
@@ -0,0 +1,4 @@
+package moe.nea.pcj.json;
+
+public interface JsonLikeError {
+}
diff --git a/src/main/java/moe/nea/pcj/JsonLikeOperations.java b/src/main/java/moe/nea/pcj/json/JsonLikeOperations.java
index 2188568..7bb0162 100644
--- a/src/main/java/moe/nea/pcj/JsonLikeOperations.java
+++ b/src/main/java/moe/nea/pcj/json/JsonLikeOperations.java
@@ -1,4 +1,8 @@
-package moe.nea.pcj;
+package moe.nea.pcj.json;
+
+import moe.nea.pcj.Operation;
+import moe.nea.pcj.Result;
+import moe.nea.pcj.Unit;
 
 public interface JsonLikeOperations<Format> extends Operation<Format> {
 
@@ -8,7 +12,7 @@ public interface JsonLikeOperations<Format> extends Operation<Format> {
 
 	Format createNumeric(Number value);
 
-	Result<Number, ? extends JsonLikeError> getInt(Format element);
+	Result<Number, ? extends JsonLikeError> getNumeric(Format element);
 
 	Format createString(String value);
 
@@ -18,11 +22,11 @@ public interface JsonLikeOperations<Format> extends Operation<Format> {
 
 	Result<Boolean, ? extends JsonLikeError> getBoolean(Format format);
 
-	RecordBuilder<? extends Format, Format> createObject();
+	RecordBuilder<Format> createObject();
 
-	Result<RecordView<? extends Format>, ? extends JsonLikeError> getObject(Format format);
+	Result<? extends RecordView<Format>, ? extends JsonLikeError> getObject(Format format);
 
-	ListBuilder<? extends Format, Format> createList();
+	ListBuilder<Format, Format> createList();
 
-	Result<ListView<? extends Format>, ? extends JsonLikeError> getList(Format format);
+	Result<? extends ListView<Format>, ? extends JsonLikeError> getList(Format format);
 }
diff --git a/src/main/java/moe/nea/pcj/ListBuilder.java b/src/main/java/moe/nea/pcj/json/ListBuilder.java
index 9f6e9a3..c6e9220 100644
--- a/src/main/java/moe/nea/pcj/ListBuilder.java
+++ b/src/main/java/moe/nea/pcj/json/ListBuilder.java
@@ -1,4 +1,4 @@
-package moe.nea.pcj;
+package moe.nea.pcj.json;
 
 public interface ListBuilder<Format, ElementFormat> extends ListView<ElementFormat> {
 	Format complete();
diff --git a/src/main/java/moe/nea/pcj/ListView.java b/src/main/java/moe/nea/pcj/json/ListView.java
index 57c229a..dcc6e37 100644
--- a/src/main/java/moe/nea/pcj/ListView.java
+++ b/src/main/java/moe/nea/pcj/json/ListView.java
@@ -1,4 +1,4 @@
-package moe.nea.pcj;
+package moe.nea.pcj.json;
 
 import java.util.Optional;
 
diff --git a/src/main/java/moe/nea/pcj/json/MapCodec.java b/src/main/java/moe/nea/pcj/json/MapCodec.java
new file mode 100644
index 0000000..468e4cf
--- /dev/null
+++ b/src/main/java/moe/nea/pcj/json/MapCodec.java
@@ -0,0 +1,17 @@
+package moe.nea.pcj.json;
+
+import moe.nea.pcj.Result;
+
+import java.util.function.Function;
+
+public interface MapCodec<T, Format> {
+	Result<T, JsonLikeError> decode(
+			RecordView<Format> record,
+			JsonLikeOperations<Format> ops);
+
+	Result<RecordBuilder<Format>, JsonLikeError> encode(T value, JsonLikeOperations<Format> ops);
+
+	default <O> RecordCodec<O, T, Format> withGetter(Function<O, T> getter) {
+		return new RecordCodec<>(this, getter);
+	}
+}
diff --git a/src/main/java/moe/nea/pcj/json/MissingKey.java b/src/main/java/moe/nea/pcj/json/MissingKey.java
new file mode 100644
index 0000000..3dad05c
--- /dev/null
+++ b/src/main/java/moe/nea/pcj/json/MissingKey.java
@@ -0,0 +1,4 @@
+package moe.nea.pcj.json;
+
+public record MissingKey(String missingKey) implements JsonLikeError {
+}
diff --git a/src/main/java/moe/nea/pcj/json/RecordBuilder.java b/src/main/java/moe/nea/pcj/json/RecordBuilder.java
new file mode 100644
index 0000000..c610f27
--- /dev/null
+++ b/src/main/java/moe/nea/pcj/json/RecordBuilder.java
@@ -0,0 +1,12 @@
+package moe.nea.pcj.json;
+
+import moe.nea.pcj.Result;
+import moe.nea.pcj.Unit;
+
+public interface RecordBuilder<ElementFormat> extends RecordView<ElementFormat> {
+	Result<Unit, JsonLikeError> add(String key, ElementFormat value);
+
+	Result<RecordBuilder<ElementFormat>, JsonLikeError> mergeWith(RecordBuilder<ElementFormat> other);
+
+	ElementFormat complete();
+}
diff --git a/src/main/java/moe/nea/pcj/json/RecordCodec.java b/src/main/java/moe/nea/pcj/json/RecordCodec.java
new file mode 100644
index 0000000..7ba8815
--- /dev/null
+++ b/src/main/java/moe/nea/pcj/json/RecordCodec.java
@@ -0,0 +1,59 @@
+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) {
+		return codec().encode(getter().apply(data), ops);
+	}
+
+	private 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) {
+		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);
+	}
+
+	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/RecordView.java b/src/main/java/moe/nea/pcj/json/RecordView.java
index 84057ba..968a936 100644
--- a/src/main/java/moe/nea/pcj/RecordView.java
+++ b/src/main/java/moe/nea/pcj/json/RecordView.java
@@ -1,10 +1,10 @@
-package moe.nea.pcj;
+package moe.nea.pcj.json;
 
 import java.util.Collection;
 import java.util.Optional;
 
 public interface RecordView<Format> {
-	Collection<Format> getKeys();
+	Collection<String> getKeys();
 
 	Optional<Format> get(String key);
 }
diff --git a/src/main/java/moe/nea/pcj/json/UnexpectedJsonElement.java b/src/main/java/moe/nea/pcj/json/UnexpectedJsonElement.java
new file mode 100644
index 0000000..7bee7c1
--- /dev/null
+++ b/src/main/java/moe/nea/pcj/json/UnexpectedJsonElement.java
@@ -0,0 +1,7 @@
+package moe.nea.pcj.json;
+
+public record UnexpectedJsonElement(
+		String expectedType,
+		Object actualJsonObject
+) implements JsonLikeError {
+}
diff --git a/src/main/java/moe/nea/pcj/json/package-info.java b/src/main/java/moe/nea/pcj/json/package-info.java
new file mode 100644
index 0000000..a5aace0
--- /dev/null
+++ b/src/main/java/moe/nea/pcj/json/package-info.java
@@ -0,0 +1,4 @@
+@NullMarked
+package moe.nea.pcj.json;
+
+import org.jspecify.annotations.NullMarked;
\ No newline at end of file