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, 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/Unit.java b/src/main/java/moe/nea/pcj/Unit.java
deleted file mode 100644
index 435d763..0000000
--- a/src/main/java/moe/nea/pcj/Unit.java
+++ /dev/null
@@ -1,5 +0,0 @@
-package moe.nea.pcj;
-
-public enum Unit {
-	INSTANCE;
-}
diff --git a/src/main/java/moe/nea/pcj/json/AtField.java b/src/main/java/moe/nea/pcj/json/AtField.java
deleted file mode 100644
index 3780e38..0000000
--- a/src/main/java/moe/nea/pcj/json/AtField.java
+++ /dev/null
@@ -1,4 +0,0 @@
-package moe.nea.pcj.json;
-
-public record AtField(String field, JsonLikeError error) implements JsonLikeError {
-}
diff --git a/src/main/java/moe/nea/pcj/json/AtIndex.java b/src/main/java/moe/nea/pcj/json/AtIndex.java
deleted file mode 100644
index ec01112..0000000
--- a/src/main/java/moe/nea/pcj/json/AtIndex.java
+++ /dev/null
@@ -1,4 +0,0 @@
-package moe.nea.pcj.json;
-
-public record AtIndex(int index, 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
deleted file mode 100644
index 565711d..0000000
--- a/src/main/java/moe/nea/pcj/json/BasicCodecs.java
+++ /dev/null
@@ -1,47 +0,0 @@
-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));
-		}
-	};
-}
\ 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
deleted file mode 100644
index 13d81db..0000000
--- a/src/main/java/moe/nea/pcj/json/DuplicateJsonKey.java
+++ /dev/null
@@ -1,4 +0,0 @@
-package moe.nea.pcj.json;
-
-public record DuplicateJsonKey(String key) implements JsonLikeError {
-}
diff --git a/src/main/java/moe/nea/pcj/json/DuringKeyExtraction.java b/src/main/java/moe/nea/pcj/json/DuringKeyExtraction.java
deleted file mode 100644
index 859f98f..0000000
--- a/src/main/java/moe/nea/pcj/json/DuringKeyExtraction.java
+++ /dev/null
@@ -1,4 +0,0 @@
-package moe.nea.pcj.json;
-
-public record DuringKeyExtraction(JsonLikeError error) implements JsonLikeError {
-}
diff --git a/src/main/java/moe/nea/pcj/json/InSubType.java b/src/main/java/moe/nea/pcj/json/InSubType.java
deleted file mode 100644
index ae62a73..0000000
--- a/src/main/java/moe/nea/pcj/json/InSubType.java
+++ /dev/null
@@ -1,4 +0,0 @@
-package moe.nea.pcj.json;
-
-public record InSubType<T>(T typeTag, JsonLikeError error) implements JsonLikeError {
-}
diff --git a/src/main/java/moe/nea/pcj/json/JsonCodec.java b/src/main/java/moe/nea/pcj/json/JsonCodec.java
deleted file mode 100644
index c5c750b..0000000
--- a/src/main/java/moe/nea/pcj/json/JsonCodec.java
+++ /dev/null
@@ -1,84 +0,0 @@
-package moe.nea.pcj.json;
-
-import moe.nea.pcj.Codec;
-import moe.nea.pcj.Result;
-
-import java.util.ArrayList;
-import java.util.List;
-
-public interface JsonCodec<T, Format> extends Codec<
-		T, Format, JsonLikeOperations<Format>,
-		JsonLikeError, JsonLikeError> {
-
-	default JsonCodec<List<T>, Format> listOf() {
-		return new JsonCodec<>() {
-			@Override
-			public Result<Format, JsonLikeError> encode(List<T> data, JsonLikeOperations<Format> ops) {
-				var list = ops.createList();
-				var erros = new ArrayList<JsonLikeError>();
-				for (int i = 0; i < data.size(); i++) {
-					var datum = data.get(i);
-					final var index = i;
-					var result = JsonCodec.this.encode(datum, ops)
-					                           .mapError(it -> new AtIndex(index, it));
-					erros.addAll(result.errors());
-					result.valueOrPartial().ifPresent(list::add);
-				}
-				return Result.<Format, JsonLikeError>ok(list.complete()).appendErrors(erros);
-			}
-
-			@Override
-			public Result<List<T>, JsonLikeError> decode(Format format, JsonLikeOperations<Format> ops) {
-				var view = Result.<ListView<Format>, JsonLikeError>cast(ops.getList(format));
-				return view.flatMap(elements -> {
-					var acc = new ArrayList<T>(elements.length());
-					var errors = new ArrayList<JsonLikeError>();
-					for (int i = 0; i < elements.length(); i++) {
-						final var index = i;
-						var result = JsonCodec.this.decode(elements.getUnsafe(i), ops)
-						                           .mapError(it -> new AtIndex(index, it));
-						errors.addAll(result.errors());
-						result.valueOrPartial().ifPresent(acc::add);
-					}
-					return Result.<List<T>, JsonLikeError>ok(acc).appendErrors(errors);
-				});
-			}
-		};
-	}
-
-	default JsonCodec<T, Format> named(String name) {
-		return new JsonCodec<>() {
-			@Override
-			public Result<? extends T, JsonLikeError> decode(Format format, JsonLikeOperations<Format> ops) {
-				return JsonCodec.this.decode(format, ops).mapError(it -> new NamedObject(name, it));
-			}
-
-			@Override
-			public Result<? extends Format, JsonLikeError> encode(T data, JsonLikeOperations<Format> ops) {
-				return JsonCodec.this.encode(data, ops).mapError(it -> new NamedObject(name, it));
-			}
-		};
-	}
-
-	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
deleted file mode 100644
index 609bd84..0000000
--- a/src/main/java/moe/nea/pcj/json/JsonLikeError.java
+++ /dev/null
@@ -1,4 +0,0 @@
-package moe.nea.pcj.json;
-
-public interface JsonLikeError {
-}
diff --git a/src/main/java/moe/nea/pcj/json/JsonLikeOperations.java b/src/main/java/moe/nea/pcj/json/JsonLikeOperations.java
deleted file mode 100644
index ffefeda..0000000
--- a/src/main/java/moe/nea/pcj/json/JsonLikeOperations.java
+++ /dev/null
@@ -1,32 +0,0 @@
-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> {
-
-	Format createNull(Unit value);
-
-	Result<Unit, ? extends JsonLikeError> getNull(Format element);
-
-	Format createNumeric(Number value);
-
-	Result<Number, ? extends JsonLikeError> getNumeric(Format element);
-
-	Format createString(String value);
-
-	Result<String, ? extends JsonLikeError> getString(Format element);
-
-	Format createBoolean(boolean value);
-
-	Result<Boolean, ? extends JsonLikeError> getBoolean(Format format);
-
-	RecordBuilder<Format> createObject();
-
-	Result<? extends RecordView<Format>, ? extends JsonLikeError> getObject(Format format);
-
-	ListBuilder<Format> createList();
-
-	Result<? extends ListView<Format>, ? extends JsonLikeError> getList(Format format);
-}
diff --git a/src/main/java/moe/nea/pcj/json/ListBuilder.java b/src/main/java/moe/nea/pcj/json/ListBuilder.java
deleted file mode 100644
index fd2a407..0000000
--- a/src/main/java/moe/nea/pcj/json/ListBuilder.java
+++ /dev/null
@@ -1,9 +0,0 @@
-package moe.nea.pcj.json;
-
-public interface ListBuilder<ElementFormat> extends ListView<ElementFormat> {
-	ElementFormat complete();
-
-	void add(ElementFormat value);
-
-	void set(int index, ElementFormat value);
-}
diff --git a/src/main/java/moe/nea/pcj/json/ListView.java b/src/main/java/moe/nea/pcj/json/ListView.java
deleted file mode 100644
index dcc6e37..0000000
--- a/src/main/java/moe/nea/pcj/json/ListView.java
+++ /dev/null
@@ -1,14 +0,0 @@
-package moe.nea.pcj.json;
-
-import java.util.Optional;
-
-public interface ListView<Format> {
-	int length();
-
-	default Optional<Format> getSafe(int index) {
-		if (index < 0 || index >= length()) return Optional.empty();
-		return Optional.of(getUnsafe(index));
-	}
-
-	Format getUnsafe(int index);
-}
diff --git a/src/main/java/moe/nea/pcj/json/MapCodec.java b/src/main/java/moe/nea/pcj/json/MapCodec.java
deleted file mode 100644
index 9f343fd..0000000
--- a/src/main/java/moe/nea/pcj/json/MapCodec.java
+++ /dev/null
@@ -1,64 +0,0 @@
-package moe.nea.pcj.json;
-
-import moe.nea.pcj.Result;
-
-import java.util.function.Function;
-
-public interface MapCodec<T, Format> {
-	Result<? extends T, JsonLikeError> decode(
-			RecordView<Format> record,
-			JsonLikeOperations<Format> ops);
-
-	Result<RecordBuilder<Format>, JsonLikeError> encode(T value, JsonLikeOperations<Format> ops);
-
-	default <O> MapCodec<? extends O, Format> dispatch(
-			Function<? super O, ? extends T> keyExtractor,
-			Function<? super T, Result<? extends MapCodec<? extends O, Format>, ? extends JsonLikeError>> codecGenerator
-	) {
-		// TODO: the codecGenerator function is not exactly typesafe. there should be some limit on keyExtractor and codecGenerator working in tandem
-		return new MapCodec<>() {
-			@Override
-			public Result<O, JsonLikeError> decode(RecordView<Format> record, JsonLikeOperations<Format> ops) { // TODO: map errors
-				return MapCodec.this.decode(record, ops)
-				                    .flatMap(key -> codecGenerator
-						                    .apply(key)
-						                    .<JsonLikeError>mapError(DuringKeyExtraction::new)
-						                    .flatMap(codec -> codec.decode(record, ops)
-						                                           .<JsonLikeError>mapError(it -> new InSubType<>(key, it))));
-			}
-
-			@Override
-			public Result<RecordBuilder<Format>, JsonLikeError> encode(O value, JsonLikeOperations<Format> ops) {
-				var key = keyExtractor.apply(value);
-				return Result.<MapCodec<? extends O, Format>, JsonLikeError>cast(
-						             codecGenerator.apply(key)
-						                           .mapError(DuringKeyExtraction::new))
-				             .flatMap(codec -> MapCodec.this
-						             .encode(key, ops)
-						             .flatMap(keyEncoded -> ((MapCodec<O, Format>) codec)
-								             .encode(value, ops)
-								             .<JsonLikeError>mapError(it -> new InSubType<>(key, it))
-								             .flatMap(keyEncoded::mergeWith)));
-			}
-		};
-	}
-
-	default JsonCodec<T, Format> codec() {
-		return new JsonCodec<>() {
-			@Override
-			public Result<? extends T, ? extends JsonLikeError> decode(Format format, JsonLikeOperations<Format> ops) {
-				return Result.<RecordView<Format>, JsonLikeError>cast(ops.getObject(format))
-				             .flatMap(record -> MapCodec.this.decode(record, ops));
-			}
-
-			@Override
-			public Result<? extends Format, ? extends JsonLikeError> encode(T data, JsonLikeOperations<Format> ops) {
-				return Result.cast(MapCodec.this.encode(data, ops)).map(RecordBuilder::complete);
-			}
-		};
-	}
-
-	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
deleted file mode 100644
index 3dad05c..0000000
--- a/src/main/java/moe/nea/pcj/json/MissingKey.java
+++ /dev/null
@@ -1,4 +0,0 @@
-package moe.nea.pcj.json;
-
-public record MissingKey(String missingKey) implements JsonLikeError {
-}
diff --git a/src/main/java/moe/nea/pcj/json/NamedObject.java b/src/main/java/moe/nea/pcj/json/NamedObject.java
deleted file mode 100644
index aedc87b..0000000
--- a/src/main/java/moe/nea/pcj/json/NamedObject.java
+++ /dev/null
@@ -1,4 +0,0 @@
-package moe.nea.pcj.json;
-
-public record NamedObject(String name, JsonLikeError error) implements JsonLikeError {
-}
diff --git a/src/main/java/moe/nea/pcj/json/RecordBuilder.java b/src/main/java/moe/nea/pcj/json/RecordBuilder.java
deleted file mode 100644
index c610f27..0000000
--- a/src/main/java/moe/nea/pcj/json/RecordBuilder.java
+++ /dev/null
@@ -1,12 +0,0 @@
-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
deleted file mode 100644
index fa7aac7..0000000
--- a/src/main/java/moe/nea/pcj/json/RecordCodec.java
+++ /dev/null
@@ -1,23 +0,0 @@
-package moe.nea.pcj.json;
-
-import moe.nea.pcj.Result;
-
-import java.util.function.Function;
-
-public record RecordCodec<O, T, Format>(
-		MapCodec<T, Format> codec,
-		Function<O, T> getter
-) {
-
-	Result<RecordBuilder<Format>, JsonLikeError> enc(O data, JsonLikeOperations<Format> ops) {
-		return codec().encode(getter().apply(data), ops);
-	}
-
-	Result<T, JsonLikeError> dec(RecordView<Format> data, JsonLikeOperations<Format> ops) {
-		return Result.cast(codec().decode(data, ops));
-	}
-
-	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));
-	}
-}
diff --git a/src/main/java/moe/nea/pcj/json/RecordJoiners.java b/src/main/java/moe/nea/pcj/json/RecordJoiners.java
deleted file mode 100644
index 57bdd63..0000000
--- a/src/main/java/moe/nea/pcj/json/RecordJoiners.java
+++ /dev/null
@@ -1,338 +0,0 @@
-// @generated by genrecord.ts
-package moe.nea.pcj.json;
-
-import moe.nea.pcj.*;
-import java.util.stream.*;
-
-@SuppressWarnings("unused")
-public class RecordJoiners {
-	public static <T0, O, Format> MapCodec<O, Format> join(
-			RecordCodec<O, T0, Format> arg0,
-			Tuple.Func1<O, T0> joiner
-	) {
-		return new MapCodec<>() {
-			@Override
-			public Result<RecordBuilder<Format>, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) {
-				return Stream.of(arg0.enc(data, ops))
-				             .reduce(Result.ok(ops.createObject()), RecordCodec::merge);
-			}
-			@Override
-			public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) {
-				return Tuple.Tuple1.collect(new Tuple.Tuple1<>(arg0.dec(format, ops)))
-				                   .map(it -> it.applyTo(joiner));
-			}
-		};
-	}
-	public static <T0, T1, O, Format> MapCodec<O, Format> join(
-			RecordCodec<O, T0, Format> arg0,
-			RecordCodec<O, T1, Format> arg1,
-			Tuple.Func2<O, T0, T1> joiner
-	) {
-		return new MapCodec<>() {
-			@Override
-			public Result<RecordBuilder<Format>, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) {
-				return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops))
-				             .reduce(Result.ok(ops.createObject()), RecordCodec::merge);
-			}
-			@Override
-			public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) {
-				return Tuple.Tuple2.collect(new Tuple.Tuple2<>(arg0.dec(format, ops), arg1.dec(format, ops)))
-				                   .map(it -> it.applyTo(joiner));
-			}
-		};
-	}
-	public static <T0, T1, T2, O, Format> MapCodec<O, Format> join(
-			RecordCodec<O, T0, Format> arg0,
-			RecordCodec<O, T1, Format> arg1,
-			RecordCodec<O, T2, Format> arg2,
-			Tuple.Func3<O, T0, T1, T2> joiner
-	) {
-		return new MapCodec<>() {
-			@Override
-			public Result<RecordBuilder<Format>, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) {
-				return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops), arg2.enc(data, ops))
-				             .reduce(Result.ok(ops.createObject()), RecordCodec::merge);
-			}
-			@Override
-			public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) {
-				return Tuple.Tuple3.collect(new Tuple.Tuple3<>(arg0.dec(format, ops), arg1.dec(format, ops), arg2.dec(format, ops)))
-				                   .map(it -> it.applyTo(joiner));
-			}
-		};
-	}
-	public static <T0, T1, T2, T3, O, Format> MapCodec<O, Format> join(
-			RecordCodec<O, T0, Format> arg0,
-			RecordCodec<O, T1, Format> arg1,
-			RecordCodec<O, T2, Format> arg2,
-			RecordCodec<O, T3, Format> arg3,
-			Tuple.Func4<O, T0, T1, T2, T3> joiner
-	) {
-		return new MapCodec<>() {
-			@Override
-			public Result<RecordBuilder<Format>, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) {
-				return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops), arg2.enc(data, ops), arg3.enc(data, ops))
-				             .reduce(Result.ok(ops.createObject()), RecordCodec::merge);
-			}
-			@Override
-			public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) {
-				return Tuple.Tuple4.collect(new Tuple.Tuple4<>(arg0.dec(format, ops), arg1.dec(format, ops), arg2.dec(format, ops), arg3.dec(format, ops)))
-				                   .map(it -> it.applyTo(joiner));
-			}
-		};
-	}
-	public static <T0, T1, T2, T3, T4, O, Format> MapCodec<O, Format> join(
-			RecordCodec<O, T0, Format> arg0,
-			RecordCodec<O, T1, Format> arg1,
-			RecordCodec<O, T2, Format> arg2,
-			RecordCodec<O, T3, Format> arg3,
-			RecordCodec<O, T4, Format> arg4,
-			Tuple.Func5<O, T0, T1, T2, T3, T4> joiner
-	) {
-		return new MapCodec<>() {
-			@Override
-			public Result<RecordBuilder<Format>, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) {
-				return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops), arg2.enc(data, ops), arg3.enc(data, ops), arg4.enc(data, ops))
-				             .reduce(Result.ok(ops.createObject()), RecordCodec::merge);
-			}
-			@Override
-			public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) {
-				return Tuple.Tuple5.collect(new Tuple.Tuple5<>(arg0.dec(format, ops), arg1.dec(format, ops), arg2.dec(format, ops), arg3.dec(format, ops), arg4.dec(format, ops)))
-				                   .map(it -> it.applyTo(joiner));
-			}
-		};
-	}
-	public static <T0, T1, T2, T3, T4, T5, O, Format> MapCodec<O, Format> join(
-			RecordCodec<O, T0, Format> arg0,
-			RecordCodec<O, T1, Format> arg1,
-			RecordCodec<O, T2, Format> arg2,
-			RecordCodec<O, T3, Format> arg3,
-			RecordCodec<O, T4, Format> arg4,
-			RecordCodec<O, T5, Format> arg5,
-			Tuple.Func6<O, T0, T1, T2, T3, T4, T5> joiner
-	) {
-		return new MapCodec<>() {
-			@Override
-			public Result<RecordBuilder<Format>, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) {
-				return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops), arg2.enc(data, ops), arg3.enc(data, ops), arg4.enc(data, ops), arg5.enc(data, ops))
-				             .reduce(Result.ok(ops.createObject()), RecordCodec::merge);
-			}
-			@Override
-			public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) {
-				return Tuple.Tuple6.collect(new Tuple.Tuple6<>(arg0.dec(format, ops), arg1.dec(format, ops), arg2.dec(format, ops), arg3.dec(format, ops), arg4.dec(format, ops), arg5.dec(format, ops)))
-				                   .map(it -> it.applyTo(joiner));
-			}
-		};
-	}
-	public static <T0, T1, T2, T3, T4, T5, T6, O, Format> MapCodec<O, Format> join(
-			RecordCodec<O, T0, Format> arg0,
-			RecordCodec<O, T1, Format> arg1,
-			RecordCodec<O, T2, Format> arg2,
-			RecordCodec<O, T3, Format> arg3,
-			RecordCodec<O, T4, Format> arg4,
-			RecordCodec<O, T5, Format> arg5,
-			RecordCodec<O, T6, Format> arg6,
-			Tuple.Func7<O, T0, T1, T2, T3, T4, T5, T6> joiner
-	) {
-		return new MapCodec<>() {
-			@Override
-			public Result<RecordBuilder<Format>, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) {
-				return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops), arg2.enc(data, ops), arg3.enc(data, ops), arg4.enc(data, ops), arg5.enc(data, ops), arg6.enc(data, ops))
-				             .reduce(Result.ok(ops.createObject()), RecordCodec::merge);
-			}
-			@Override
-			public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) {
-				return Tuple.Tuple7.collect(new Tuple.Tuple7<>(arg0.dec(format, ops), arg1.dec(format, ops), arg2.dec(format, ops), arg3.dec(format, ops), arg4.dec(format, ops), arg5.dec(format, ops), arg6.dec(format, ops)))
-				                   .map(it -> it.applyTo(joiner));
-			}
-		};
-	}
-	public static <T0, T1, T2, T3, T4, T5, T6, T7, O, Format> MapCodec<O, Format> join(
-			RecordCodec<O, T0, Format> arg0,
-			RecordCodec<O, T1, Format> arg1,
-			RecordCodec<O, T2, Format> arg2,
-			RecordCodec<O, T3, Format> arg3,
-			RecordCodec<O, T4, Format> arg4,
-			RecordCodec<O, T5, Format> arg5,
-			RecordCodec<O, T6, Format> arg6,
-			RecordCodec<O, T7, Format> arg7,
-			Tuple.Func8<O, T0, T1, T2, T3, T4, T5, T6, T7> joiner
-	) {
-		return new MapCodec<>() {
-			@Override
-			public Result<RecordBuilder<Format>, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) {
-				return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops), arg2.enc(data, ops), arg3.enc(data, ops), arg4.enc(data, ops), arg5.enc(data, ops), arg6.enc(data, ops), arg7.enc(data, ops))
-				             .reduce(Result.ok(ops.createObject()), RecordCodec::merge);
-			}
-			@Override
-			public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) {
-				return Tuple.Tuple8.collect(new Tuple.Tuple8<>(arg0.dec(format, ops), arg1.dec(format, ops), arg2.dec(format, ops), arg3.dec(format, ops), arg4.dec(format, ops), arg5.dec(format, ops), arg6.dec(format, ops), arg7.dec(format, ops)))
-				                   .map(it -> it.applyTo(joiner));
-			}
-		};
-	}
-	public static <T0, T1, T2, T3, T4, T5, T6, T7, T8, O, Format> MapCodec<O, Format> join(
-			RecordCodec<O, T0, Format> arg0,
-			RecordCodec<O, T1, Format> arg1,
-			RecordCodec<O, T2, Format> arg2,
-			RecordCodec<O, T3, Format> arg3,
-			RecordCodec<O, T4, Format> arg4,
-			RecordCodec<O, T5, Format> arg5,
-			RecordCodec<O, T6, Format> arg6,
-			RecordCodec<O, T7, Format> arg7,
-			RecordCodec<O, T8, Format> arg8,
-			Tuple.Func9<O, T0, T1, T2, T3, T4, T5, T6, T7, T8> joiner
-	) {
-		return new MapCodec<>() {
-			@Override
-			public Result<RecordBuilder<Format>, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) {
-				return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops), arg2.enc(data, ops), arg3.enc(data, ops), arg4.enc(data, ops), arg5.enc(data, ops), arg6.enc(data, ops), arg7.enc(data, ops), arg8.enc(data, ops))
-				             .reduce(Result.ok(ops.createObject()), RecordCodec::merge);
-			}
-			@Override
-			public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) {
-				return Tuple.Tuple9.collect(new Tuple.Tuple9<>(arg0.dec(format, ops), arg1.dec(format, ops), arg2.dec(format, ops), arg3.dec(format, ops), arg4.dec(format, ops), arg5.dec(format, ops), arg6.dec(format, ops), arg7.dec(format, ops), arg8.dec(format, ops)))
-				                   .map(it -> it.applyTo(joiner));
-			}
-		};
-	}
-	public static <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, O, Format> MapCodec<O, Format> join(
-			RecordCodec<O, T0, Format> arg0,
-			RecordCodec<O, T1, Format> arg1,
-			RecordCodec<O, T2, Format> arg2,
-			RecordCodec<O, T3, Format> arg3,
-			RecordCodec<O, T4, Format> arg4,
-			RecordCodec<O, T5, Format> arg5,
-			RecordCodec<O, T6, Format> arg6,
-			RecordCodec<O, T7, Format> arg7,
-			RecordCodec<O, T8, Format> arg8,
-			RecordCodec<O, T9, Format> arg9,
-			Tuple.Func10<O, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> joiner
-	) {
-		return new MapCodec<>() {
-			@Override
-			public Result<RecordBuilder<Format>, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) {
-				return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops), arg2.enc(data, ops), arg3.enc(data, ops), arg4.enc(data, ops), arg5.enc(data, ops), arg6.enc(data, ops), arg7.enc(data, ops), arg8.enc(data, ops), arg9.enc(data, ops))
-				             .reduce(Result.ok(ops.createObject()), RecordCodec::merge);
-			}
-			@Override
-			public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) {
-				return Tuple.Tuple10.collect(new Tuple.Tuple10<>(arg0.dec(format, ops), arg1.dec(format, ops), arg2.dec(format, ops), arg3.dec(format, ops), arg4.dec(format, ops), arg5.dec(format, ops), arg6.dec(format, ops), arg7.dec(format, ops), arg8.dec(format, ops), arg9.dec(format, ops)))
-				                    .map(it -> it.applyTo(joiner));
-			}
-		};
-	}
-	public static <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, O, Format> MapCodec<O, Format> join(
-			RecordCodec<O, T0, Format> arg0,
-			RecordCodec<O, T1, Format> arg1,
-			RecordCodec<O, T2, Format> arg2,
-			RecordCodec<O, T3, Format> arg3,
-			RecordCodec<O, T4, Format> arg4,
-			RecordCodec<O, T5, Format> arg5,
-			RecordCodec<O, T6, Format> arg6,
-			RecordCodec<O, T7, Format> arg7,
-			RecordCodec<O, T8, Format> arg8,
-			RecordCodec<O, T9, Format> arg9,
-			RecordCodec<O, T10, Format> arg10,
-			Tuple.Func11<O, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> joiner
-	) {
-		return new MapCodec<>() {
-			@Override
-			public Result<RecordBuilder<Format>, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) {
-				return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops), arg2.enc(data, ops), arg3.enc(data, ops), arg4.enc(data, ops), arg5.enc(data, ops), arg6.enc(data, ops), arg7.enc(data, ops), arg8.enc(data, ops), arg9.enc(data, ops), arg10.enc(data, ops))
-				             .reduce(Result.ok(ops.createObject()), RecordCodec::merge);
-			}
-			@Override
-			public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) {
-				return Tuple.Tuple11.collect(new Tuple.Tuple11<>(arg0.dec(format, ops), arg1.dec(format, ops), arg2.dec(format, ops), arg3.dec(format, ops), arg4.dec(format, ops), arg5.dec(format, ops), arg6.dec(format, ops), arg7.dec(format, ops), arg8.dec(format, ops), arg9.dec(format, ops), arg10.dec(format, ops)))
-				                    .map(it -> it.applyTo(joiner));
-			}
-		};
-	}
-	public static <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, O, Format> MapCodec<O, Format> join(
-			RecordCodec<O, T0, Format> arg0,
-			RecordCodec<O, T1, Format> arg1,
-			RecordCodec<O, T2, Format> arg2,
-			RecordCodec<O, T3, Format> arg3,
-			RecordCodec<O, T4, Format> arg4,
-			RecordCodec<O, T5, Format> arg5,
-			RecordCodec<O, T6, Format> arg6,
-			RecordCodec<O, T7, Format> arg7,
-			RecordCodec<O, T8, Format> arg8,
-			RecordCodec<O, T9, Format> arg9,
-			RecordCodec<O, T10, Format> arg10,
-			RecordCodec<O, T11, Format> arg11,
-			Tuple.Func12<O, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> joiner
-	) {
-		return new MapCodec<>() {
-			@Override
-			public Result<RecordBuilder<Format>, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) {
-				return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops), arg2.enc(data, ops), arg3.enc(data, ops), arg4.enc(data, ops), arg5.enc(data, ops), arg6.enc(data, ops), arg7.enc(data, ops), arg8.enc(data, ops), arg9.enc(data, ops), arg10.enc(data, ops), arg11.enc(data, ops))
-				             .reduce(Result.ok(ops.createObject()), RecordCodec::merge);
-			}
-			@Override
-			public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) {
-				return Tuple.Tuple12.collect(new Tuple.Tuple12<>(arg0.dec(format, ops), arg1.dec(format, ops), arg2.dec(format, ops), arg3.dec(format, ops), arg4.dec(format, ops), arg5.dec(format, ops), arg6.dec(format, ops), arg7.dec(format, ops), arg8.dec(format, ops), arg9.dec(format, ops), arg10.dec(format, ops), arg11.dec(format, ops)))
-				                    .map(it -> it.applyTo(joiner));
-			}
-		};
-	}
-	public static <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, O, Format> MapCodec<O, Format> join(
-			RecordCodec<O, T0, Format> arg0,
-			RecordCodec<O, T1, Format> arg1,
-			RecordCodec<O, T2, Format> arg2,
-			RecordCodec<O, T3, Format> arg3,
-			RecordCodec<O, T4, Format> arg4,
-			RecordCodec<O, T5, Format> arg5,
-			RecordCodec<O, T6, Format> arg6,
-			RecordCodec<O, T7, Format> arg7,
-			RecordCodec<O, T8, Format> arg8,
-			RecordCodec<O, T9, Format> arg9,
-			RecordCodec<O, T10, Format> arg10,
-			RecordCodec<O, T11, Format> arg11,
-			RecordCodec<O, T12, Format> arg12,
-			Tuple.Func13<O, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> joiner
-	) {
-		return new MapCodec<>() {
-			@Override
-			public Result<RecordBuilder<Format>, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) {
-				return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops), arg2.enc(data, ops), arg3.enc(data, ops), arg4.enc(data, ops), arg5.enc(data, ops), arg6.enc(data, ops), arg7.enc(data, ops), arg8.enc(data, ops), arg9.enc(data, ops), arg10.enc(data, ops), arg11.enc(data, ops), arg12.enc(data, ops))
-				             .reduce(Result.ok(ops.createObject()), RecordCodec::merge);
-			}
-			@Override
-			public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) {
-				return Tuple.Tuple13.collect(new Tuple.Tuple13<>(arg0.dec(format, ops), arg1.dec(format, ops), arg2.dec(format, ops), arg3.dec(format, ops), arg4.dec(format, ops), arg5.dec(format, ops), arg6.dec(format, ops), arg7.dec(format, ops), arg8.dec(format, ops), arg9.dec(format, ops), arg10.dec(format, ops), arg11.dec(format, ops), arg12.dec(format, ops)))
-				                    .map(it -> it.applyTo(joiner));
-			}
-		};
-	}
-	public static <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, O, Format> MapCodec<O, Format> join(
-			RecordCodec<O, T0, Format> arg0,
-			RecordCodec<O, T1, Format> arg1,
-			RecordCodec<O, T2, Format> arg2,
-			RecordCodec<O, T3, Format> arg3,
-			RecordCodec<O, T4, Format> arg4,
-			RecordCodec<O, T5, Format> arg5,
-			RecordCodec<O, T6, Format> arg6,
-			RecordCodec<O, T7, Format> arg7,
-			RecordCodec<O, T8, Format> arg8,
-			RecordCodec<O, T9, Format> arg9,
-			RecordCodec<O, T10, Format> arg10,
-			RecordCodec<O, T11, Format> arg11,
-			RecordCodec<O, T12, Format> arg12,
-			RecordCodec<O, T13, Format> arg13,
-			Tuple.Func14<O, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> joiner
-	) {
-		return new MapCodec<>() {
-			@Override
-			public Result<RecordBuilder<Format>, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) {
-				return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops), arg2.enc(data, ops), arg3.enc(data, ops), arg4.enc(data, ops), arg5.enc(data, ops), arg6.enc(data, ops), arg7.enc(data, ops), arg8.enc(data, ops), arg9.enc(data, ops), arg10.enc(data, ops), arg11.enc(data, ops), arg12.enc(data, ops), arg13.enc(data, ops))
-				             .reduce(Result.ok(ops.createObject()), RecordCodec::merge);
-			}
-			@Override
-			public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) {
-				return Tuple.Tuple14.collect(new Tuple.Tuple14<>(arg0.dec(format, ops), arg1.dec(format, ops), arg2.dec(format, ops), arg3.dec(format, ops), arg4.dec(format, ops), arg5.dec(format, ops), arg6.dec(format, ops), arg7.dec(format, ops), arg8.dec(format, ops), arg9.dec(format, ops), arg10.dec(format, ops), arg11.dec(format, ops), arg12.dec(format, ops), arg13.dec(format, ops)))
-				                    .map(it -> it.applyTo(joiner));
-			}
-		};
-	}
-}
diff --git a/src/main/java/moe/nea/pcj/json/RecordView.java b/src/main/java/moe/nea/pcj/json/RecordView.java
deleted file mode 100644
index 968a936..0000000
--- a/src/main/java/moe/nea/pcj/json/RecordView.java
+++ /dev/null
@@ -1,10 +0,0 @@
-package moe.nea.pcj.json;
-
-import java.util.Collection;
-import java.util.Optional;
-
-public interface RecordView<Format> {
-	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
deleted file mode 100644
index 7bee7c1..0000000
--- a/src/main/java/moe/nea/pcj/json/UnexpectedJsonElement.java
+++ /dev/null
@@ -1,7 +0,0 @@
-package moe.nea.pcj.json;
-
-public record UnexpectedJsonElement(
-		String expectedType,
-		Object actualJsonObject
-) implements JsonLikeError {
-}
diff --git a/src/main/java/moe/nea/pcj/json/UnknownSubtype.java b/src/main/java/moe/nea/pcj/json/UnknownSubtype.java
deleted file mode 100644
index 942a7dc..0000000
--- a/src/main/java/moe/nea/pcj/json/UnknownSubtype.java
+++ /dev/null
@@ -1,10 +0,0 @@
-package moe.nea.pcj.json;
-
-import java.util.Set;
-
-public record UnknownSubtype<T>(T actual, Set<T> expectedTypes) implements JsonLikeError {
-	@SafeVarargs
-	public UnknownSubtype(T actual, T... expected) {
-		this(actual, Set.of(expected));
-	}
-}
diff --git a/src/main/java/moe/nea/pcj/json/package-info.java b/src/main/java/moe/nea/pcj/json/package-info.java
deleted file mode 100644
index a5aace0..0000000
--- a/src/main/java/moe/nea/pcj/json/package-info.java
+++ /dev/null
@@ -1,4 +0,0 @@
-@NullMarked
-package moe.nea.pcj.json;
-
-import org.jspecify.annotations.NullMarked;
\ No newline at end of file
diff --git a/src/main/java/moe/nea/pcj/package-info.java b/src/main/java/moe/nea/pcj/package-info.java
deleted file mode 100644
index 8adfc56..0000000
--- a/src/main/java/moe/nea/pcj/package-info.java
+++ /dev/null
@@ -1,4 +0,0 @@
-@NullMarked
-package moe.nea.pcj;
-
-import org.jspecify.annotations.NullMarked;
\ No newline at end of file