wip

23 files changed, 1289 insertions, 105 deletions

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);
+		}
+