chore: create subproject for core

29 files changed, 0 insertions, 1910 deletions

diff --git a/src/main/java/moe/nea/pcj/Codec.java b/src/main/java/moe/nea/pcj/Codec.java
deleted file mode 100644
index 121e05f..0000000
--- a/src/main/java/moe/nea/pcj/Codec.java
+++ /dev/null
@@ -1,6 +0,0 @@
-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/src/main/java/moe/nea/pcj/Decode.java b/src/main/java/moe/nea/pcj/Decode.java
deleted file mode 100644
index d10c98a..0000000
--- a/src/main/java/moe/nea/pcj/Decode.java
+++ /dev/null
@@ -1,5 +0,0 @@
-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/src/main/java/moe/nea/pcj/Encode.java b/src/main/java/moe/nea/pcj/Encode.java
deleted file mode 100644
index 834ce66..0000000
--- a/src/main/java/moe/nea/pcj/Encode.java
+++ /dev/null
@@ -1,5 +0,0 @@
-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/src/main/java/moe/nea/pcj/Operation.java b/src/main/java/moe/nea/pcj/Operation.java
deleted file mode 100644
index 90995ef..0000000
--- a/src/main/java/moe/nea/pcj/Operation.java
+++ /dev/null
@@ -1,4 +0,0 @@
-package moe.nea.pcj;
-
-public interface Operation<Format> {
-}
diff --git a/src/main/java/moe/nea/pcj/Result.java b/src/main/java/moe/nea/pcj/Result.java
deleted file mode 100644
index a9c2494..0000000
--- a/src/main/java/moe/nea/pcj/Result.java
+++ /dev/null
@@ -1,165 +0,0 @@
-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/src/main/java/moe/nea/pcj/Tuple.java b/src/main/java/moe/nea/pcj/Tuple.java
deleted file mode 100644
index e6207ff..0000000
--- a/src/main/java/moe/nea/pcj/Tuple.java
+++ /dev/null
@@ -1,1030 +0,0 @@
-// @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.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