From aad6ebad69685abd4b7711039d91d5c19dfbf61f Mon Sep 17 00:00:00 2001 From: Linnea Gräf Date: Sat, 16 Nov 2024 17:20:52 +0100 Subject: chore: create subproject for core --- core/src/main/java/moe/nea/pcj/Codec.java | 6 + core/src/main/java/moe/nea/pcj/Decode.java | 5 + core/src/main/java/moe/nea/pcj/Encode.java | 5 + core/src/main/java/moe/nea/pcj/Operation.java | 4 + core/src/main/java/moe/nea/pcj/Result.java | 165 ++++ core/src/main/java/moe/nea/pcj/Tuple.java | 1030 ++++++++++++++++++++ core/src/main/java/moe/nea/pcj/Unit.java | 5 + core/src/main/java/moe/nea/pcj/json/AtField.java | 4 + core/src/main/java/moe/nea/pcj/json/AtIndex.java | 4 + .../main/java/moe/nea/pcj/json/BasicCodecs.java | 47 + .../java/moe/nea/pcj/json/DuplicateJsonKey.java | 4 + .../java/moe/nea/pcj/json/DuringKeyExtraction.java | 4 + core/src/main/java/moe/nea/pcj/json/InSubType.java | 4 + core/src/main/java/moe/nea/pcj/json/JsonCodec.java | 84 ++ .../main/java/moe/nea/pcj/json/JsonLikeError.java | 4 + .../java/moe/nea/pcj/json/JsonLikeOperations.java | 32 + .../main/java/moe/nea/pcj/json/ListBuilder.java | 9 + core/src/main/java/moe/nea/pcj/json/ListView.java | 14 + core/src/main/java/moe/nea/pcj/json/MapCodec.java | 64 ++ .../src/main/java/moe/nea/pcj/json/MissingKey.java | 4 + .../main/java/moe/nea/pcj/json/NamedObject.java | 4 + .../main/java/moe/nea/pcj/json/RecordBuilder.java | 12 + .../main/java/moe/nea/pcj/json/RecordCodec.java | 23 + .../main/java/moe/nea/pcj/json/RecordJoiners.java | 338 +++++++ .../src/main/java/moe/nea/pcj/json/RecordView.java | 10 + .../moe/nea/pcj/json/UnexpectedJsonElement.java | 7 + .../main/java/moe/nea/pcj/json/UnknownSubtype.java | 10 + .../main/java/moe/nea/pcj/json/package-info.java | 4 + core/src/main/java/moe/nea/pcj/package-info.java | 4 + 29 files changed, 1910 insertions(+) create mode 100644 core/src/main/java/moe/nea/pcj/Codec.java create mode 100644 core/src/main/java/moe/nea/pcj/Decode.java create mode 100644 core/src/main/java/moe/nea/pcj/Encode.java create mode 100644 core/src/main/java/moe/nea/pcj/Operation.java create mode 100644 core/src/main/java/moe/nea/pcj/Result.java create mode 100644 core/src/main/java/moe/nea/pcj/Tuple.java create mode 100644 core/src/main/java/moe/nea/pcj/Unit.java create mode 100644 core/src/main/java/moe/nea/pcj/json/AtField.java create mode 100644 core/src/main/java/moe/nea/pcj/json/AtIndex.java create mode 100644 core/src/main/java/moe/nea/pcj/json/BasicCodecs.java create mode 100644 core/src/main/java/moe/nea/pcj/json/DuplicateJsonKey.java create mode 100644 core/src/main/java/moe/nea/pcj/json/DuringKeyExtraction.java create mode 100644 core/src/main/java/moe/nea/pcj/json/InSubType.java create mode 100644 core/src/main/java/moe/nea/pcj/json/JsonCodec.java create mode 100644 core/src/main/java/moe/nea/pcj/json/JsonLikeError.java create mode 100644 core/src/main/java/moe/nea/pcj/json/JsonLikeOperations.java create mode 100644 core/src/main/java/moe/nea/pcj/json/ListBuilder.java create mode 100644 core/src/main/java/moe/nea/pcj/json/ListView.java create mode 100644 core/src/main/java/moe/nea/pcj/json/MapCodec.java create mode 100644 core/src/main/java/moe/nea/pcj/json/MissingKey.java create mode 100644 core/src/main/java/moe/nea/pcj/json/NamedObject.java create mode 100644 core/src/main/java/moe/nea/pcj/json/RecordBuilder.java create mode 100644 core/src/main/java/moe/nea/pcj/json/RecordCodec.java create mode 100644 core/src/main/java/moe/nea/pcj/json/RecordJoiners.java create mode 100644 core/src/main/java/moe/nea/pcj/json/RecordView.java create mode 100644 core/src/main/java/moe/nea/pcj/json/UnexpectedJsonElement.java create mode 100644 core/src/main/java/moe/nea/pcj/json/UnknownSubtype.java create mode 100644 core/src/main/java/moe/nea/pcj/json/package-info.java create mode 100644 core/src/main/java/moe/nea/pcj/package-info.java (limited to 'core/src/main') diff --git a/core/src/main/java/moe/nea/pcj/Codec.java b/core/src/main/java/moe/nea/pcj/Codec.java new file mode 100644 index 0000000..121e05f --- /dev/null +++ b/core/src/main/java/moe/nea/pcj/Codec.java @@ -0,0 +1,6 @@ +package moe.nea.pcj; + +public interface Codec, DeErr, CoErr> + extends Decode, Encode { + +} diff --git a/core/src/main/java/moe/nea/pcj/Decode.java b/core/src/main/java/moe/nea/pcj/Decode.java new file mode 100644 index 0000000..d10c98a --- /dev/null +++ b/core/src/main/java/moe/nea/pcj/Decode.java @@ -0,0 +1,5 @@ +package moe.nea.pcj; + +public interface Decode, Err> { + Result decode(Format format, Op ops); +} diff --git a/core/src/main/java/moe/nea/pcj/Encode.java b/core/src/main/java/moe/nea/pcj/Encode.java new file mode 100644 index 0000000..834ce66 --- /dev/null +++ b/core/src/main/java/moe/nea/pcj/Encode.java @@ -0,0 +1,5 @@ +package moe.nea.pcj; + +public interface Encode, Err> { + Result encode(Typ data, Op ops); +} diff --git a/core/src/main/java/moe/nea/pcj/Operation.java b/core/src/main/java/moe/nea/pcj/Operation.java new file mode 100644 index 0000000..90995ef --- /dev/null +++ b/core/src/main/java/moe/nea/pcj/Operation.java @@ -0,0 +1,4 @@ +package moe.nea.pcj; + +public interface Operation { +} diff --git a/core/src/main/java/moe/nea/pcj/Result.java b/core/src/main/java/moe/nea/pcj/Result.java new file mode 100644 index 0000000..a9c2494 --- /dev/null +++ b/core/src/main/java/moe/nea/pcj/Result.java @@ -0,0 +1,165 @@ +package moe.nea.pcj; + +import org.jspecify.annotations.Nullable; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.Objects; +import java.util.Optional; +import java.util.function.Function; + +public sealed interface Result permits Result.Ok, Result.Fail { + default boolean isOk() { + return errors().isEmpty(); + } + + Optional value(); + + Optional partial(); + + default Optional valueOrPartial() { + return value().or(this::partial); + } + + List errors(); + + default Result map(Function mapper) { + return flatMap(mapper.andThen(Result::ok)); + } + + Result flatMap(Function> mapper); + + default Result mapError(Function mapper) { + return mapErrors(it -> it.stream().map(mapper).toList()); + } + + Result mapErrors(Function, List> mapper); + + default Result appendError(Bad error) { + return appendErrors(List.of(error)); + } + + Result appendErrors(List error); + + record Ok(Good okValue) implements Result { + @Override + public Result appendErrors(List errors) { + if (errors.isEmpty()) return new Ok<>(okValue); + return new Fail<>(okValue, errors); + } + + @Override + public Result mapErrors(Function, List> mapper) { + return new Ok<>(okValue); + } + + @Override + public Optional partial() { + return Optional.empty(); + } + + @Override + public List errors() { + return List.of(); + } + + @Override + public Result flatMap(Function> mapper) { + return Result.cast(mapper.apply(okValue)); + } + + @Override + public Optional 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(@Nullable Good partialValue, List badValue) implements Result { + 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 value() { + return Optional.empty(); + } + + @Override + public Optional partial() { + return Optional.ofNullable(partialValue); + } + + @Override + public List errors() { + return Collections.unmodifiableList(badValue); + } + + @Override + public Result flatMap(Function> mapper) { + if (partialValue != null) { + return Result.cast(mapper.apply(partialValue)).appendErrors(badValue); + } + return new Fail<>(null, badValue); + } + + @Override + public Result mapErrors(Function, List> mapper) { + return new Fail<>(partialValue, mapper.apply(badValue)); + } + + @Override + public Result appendErrors(List errors) { + var nextErrors = new ArrayList<>(badValue); + nextErrors.addAll(errors); + return new Fail<>(partialValue, nextErrors); + } + } + + static Result ok(Good value) { + return new Ok<>(value); + } + + static Result.Fail fail(Bad error) { + return new Fail<>(null, List.of(error)); + } + + + static Result cast(Result c) { + //noinspection unchecked + return (Result) c; + } + + static Result.Fail partial(@Nullable Good partial, Bad error) { + return new Fail<>(partial, List.of(error)); + } +} diff --git a/core/src/main/java/moe/nea/pcj/Tuple.java b/core/src/main/java/moe/nea/pcj/Tuple.java new file mode 100644 index 0000000..e6207ff --- /dev/null +++ b/core/src/main/java/moe/nea/pcj/Tuple.java @@ -0,0 +1,1030 @@ +// @generated by gentuples.ts +package moe.nea.pcj; + +@SuppressWarnings("unused") +public interface Tuple { + class Tuple0 implements Tuple { + public R applyTo(Func0 func) { + return func.apply(); + } + + public static Result collect(Tuple0 tuple) { + return + Result.ok(new Tuple0()) + ; + } + + public Tuple0 map() { + return new Tuple0(); + } + + public Tuple0 join(Tuple0 other) { + return new Tuple0(); + } + + public Tuple1 join(Tuple1 other) { + return new Tuple1<>(other.element0); + } + + public Tuple2 join(Tuple2 other) { + return new Tuple2<>(other.element0, other.element1); + } + + public Tuple3 join(Tuple3 other) { + return new Tuple3<>(other.element0, other.element1, other.element2); + } + + public Tuple4 join(Tuple4 other) { + return new Tuple4<>(other.element0, other.element1, other.element2, other.element3); + } + + public Tuple5 join(Tuple5 other) { + return new Tuple5<>(other.element0, other.element1, other.element2, other.element3, other.element4); + } + + public Tuple6 join(Tuple6 other) { + return new Tuple6<>(other.element0, other.element1, other.element2, other.element3, other.element4, other.element5); + } + + public Tuple7 join(Tuple7 other) { + return new Tuple7<>(other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6); + } + + public Tuple8 join(Tuple8 other) { + return new Tuple8<>(other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7); + } + + public Tuple9 join(Tuple9 other) { + return new Tuple9<>(other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8); + } + + public Tuple10 join(Tuple10 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 Tuple11 join(Tuple11 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 Tuple12 join(Tuple12 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 Tuple13 join(Tuple13 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 Tuple14 join(Tuple14 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 apply(); + } + + record Tuple1(T0 element0) { + public R applyTo(Func1 func) { + return func.apply(this.element0); + } + + public static Result, R> collect(Tuple1> tuple) { + return + tuple.element0.flatMap(element0 -> + Result.ok(new Tuple1<>(element0)) + ) + ; + } + + public Tuple1 map(Func1 map0) { + return new Tuple1<>(map0.apply(this.element0)); + } + + public Tuple1 join(Tuple0 other) { + return new Tuple1<>(this.element0); + } + + public Tuple2 join(Tuple1 other) { + return new Tuple2<>(this.element0, other.element0); + } + + public Tuple3 join(Tuple2 other) { + return new Tuple3<>(this.element0, other.element0, other.element1); + } + + public Tuple4 join(Tuple3 other) { + return new Tuple4<>(this.element0, other.element0, other.element1, other.element2); + } + + public Tuple5 join(Tuple4 other) { + return new Tuple5<>(this.element0, other.element0, other.element1, other.element2, other.element3); + } + + public Tuple6 join(Tuple5 other) { + return new Tuple6<>(this.element0, other.element0, other.element1, other.element2, other.element3, other.element4); + } + + public Tuple7 join(Tuple6 other) { + return new Tuple7<>(this.element0, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5); + } + + public Tuple8 join(Tuple7 other) { + return new Tuple8<>(this.element0, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6); + } + + public Tuple9 join(Tuple8 other) { + return new Tuple9<>(this.element0, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7); + } + + public Tuple10 join(Tuple9 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 Tuple11 join(Tuple10 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 Tuple12 join(Tuple11 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 Tuple13 join(Tuple12 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 Tuple14 join(Tuple13 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 apply(T0 arg0); + } + + record Tuple2(T0 element0, T1 element1) { + public R applyTo(Func2 func) { + return func.apply(this.element0, this.element1); + } + + public static Result, R> collect(Tuple2, Result> tuple) { + return + tuple.element0.flatMap(element0 -> + tuple.element1.flatMap(element1 -> + Result.ok(new Tuple2<>(element0, element1)) + ) + ) + ; + } + + public Tuple2 map(Func1 map0, Func1 map1) { + return new Tuple2<>(map0.apply(this.element0), map1.apply(this.element1)); + } + + public Tuple2 join(Tuple0 other) { + return new Tuple2<>(this.element0, this.element1); + } + + public Tuple3 join(Tuple1 other) { + return new Tuple3<>(this.element0, this.element1, other.element0); + } + + public Tuple4 join(Tuple2 other) { + return new Tuple4<>(this.element0, this.element1, other.element0, other.element1); + } + + public Tuple5 join(Tuple3 other) { + return new Tuple5<>(this.element0, this.element1, other.element0, other.element1, other.element2); + } + + public Tuple6 join(Tuple4 other) { + return new Tuple6<>(this.element0, this.element1, other.element0, other.element1, other.element2, other.element3); + } + + public Tuple7 join(Tuple5 other) { + return new Tuple7<>(this.element0, this.element1, other.element0, other.element1, other.element2, other.element3, other.element4); + } + + public Tuple8 join(Tuple6 other) { + return new Tuple8<>(this.element0, this.element1, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5); + } + + public Tuple9 join(Tuple7 other) { + return new Tuple9<>(this.element0, this.element1, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6); + } + + public Tuple10 join(Tuple8 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 Tuple11 join(Tuple9 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 Tuple12 join(Tuple10 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 Tuple13 join(Tuple11 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 Tuple14 join(Tuple12 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 apply(T0 arg0, T1 arg1); + } + + record Tuple3(T0 element0, T1 element1, T2 element2) { + public R applyTo(Func3 func) { + return func.apply(this.element0, this.element1, this.element2); + } + + public static Result, R> collect(Tuple3, Result, Result> tuple) { + return + tuple.element0.flatMap(element0 -> + tuple.element1.flatMap(element1 -> + tuple.element2.flatMap(element2 -> + Result.ok(new Tuple3<>(element0, element1, element2)) + ) + ) + ) + ; + } + + public Tuple3 map(Func1 map0, Func1 map1, Func1 map2) { + return new Tuple3<>(map0.apply(this.element0), map1.apply(this.element1), map2.apply(this.element2)); + } + + public Tuple3 join(Tuple0 other) { + return new Tuple3<>(this.element0, this.element1, this.element2); + } + + public Tuple4 join(Tuple1 other) { + return new Tuple4<>(this.element0, this.element1, this.element2, other.element0); + } + + public Tuple5 join(Tuple2 other) { + return new Tuple5<>(this.element0, this.element1, this.element2, other.element0, other.element1); + } + + public Tuple6 join(Tuple3 other) { + return new Tuple6<>(this.element0, this.element1, this.element2, other.element0, other.element1, other.element2); + } + + public Tuple7 join(Tuple4 other) { + return new Tuple7<>(this.element0, this.element1, this.element2, other.element0, other.element1, other.element2, other.element3); + } + + public Tuple8 join(Tuple5 other) { + return new Tuple8<>(this.element0, this.element1, this.element2, other.element0, other.element1, other.element2, other.element3, other.element4); + } + + public Tuple9 join(Tuple6 other) { + return new Tuple9<>(this.element0, this.element1, this.element2, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5); + } + + public Tuple10 join(Tuple7 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 Tuple11 join(Tuple8 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 Tuple12 join(Tuple9 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 Tuple13 join(Tuple10 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 Tuple14 join(Tuple11 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 apply(T0 arg0, T1 arg1, T2 arg2); + } + + record Tuple4(T0 element0, T1 element1, T2 element2, T3 element3) { + public R applyTo(Func4 func) { + return func.apply(this.element0, this.element1, this.element2, this.element3); + } + + public static Result, R> collect(Tuple4, Result, Result, Result> 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 Tuple4 map(Func1 map0, Func1 map1, Func1 map2, Func1 map3) { + return new Tuple4<>(map0.apply(this.element0), map1.apply(this.element1), map2.apply(this.element2), map3.apply(this.element3)); + } + + public Tuple4 join(Tuple0 other) { + return new Tuple4<>(this.element0, this.element1, this.element2, this.element3); + } + + public Tuple5 join(Tuple1 other) { + return new Tuple5<>(this.element0, this.element1, this.element2, this.element3, other.element0); + } + + public Tuple6 join(Tuple2 other) { + return new Tuple6<>(this.element0, this.element1, this.element2, this.element3, other.element0, other.element1); + } + + public Tuple7 join(Tuple3 other) { + return new Tuple7<>(this.element0, this.element1, this.element2, this.element3, other.element0, other.element1, other.element2); + } + + public Tuple8 join(Tuple4 other) { + return new Tuple8<>(this.element0, this.element1, this.element2, this.element3, other.element0, other.element1, other.element2, other.element3); + } + + public Tuple9 join(Tuple5 other) { + return new Tuple9<>(this.element0, this.element1, this.element2, this.element3, other.element0, other.element1, other.element2, other.element3, other.element4); + } + + public Tuple10 join(Tuple6 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 Tuple11 join(Tuple7 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 Tuple12 join(Tuple8 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 Tuple13 join(Tuple9 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 Tuple14 join(Tuple10 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 apply(T0 arg0, T1 arg1, T2 arg2, T3 arg3); + } + + record Tuple5(T0 element0, T1 element1, T2 element2, T3 element3, T4 element4) { + public R applyTo(Func5 func) { + return func.apply(this.element0, this.element1, this.element2, this.element3, this.element4); + } + + public static Result, R> collect(Tuple5, Result, Result, Result, Result> 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 Tuple5 map(Func1 map0, Func1 map1, Func1 map2, Func1 map3, Func1 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 join(Tuple0 other) { + return new Tuple5<>(this.element0, this.element1, this.element2, this.element3, this.element4); + } + + public Tuple6 join(Tuple1 other) { + return new Tuple6<>(this.element0, this.element1, this.element2, this.element3, this.element4, other.element0); + } + + public Tuple7 join(Tuple2 other) { + return new Tuple7<>(this.element0, this.element1, this.element2, this.element3, this.element4, other.element0, other.element1); + } + + public Tuple8 join(Tuple3 other) { + return new Tuple8<>(this.element0, this.element1, this.element2, this.element3, this.element4, other.element0, other.element1, other.element2); + } + + public Tuple9 join(Tuple4 other) { + return new Tuple9<>(this.element0, this.element1, this.element2, this.element3, this.element4, other.element0, other.element1, other.element2, other.element3); + } + + public Tuple10 join(Tuple5 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 Tuple11 join(Tuple6 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 Tuple12 join(Tuple7 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 Tuple13 join(Tuple8 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 Tuple14 join(Tuple9 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 apply(T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4); + } + + record Tuple6(T0 element0, T1 element1, T2 element2, T3 element3, T4 element4, + T5 element5) { + public R applyTo(Func6 func) { + return func.apply(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5); + } + + public static Result, R> collect(Tuple6, Result, Result, Result, Result, Result> 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 Tuple6 map(Func1 map0, Func1 map1, Func1 map2, Func1 map3, Func1 map4, Func1 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 join(Tuple0 other) { + return new Tuple6<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5); + } + + public Tuple7 join(Tuple1 other) { + return new Tuple7<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, other.element0); + } + + public Tuple8 join(Tuple2 other) { + return new Tuple8<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, other.element0, other.element1); + } + + public Tuple9 join(Tuple3 other) { + return new Tuple9<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, other.element0, other.element1, other.element2); + } + + public Tuple10 join(Tuple4 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 Tuple11 join(Tuple5 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 Tuple12 join(Tuple6 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 Tuple13 join(Tuple7 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 Tuple14 join(Tuple8 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 apply(T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5); + } + + record Tuple7(T0 element0, T1 element1, T2 element2, T3 element3, T4 element4, + T5 element5, T6 element6) { + public R applyTo(Func7 func) { + return func.apply(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6); + } + + public static Result, R> collect(Tuple7, Result, Result, Result, Result, Result, Result> 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 Tuple7 map(Func1 map0, Func1 map1, Func1 map2, Func1 map3, Func1 map4, Func1 map5, Func1 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 join(Tuple0 other) { + return new Tuple7<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6); + } + + public Tuple8 join(Tuple1 other) { + return new Tuple8<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, other.element0); + } + + public Tuple9 join(Tuple2 other) { + return new Tuple9<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, other.element0, other.element1); + } + + public Tuple10 join(Tuple3 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 Tuple11 join(Tuple4 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 Tuple12 join(Tuple5 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 Tuple13 join(Tuple6 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 Tuple14 join(Tuple7 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 apply(T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6); + } + + record Tuple8(T0 element0, T1 element1, T2 element2, T3 element3, T4 element4, + T5 element5, T6 element6, T7 element7) { + public R applyTo(Func8 func) { + return func.apply(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7); + } + + public static Result, R> collect(Tuple8, Result, Result, Result, Result, Result, Result, Result> 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 Tuple8 map(Func1 map0, Func1 map1, Func1 map2, Func1 map3, Func1 map4, Func1 map5, Func1 map6, Func1 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 join(Tuple0 other) { + return new Tuple8<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7); + } + + public Tuple9 join(Tuple1 other) { + return new Tuple9<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, other.element0); + } + + public Tuple10 join(Tuple2 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 Tuple11 join(Tuple3 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 Tuple12 join(Tuple4 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 Tuple13 join(Tuple5 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 Tuple14 join(Tuple6 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 apply(T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7); + } + + record Tuple9(T0 element0, T1 element1, T2 element2, T3 element3, T4 element4, + T5 element5, T6 element6, T7 element7, T8 element8) { + public R applyTo(Func9 func) { + return func.apply(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8); + } + + public static Result, R> collect(Tuple9, Result, Result, Result, Result, Result, Result, Result, Result> 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 Tuple9 map(Func1 map0, Func1 map1, Func1 map2, Func1 map3, Func1 map4, Func1 map5, Func1 map6, Func1 map7, Func1 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 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 Tuple10 join(Tuple1 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 Tuple11 join(Tuple2 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 Tuple12 join(Tuple3 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 Tuple13 join(Tuple4 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 Tuple14 join(Tuple5 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 apply(T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8); + } + + record Tuple10(T0 element0, T1 element1, T2 element2, T3 element3, + T4 element4, T5 element5, T6 element6, T7 element7, + T8 element8, T9 element9) { + public R applyTo(Func10 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 Result, R> collect(Tuple10, Result, Result, Result, Result, Result, Result, Result, Result, Result> 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 Tuple10 map(Func1 map0, Func1 map1, Func1 map2, Func1 map3, Func1 map4, Func1 map5, Func1 map6, Func1 map7, Func1 map8, Func1 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 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 Tuple11 join(Tuple1 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 Tuple12 join(Tuple2 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,