chore: create subproject for core

29 files changed, 1910 insertions, 0 deletions

diff --git a/core/src/main/java/moe/nea/pcj/Codec.java b/core/src/main/java/moe/nea/pcj/Codec.java
new file mode 100644
index 0000000..121e05f
--- /dev/null
+++ b/core/src/main/java/moe/nea/pcj/Codec.java
@@ -0,0 +1,6 @@
+package moe.nea.pcj;
+
+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/core/src/main/java/moe/nea/pcj/Decode.java b/core/src/main/java/moe/nea/pcj/Decode.java
new file mode 100644
index 0000000..d10c98a
--- /dev/null
+++ b/core/src/main/java/moe/nea/pcj/Decode.java
@@ -0,0 +1,5 @@
+package moe.nea.pcj;
+
+public interface Decode<Typ, Format, Op extends Operation<Format>, Err> {
+	Result<? extends Typ, ? extends Err> decode(Format format, Op ops);
+}
diff --git a/core/src/main/java/moe/nea/pcj/Encode.java b/core/src/main/java/moe/nea/pcj/Encode.java
new file mode 100644
index 0000000..834ce66
--- /dev/null
+++ b/core/src/main/java/moe/nea/pcj/Encode.java
@@ -0,0 +1,5 @@
+package moe.nea.pcj;
+
+public interface Encode<Typ, Format, Op extends Operation<Format>, Err> {
+	Result<? extends Format, ? extends Err> encode(Typ data, Op ops);
+}
diff --git a/core/src/main/java/moe/nea/pcj/Operation.java b/core/src/main/java/moe/nea/pcj/Operation.java
new file mode 100644
index 0000000..90995ef
--- /dev/null
+++ b/core/src/main/java/moe/nea/pcj/Operation.java
@@ -0,0 +1,4 @@
+package moe.nea.pcj;
+
+public interface Operation<Format> {
+}
diff --git a/core/src/main/java/moe/nea/pcj/Result.java b/core/src/main/java/moe/nea/pcj/Result.java
new file mode 100644
index 0000000..a9c2494
--- /dev/null
+++ b/core/src/main/java/moe/nea/pcj/Result.java
@@ -0,0 +1,165 @@
+package moe.nea.pcj;
+
+import org.jspecify.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.function.Function;
+
+public sealed interface Result<Good, Bad> permits Result.Ok, Result.Fail {
+	default boolean isOk() {
+		return errors().isEmpty();
+	}
+
+	Optional<Good> value();
+
+	Optional<Good> partial();
+
+	default Optional<Good> valueOrPartial() {
+		return value().or(this::partial);
+	}
+
+	List<Bad> errors();
+
+	default <Next> Result<Next, Bad> map(Function<Good, Next> mapper) {
+		return flatMap(mapper.andThen(Result::ok));
+	}
+
+	<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());
+	}
+
+	<NextBad> Result<Good, NextBad> mapErrors(Function<List<Bad>, List<NextBad>> mapper);
+
+	default Result<Good, Bad> appendError(Bad error) {
+		return appendErrors(List.of(error));
+	}
+
+	Result<Good, Bad> appendErrors(List<Bad> error);
+
+	record Ok<Good, Bad>(Good okValue) implements Result<Good, Bad> {
+		@Override
+		public Result<Good, Bad> appendErrors(List<Bad> errors) {
+			if (errors.isEmpty()) return new Ok<>(okValue);
+			return new Fail<>(okValue, errors);
+		}
+
+		@Override
+		public <NextBad> Result<Good, NextBad> mapErrors(Function<List<Bad>, List<NextBad>> mapper) {
+			return new Ok<>(okValue);
+		}
+
+		@Override
+		public Optional<Good> partial() {
+			return Optional.empty();
+		}
+
+		@Override
+		public List<Bad> errors() {
+			return List.of();
+		}
+
+		@Override
+		public <Next> Result<Next, Bad> flatMap(Function<Good, Result<? extends Next, ? extends Bad>> mapper) {
+			return Result.cast(mapper.apply(okValue));
+		}
+
+		@Override
+		public Optional<Good> value() {
+			return Optional.of(okValue);
+		}
+
+		@Override
+		public int hashCode() {
+			return Objects.hash(okValue);
+		}
+
+		@Override
+		public boolean equals(Object obj) {
+			if (obj == this) return true;
+			if (obj instanceof Result.Ok<?, ?> ok) {
+				return Objects.equals(ok.okValue, this.okValue);
+			}
+			return false;
+		}
+	}
+
+	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 boolean equals(Object obj) {
+			if (this == obj) return true;
+			if (obj instanceof Result.Fail<?, ?> fail) {
+				return Objects.equals(partialValue, fail.partialValue) && badValue.equals(fail.badValue);
+			}
+			return false;
+		}
+
+		@Override
+		public int hashCode() {
+			return Objects.hash(partialValue, badValue);
+		}
+
+		@Override
+		public Optional<Good> value() {
+			return Optional.empty();
+		}
+
+		@Override
+		public Optional<Good> partial() {
+			return Optional.ofNullable(partialValue);
+		}
+
+		@Override
+		public List<Bad> errors() {
+			return Collections.unmodifiableList(badValue);
+		}
+
+		@Override
+		public <Next> Result<Next, Bad> flatMap(Function<Good, Result<? extends Next, ? extends Bad>> mapper) {
+			if (partialValue != null) {
+				return Result.<Next, Bad>cast(mapper.apply(partialValue)).appendErrors(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> appendErrors(List<Bad> errors) {
+			var nextErrors = new ArrayList<>(badValue);
+			nextErrors.addAll(errors);
+			return new Fail<>(partialValue, nextErrors);
+		}
+	}
+
+	static <Good, Bad> Result<Good, Bad> ok(Good value) {
+		return new Ok<>(value);
+	}
+
+	static <Good, Bad> Result.Fail<Good, Bad> fail(Bad 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, List.of(error));
+	}
+}
diff --git a/core/src/main/java/moe/nea/pcj/Tuple.java b/core/src/main/java/moe/nea/pcj/Tuple.java
new file mode 100644
index 0000000..e6207ff
--- /dev/null
+++ b/core/src/main/java/moe/nea/pcj/Tuple.java
@@ -0,0 +1,1030 @@
+// @generated by gentuples.ts
+package moe.nea.pcj;
+
+@SuppressWarnings("unused")
+public interface Tuple {
+	class Tuple0 implements Tuple {
+		public <R> R applyTo(Func0<R> func) {
+			return func.apply();
+		}
+
+		public static <R> Result<Tuple0, R> collect(Tuple0 tuple) {
+			return
+					Result.ok(new Tuple0())
+					;
+		}
+
+		public Tuple0 map() {
+			return new Tuple0();
+		}
+
+		public Tuple0 join(Tuple0 other) {
+			return new Tuple0();
+		}
+
+		public <E0> Tuple1<E0> join(Tuple1<E0> other) {
+			return new Tuple1<>(other.element0);
+		}
+
+		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