diff options
Diffstat (limited to 'src/main/java')
23 files changed, 1289 insertions, 105 deletions
diff --git a/src/main/java/moe/nea/pcj/AppendableError.java b/src/main/java/moe/nea/pcj/AppendableError.java deleted file mode 100644 index 6ec48fa..0000000 --- a/src/main/java/moe/nea/pcj/AppendableError.java +++ /dev/null @@ -1,21 +0,0 @@ -package moe.nea.pcj; - -import java.util.List; -import java.util.Optional; - -public interface AppendableError<T extends AppendableError<T>> { - /** - * @return an optional Self with getSuppressed containing the argument - */ - Optional<T> appendError(Object other); - - List<T> getSuppressed(); - - static <T> T concatError(T left, T right) { - if (left instanceof AppendableError<?> appendable) { - var opt = (Optional<T>) appendable.appendError(right); - return opt.orElse(left); - } - return left; - } -} diff --git a/src/main/java/moe/nea/pcj/Codec.java b/src/main/java/moe/nea/pcj/Codec.java index 728fbc6..121e05f 100644 --- a/src/main/java/moe/nea/pcj/Codec.java +++ b/src/main/java/moe/nea/pcj/Codec.java @@ -1,5 +1,6 @@ package moe.nea.pcj; -public interface Codec<Typ, Format, DeErr, CoErr> extends Decode<Typ, Format, DeErr>, Encode<Typ, Format, CoErr> { +public interface Codec<Typ, Format, Op extends Operation<Format>, DeErr, CoErr> + extends Decode<Typ, Format, Op, DeErr>, Encode<Typ, Format, Op, CoErr> { } diff --git a/src/main/java/moe/nea/pcj/Decode.java b/src/main/java/moe/nea/pcj/Decode.java index a335849..d10c98a 100644 --- a/src/main/java/moe/nea/pcj/Decode.java +++ b/src/main/java/moe/nea/pcj/Decode.java @@ -1,5 +1,5 @@ package moe.nea.pcj; -public interface Decode<Typ, Format, Err> { - Result<Typ, Err> decode(Format format, Operation<Format> op); +public interface Decode<Typ, Format, Op extends Operation<Format>, Err> { + Result<? extends Typ, ? extends Err> decode(Format format, Op ops); } diff --git a/src/main/java/moe/nea/pcj/Encode.java b/src/main/java/moe/nea/pcj/Encode.java index 0c17097..834ce66 100644 --- a/src/main/java/moe/nea/pcj/Encode.java +++ b/src/main/java/moe/nea/pcj/Encode.java @@ -1,5 +1,5 @@ package moe.nea.pcj; -public interface Encode<Typ, Format, Err> { - Result<Format, Err> encode(Typ data, Operation<Format> op); +public interface Encode<Typ, Format, Op extends Operation<Format>, Err> { + Result<? extends Format, ? extends Err> encode(Typ data, Op ops); } diff --git a/src/main/java/moe/nea/pcj/JsonLikeError.java b/src/main/java/moe/nea/pcj/JsonLikeError.java deleted file mode 100644 index 6d309ab..0000000 --- a/src/main/java/moe/nea/pcj/JsonLikeError.java +++ /dev/null @@ -1,29 +0,0 @@ -package moe.nea.pcj; - -import java.util.ArrayList; -import java.util.Collections; -import java.util.List; -import java.util.Optional; - -public abstract class JsonLikeError<Self extends JsonLikeError<?>> implements AppendableError<JsonLikeError<?>> { - private final List<JsonLikeError<?>> suppressed = new ArrayList<>(); - - protected abstract Self copySelfWithoutSuppressions(); - - @Override - public List<JsonLikeError<?>> getSuppressed() { - return Collections.unmodifiableList(suppressed); - } - - @Override - public Optional<JsonLikeError<?>> appendError(Object other) { - if (other instanceof JsonLikeError<?> jsonLikeOther) { - var newSelf = (JsonLikeError<?>) copySelfWithoutSuppressions(); - newSelf.suppressed.add(jsonLikeOther.copySelfWithoutSuppressions()); - newSelf.suppressed.addAll(jsonLikeOther.getSuppressed()); - return Optional.of(newSelf); - } else { - return Optional.empty(); - } - } -} diff --git a/src/main/java/moe/nea/pcj/RecordBuilder.java b/src/main/java/moe/nea/pcj/RecordBuilder.java deleted file mode 100644 index c28be7b..0000000 --- a/src/main/java/moe/nea/pcj/RecordBuilder.java +++ /dev/null @@ -1,6 +0,0 @@ -package moe.nea.pcj; - -public interface RecordBuilder<Format, ElementFormat> extends RecordView<ElementFormat> { - void add(String key, ElementFormat value); // TODO - Format complete(); -} diff --git a/src/main/java/moe/nea/pcj/Result.java b/src/main/java/moe/nea/pcj/Result.java index 8bec96a..e43633b 100644 --- a/src/main/java/moe/nea/pcj/Result.java +++ b/src/main/java/moe/nea/pcj/Result.java @@ -2,12 +2,15 @@ package moe.nea.pcj; import org.jspecify.annotations.Nullable; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; import java.util.Optional; import java.util.function.Function; public sealed interface Result<Good, Bad> permits Result.Ok, Result.Fail { default boolean isOk() { - return error().isEmpty(); + return errors().isEmpty(); } Optional<Good> value(); @@ -18,26 +21,31 @@ public sealed interface Result<Good, Bad> permits Result.Ok, Result.Fail { return value().or(this::partial); } - Optional<Bad> error(); + List<Bad> errors(); default <Next> Result<Next, Bad> map(Function<Good, Next> mapper) { return flatMap(mapper.andThen(Result::ok)); } - default <Next> Result<Next, Bad> flatMap(Function<Good, Result<Next, Bad>> mapper) { - return flatMapBoth(mapper, Result::fail); + <Next> Result<Next, Bad> flatMap(Function<Good, Result<? extends Next, ? extends Bad>> mapper); + + default <NextBad> Result<Good, NextBad> mapError(Function<Bad, NextBad> mapper) { + return mapErrors(it -> it.stream().map(mapper).toList()); } - <NextGood> Result<NextGood, Bad> flatMapBoth( - Function<Good, Result<NextGood, Bad>> mapGood, - Function<Bad, Result<NextGood, Bad>> mapBad); + <NextBad> Result<Good, NextBad> mapErrors(Function<List<Bad>, List<NextBad>> mapper); - Result<Good, Bad> appendError(Bad error); + Result<Good, Bad> appendErrors(List<Bad> error); record Ok<Good, Bad>(Good okValue) implements Result<Good, Bad> { @Override - public Result<Good, Bad> appendError(Bad error) { - return Result.partial(okValue, error); + public Result<Good, Bad> appendErrors(List<Bad> errors) { + return new Fail<>(okValue, errors); + } + + @Override + public <NextBad> Result<Good, NextBad> mapErrors(Function<List<Bad>, List<NextBad>> mapper) { + return new Ok<>(okValue); } @Override @@ -46,22 +54,26 @@ public sealed interface Result<Good, Bad> permits Result.Ok, Result.Fail { } @Override - public Optional<Good> value() { - return Optional.of(okValue); + public List<Bad> errors() { + return List.of(); } @Override - public Optional<Bad> error() { - return Optional.empty(); + public <Next> Result<Next, Bad> flatMap(Function<Good, Result<? extends Next, ? extends Bad>> mapper) { + return Result.cast(mapper.apply(okValue)); } @Override - public <NextGood> Result<NextGood, Bad> flatMapBoth(Function<Good, Result<NextGood, Bad>> mapGood, Function<Bad, Result<NextGood, Bad>> mapBad) { - return mapGood.apply(okValue); + public Optional<Good> value() { + return Optional.of(okValue); } } - record Fail<Good, Bad>(@Nullable Good partialValue, Bad badValue) implements Result<Good, Bad> { + record Fail<Good, Bad>(@Nullable Good partialValue, List<Bad> badValue) implements Result<Good, Bad> { + public Fail { + if (badValue.isEmpty()) + throw new IllegalArgumentException("Cannot create failure without any error values"); + } @Override public Optional<Good> value() { @@ -74,22 +86,28 @@ public sealed interface Result<Good, Bad> permits Result.Ok, Result.Fail { } @Override - public Optional<Bad> error() { - return Optional.of(badValue); + public List<Bad> errors() { + return Collections.unmodifiableList(badValue); } @Override - public <NextGood> Result<NextGood, Bad> flatMapBoth(Function<Good, Result<NextGood, Bad>> mapGood, Function<Bad, Result<NextGood, Bad>> mapBad) { + public <Next> Result<Next, Bad> flatMap(Function<Good, Result<? extends Next, ? extends Bad>> mapper) { if (partialValue != null) { - var nextPartial = mapGood.apply(partialValue); - return nextPartial.appendError(badValue); + return Result.<Next, Bad>cast(mapper.apply(partialValue)).appendErrors(badValue); } - return mapBad.apply(badValue); + return new Fail<>(null, badValue); + } + + @Override + public <NextBad> Result<Good, NextBad> mapErrors(Function<List<Bad>, List<NextBad>> mapper) { + return new Fail<>(partialValue, mapper.apply(badValue)); } @Override - public Result<Good, Bad> appendError(Bad error) { - return Result.partial(partialValue, AppendableError.concatError(badValue, error)); + public Result<Good, Bad> appendErrors(List<Bad> errors) { + var nextErrors = new ArrayList<>(badValue); + nextErrors.addAll(errors); + return new Fail<>(partialValue, nextErrors); } } @@ -98,10 +116,16 @@ public sealed interface Result<Good, Bad> permits Result.Ok, Result.Fail { } static <Good, Bad> Result.Fail<Good, Bad> fail(Bad error) { - return new Fail<>(null, error); + return new Fail<>(null, List.of(error)); + } + + + static <Good, Bad> Result<Good, Bad> cast(Result<? extends Good, ? extends Bad> c) { + //noinspection unchecked + return (Result<Good, Bad>) c; } static <Good, Bad> Result.Fail<Good, Bad> partial(@Nullable Good partial, Bad error) { - return new Fail<>(partial, error); + return new Fail<>(partial, List.of(error)); } } diff --git a/src/main/java/moe/nea/pcj/Tuple.java b/src/main/java/moe/nea/pcj/Tuple.java index baaceef..e6207ff 100644 --- a/src/main/java/moe/nea/pcj/Tuple.java +++ b/src/main/java/moe/nea/pcj/Tuple.java @@ -1,16 +1,1030 @@ +// @generated by gentuples.ts package moe.nea.pcj; +@SuppressWarnings("unused") public interface Tuple { - record Tuple2<A, B>(A first, B second) implements Tuple {} + class Tuple0 implements Tuple { + public <R> R applyTo(Func0<R> func) { + return func.apply(); + } - record Tuple3<A, B, C>(A first, B second, C third) implements Tuple {} + public static <R> Result<Tuple0, R> collect(Tuple0 tuple) { + return + Result.ok(new Tuple0()) + ; + } - record Tuple4<A, B, C, D>(A first, B second, C third, D fourth) implements Tuple {} + public Tuple0 map() { + return new Tuple0(); + } - record Tuple5<A, B, C, D, E>(A first, B second, C third, D fourth, E fifth) implements Tuple {} + public Tuple0 join(Tuple0 other) { + return new Tuple0(); + } - record Tuple6<A, B, C, D, E, F>(A first, B second, C third, D fourth, E fifth, F sixth) implements Tuple {} + public <E0> Tuple1<E0> join(Tuple1<E0> other) { + return new Tuple1<>(other.element0); + } - record Tuple7<A, B, C, D, E, F, G>(A first, B second, C third, D fourth, E fifth, F sixth, - G seventh) implements Tuple {} + public <E0, E1> Tuple2<E0, E1> join(Tuple2<E0, E1> other) { + return new Tuple2<>(other.element0, other.element1); + } + + public <E0, E1, E2> Tuple3<E0, E1, E2> join(Tuple3<E0, E1, E2> other) { + return new Tuple3<>(other.element0, other.element1, other.element2); + } + + public <E0, E1, E2, E3> Tuple4<E0, E1, E2, E3> join(Tuple4<E0, E1, E2, E3> other) { + return new Tuple4<>(other.element0, other.element1, other.element2, other.element3); + } + + public <E0, E1, E2, E3, E4> Tuple5<E0, E1, E2, E3, E4> join(Tuple5<E0, E1, E2, E3, E4> other) { + return new Tuple5<>(other.element0, other.element1, other.element2, other.element3, other.element4); + } + + public <E0, E1, E2, E3, E4, E5> Tuple6<E0, E1, E2, E3, E4, E5> join(Tuple6<E0, E1, E2, E3, E4, E5> other) { + return new Tuple6<>(other.element0, other.element1, other.element2, other.element3, other.element4, other.element5); + } + + public <E0, E1, E2, E3, E4, E5, E6> Tuple7<E0, E1, E2, E3, E4, E5, E6> join(Tuple7<E0, E1, E2, E3, E4, E5, E6> other) { + return new Tuple7<>(other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6); + } + + public <E0, E1, E2, E3, E4, E5, E6, E7> Tuple8<E0, E1, E2, E3, E4, E5, E6, E7> join(Tuple8<E0, E1, E2, E3, E4, E5, E6, E7> other) { + return new Tuple8<>(other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7); + } + + public <E0, E1, E2, E3, E4, E5, E6, E7, E8> Tuple9<E0, E1, E2, E3, E4, E5, E6, E7, E8> join(Tuple9<E0, E1, E2, E3, E4, E5, E6, E7, E8> other) { + return new Tuple9<>(other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8); + } + + public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> Tuple10<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> join(Tuple10<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> other) { + return new Tuple10<>(other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9); + } + + public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> Tuple11<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> join(Tuple11<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> other) { + return new Tuple11<>(other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9, other.element10); + } + + public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11> Tuple12<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11> join(Tuple12<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11> other) { + return new Tuple12<>(other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9, other.element10, other.element11); + } + + public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11, E12> Tuple13<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11, E12> join(Tuple13<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11, E12> other) { + return new Tuple13<>(other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9, other.element10, other.element11, other.element12); + } + + public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11, E12, E13> Tuple14<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11, E12, E13> join(Tuple14<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11, E12, E13> other) { + return new Tuple14<>(other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9, other.element10, other.element11, other.element12, other.element13); + } + } + + @FunctionalInterface + interface Func0<R> { + R apply(); + } + + record Tuple1<T0>(T0 element0) { + public <R> R applyTo(Func1<R, T0> func) { + return func.apply(this.element0); + } + + public static <R, T0> Result<Tuple1<T0>, R> collect(Tuple1<Result<T0, R>> tuple) { + return + tuple.element0.flatMap(element0 -> + Result.ok(new Tuple1<>(element0)) + ) + ; + } + + public <E0> Tuple1<E0> map(Func1<E0, T0> map0) { + return new Tuple1<>(map0.apply(this.element0)); + } + + public Tuple1<T0> join(Tuple0 other) { + return new Tuple1<>(this.element0); + } + + public <E0> Tuple2<T0, E0> join(Tuple1<E0> other) { + return new Tuple2<>(this.element0, other.element0); + } + + public <E0, E1> Tuple3<T0, E0, E1> join(Tuple2<E0, E1> other) { + return new Tuple3<>(this.element0, other.element0, other.element1); + } + + public <E0, E1, E2> Tuple4<T0, E0, E1, E2> join(Tuple3<E0, E1, E2> other) { + return new Tuple4<>(this.element0, other.element0, other.element1, other.element2); + } + + public <E0, E1, E2, E3> Tuple5<T0, E0, E1, E2, E3> join(Tuple4<E0, E1, E2, E3> other) { + return new Tuple5<>(this.element0, other.element0, other.element1, other.element2, other.element3); + } + + public <E0, E1, E2, E3, E4> Tuple6<T0, E0, E1, E2, E3, E4> join(Tuple5<E0, E1, E2, E3, E4> other) { + return new Tuple6<>(this.element0, other.element0, other.element1, other.element2, other.element3, other.element4); + } + + public <E0, E1, E2, E3, E4, E5> Tuple7<T0, E0, E1, E2, E3, E4, E5> join(Tuple6<E0, E1, E2, E3, E4, E5> other) { + return new Tuple7<>(this.element0, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5); + } + + public <E0, E1, E2, E3, E4, E5, E6> Tuple8<T0, E0, E1, E2, E3, E4, E5, E6> join(Tuple7<E0, E1, E2, E3, E4, E5, E6> other) { + return new Tuple8<>(this.element0, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6); + } + + public <E0, E1, E2, E3, E4, E5, E6, E7> Tuple9<T0, E0, E1, E2, E3, E4, E5, E6, E7> join(Tuple8<E0, E1, E2, E3, E4, E5, E6, E7> other) { + return new Tuple9<>(this.element0, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7); + } + + public <E0, E1, E2, E3, E4, E5, E6, E7, E8> Tuple10<T0, E0, E1, E2, E3, E4, E5, E6, E7, E8> join(Tuple9<E0, E1, E2, E3, E4, E5, E6, E7, E8> other) { + return new Tuple10<>(this.element0, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8); + } + + public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> Tuple11<T0, E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> join(Tuple10<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> other) { + return new Tuple11<>(this.element0, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9); + } + + public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> Tuple12<T0, E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> join(Tuple11<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> other) { + return new Tuple12<>(this.element0, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9, other.element10); + } + + public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11> Tuple13<T0, E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11> join(Tuple12<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11> other) { + return new Tuple13<>(this.element0, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9, other.element10, other.element11); + } + + public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11, E12> Tuple14<T0, E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11, E12> join(Tuple13<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11, E12> other) { + return new Tuple14<>(this.element0, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9, other.element10, other.element11, other.element12); + } + } + + @FunctionalInterface + interface Func1<R, T0> { + R apply(T0 arg0); + } + + record Tuple2<T0, T1>(T0 element0, T1 element1) { + public <R> R applyTo(Func2<R, T0, T1> func) { + return func.apply(this.element0, this.element1); + } + + public static <R, T0, T1> Result<Tuple2<T0, T1>, R> collect(Tuple2<Result<T0, R>, Result<T1, R>> tuple) { + return + tuple.element0.flatMap(element0 -> + tuple.element1.flatMap(element1 -> + Result.ok(new Tuple2<>(element0, element1)) + ) + ) + ; + } + + public <E0, E1> Tuple2<E0, E1> map(Func1<E0, T0> map0, Func1<E1, T1> map1) { + return new Tuple2<>(map0.apply(this.element0), map1.apply(this.element1)); + } + + public Tuple2<T0, T1> join(Tuple0 other) { + return new Tuple2<>(this.element0, this.element1); + } + + public <E0> Tuple3<T0, T1, E0> join(Tuple1<E0> other) { + return new Tuple3<>(this.element0, this.element1, other.element0); + } + + public <E0, E1> Tuple4<T0, T1, E0, E1> join(Tuple2<E0, E1> other) { + return new Tuple4<>(this.element0, this.element1, other.element0, other.element1); + } + + public <E0, E1, E2> Tuple5<T0, T1, E0, E1, E2> join(Tuple3<E0, E1, E2> other) { + return new Tuple5<>(this.element0, this.element1, other.element0, other.element1, other.element2); + } + + public <E0, E1, E2, E3> Tuple6<T0, T1, E0, E1, E2, E3> join(Tuple4<E0, E1, E2, E3> other) { + return new Tuple6<>(this.element0, this.element1, other.element0, other.element1, other.element2, other.element3); + } + + public <E0, E1, E2, E3, E4> Tuple7<T0, T1, E0, E1, E2, E3, E4> join(Tuple5<E0, E1, E2, E3, E4> other) { + return new Tuple7<>(this.element0, this.element1, other.element0, other.element1, other.element2, other.element3, other.element4); + } + + public <E0, E1, E2, E3, E4, E5> Tuple8<T0, T1, E0, E1, E2, E3, E4, E5> join(Tuple6<E0, E1, E2, E3, E4, E5> other) { + return new Tuple8<>(this.element0, this.element1, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5); + } + + public <E0, E1, E2, E3, E4, E5, E6> Tuple9<T0, T1, E0, E1, E2, E3, E4, E5, E6> join(Tuple7<E0, E1, E2, E3, E4, E5, E6> other) { + return new Tuple9<>(this.element0, this.element1, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6); + } + + public <E0, E1, E2, E3, E4, E5, E6, E7> Tuple10<T0, T1, E0, E1, E2, E3, E4, E5, E6, E7> join(Tuple8<E0, E1, E2, E3, E4, E5, E6, E7> other) { + return new Tuple10<>(this.element0, this.element1, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7); + } + + public <E0, E1, E2, E3, E4, E5, E6, E7, E8> Tuple11<T0, T1, E0, E1, E2, E3, E4, E5, E6, E7, E8> join(Tuple9<E0, E1, E2, E3, E4, E5, E6, E7, E8> other) { + return new Tuple11<>(this.element0, this.element1, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8); + } + + public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> Tuple12<T0, T1, E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> join(Tuple10<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> other) { + return new Tuple12<>(this.element0, this.element1, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9); + } + + public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> Tuple13<T0, T1, E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> join(Tuple11<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> other) { + return new Tuple13<>(this.element0, this.element1, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9, other.element10); + } + + public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11> Tuple14<T0, T1, E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11> join(Tuple12<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11> other) { + return new Tuple14<>(this.element0, this.element1, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9, other.element10, other.element11); + } + } + + @FunctionalInterface + interface Func2<R, T0, T1> { + R apply(T0 arg0, T1 arg1); + } + + record Tuple3<T0, T1, T2>(T0 element0, T1 element1, T2 element2) { + public <R> R applyTo(Func3<R, T0, T1, T2> func) { + return func.apply(this.element0, this.element1, this.element2); + } + + public static <R, T0, T1, T2> Result<Tuple3<T0, T1, T2>, R> collect(Tuple3<Result<T0, R>, Result<T1, R>, Result<T2, R>> tuple) { + return + tuple.element0.flatMap(element0 -> + tuple.element1.flatMap(element1 -> + tuple.element2.flatMap(element2 -> + Result.ok(new Tuple3<>(element0, element1, element2)) + ) + ) + ) + ; + } + + public <E0, E1, E2> Tuple3<E0, E1, E2> map(Func1<E0, T0> map0, Func1<E1, T1> map1, Func1<E2, T2> map2) { + return new Tuple3<>(map0.apply(this.element0), map1.apply(this.element1), map2.apply(this.element2)); + } + + public Tuple3<T0, T1, T2> join(Tuple0 other) { + return new Tuple3<>(this.element0, this.element1, this.element2); + } + + public <E0> Tuple4<T0, T1, T2, E0> join(Tuple1<E0> other) { + return new Tuple4<>(this.element0, this.element1, this.element2, other.element0); + } + + public <E0, E1> Tuple5<T0, T1, T2, E0, E1> join(Tuple2<E0, E1> other) { + return new Tuple5<>(this.element0, this.element1, this.element2, other.element0, other.element1); + } + + public <E0, E1, E2> Tuple6<T0, T1, T2, E0, E1, E2> join(Tuple3<E0, E1, E2> other) { + return new Tuple6<>(this.element0, this.element1, this.element2, other.element0, other.element1, other.element2); + } + + public <E0, E1, E2, E3> Tuple7<T0, T1, T2, E0, E1, E2, E3> join(Tuple4<E0, E1, E2, E3> other) { + return new Tuple7<>(this.element0, this.element1, this.element2, other.element0, other.element1, other.element2, other.element3); + } + + public <E0, E1, E2, E3, E4> Tuple8<T0, T1, T2, E0, E1, E2, E3, E4> join(Tuple5<E0, E1, E2, E3, E4> other) { + return new Tuple8<>(this.element0, this.element1, this.element2, other.element0, other.element1, other.element2, other.element3, other.element4); + } + + public <E0, E1, E2, E3, E4, E5> Tuple9<T0, T1, T2, E0, E1, E2, E3, E4, E5> join(Tuple6<E0, E1, E2, E3, E4, E5> other) { + return new Tuple9<>(this.element0, this.element1, this.element2, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5); + } + + public <E0, E1, E2, E3, E4, E5, E6> Tuple10<T0, T1, T2, E0, E1, E2, E3, E4, E5, E6> join(Tuple7<E0, E1, E2, E3, E4, E5, E6> other) { + return new Tuple10<>(this.element0, this.element1, this.element2, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6); + } + + public <E0, E1, E2, E3, E4, E5, E6, E7> Tuple11<T0, T1, T2, E0, E1, E2, E3, E4, E5, E6, E7> join(Tuple8<E0, E1, E2, E3, E4, E5, E6, E7> other) { + return new Tuple11<>(this.element0, this.element1, this.element2, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7); + } + + public <E0, E1, E2, E3, E4, E5, E6, E7, E8> Tuple12<T0, T1, T2, E0, E1, E2, E3, E4, E5, E6, E7, E8> join(Tuple9<E0, E1, E2, E3, E4, E5, E6, E7, E8> other) { + return new Tuple12<>(this.element0, this.element1, this.element2, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8); + } + + public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> Tuple13<T0, T1, T2, E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> join(Tuple10<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> other) { + return new Tuple13<>(this.element0, this.element1, this.element2, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9); + } + + public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> Tuple14<T0, T1, T2, E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> join(Tuple11<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> other) { + return new Tuple14<>(this.element0, this.element1, this.element2, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9, other.element10); + } + } + + @FunctionalInterface + interface Func3<R, T0, T1, T2> { + R apply(T0 arg0, T1 arg1, T2 arg2); + } + + record Tuple4<T0, T1, T2, T3>(T0 element0, T1 element1, T2 element2, T3 element3) { + public <R> R applyTo(Func4<R, T0, T1, T2, T3> func) { + return func.apply(this.element0, this.element1, this.element2, this.element3); + } + + public static <R, T0, T1, T2, T3> Result<Tuple4<T0, T1, T2, T3>, R> collect(Tuple4<Result<T0, R>, Result<T1, R>, Result<T2, R>, Result<T3, R>> tuple) { + return + tuple.element0.flatMap(element0 -> + tuple.element1.flatMap(element1 -> + tuple.element2.flatMap(element2 -> + tuple.element3.flatMap(element3 -> + Result.ok(new Tuple4<>(element0, element1, element2, element3)) + ) + ) + ) + ) + ; + } + + public <E0, E1, E2, E3> Tuple4<E0, E1, E2, E3> map(Func1<E0, T0> map0, Func1<E1, T1> map1, Func1<E2, T2> map2, Func1<E3, T3> map3) { + return new Tuple4<>(map0.apply(this.element0), map1.apply(this.element1), map2.apply(this.element2), map3.apply(this.element3)); + } + + public Tuple4<T0, T1, T2, T3> join(Tuple0 other) { + return new Tuple4<>(this.element0, this.element1, this.element2, this.element3); + } + + public <E0> Tuple5<T0, T1, T2, T3, E0> join(Tuple1<E0> other) { + return new Tuple5<>(this.element0, this.element1, this.element2, this.element3, other.element0); + } + + public <E0, E1> Tuple6<T0, T1, T2, T3, E0, E1> join(Tuple2<E0, E1> other) { + return new Tuple6<>(this.element0, this.element1, this.element2, this.element3, other.element0, other.element1); + } + + 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/json/AtField.java b/src/main/java/moe/nea/pcj/json/AtField.java new file mode 100644 index 0000000..3780e38 --- /dev/null +++ b/src/main/java/moe/nea/pcj/json/AtField.java @@ -0,0 +1,4 @@ +package moe.nea.pcj.json; + +public record AtField(String field, 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 new file mode 100644 index 0000000..8f957f9 --- /dev/null +++ b/src/main/java/moe/nea/pcj/json/BasicCodecs.java @@ -0,0 +1,51 @@ +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)); + } + }; + + public <T> JsonCodec<T, Format> objectCodec() { + + } +}
\ 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 new file mode 100644 index 0000000..13d81db --- /dev/null +++ b/src/main/java/moe/nea/pcj/json/DuplicateJsonKey.java @@ -0,0 +1,4 @@ +package moe.nea.pcj.json; + +public record DuplicateJsonKey(String key) implements JsonLikeError { +} diff --git a/src/main/java/moe/nea/pcj/json/JsonCodec.java b/src/main/java/moe/nea/pcj/json/JsonCodec.java new file mode 100644 index 0000000..65f4a5e --- /dev/null +++ b/src/main/java/moe/nea/pcj/json/JsonCodec.java @@ -0,0 +1,31 @@ +package moe.nea.pcj.json; + +import moe.nea.pcj.Codec; +import moe.nea.pcj.Result; + +public interface JsonCodec<T, Format> extends Codec< + T, Format, JsonLikeOperations<Format>, + JsonLikeError, JsonLikeError> { + + 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 new file mode 100644 index 0000000..609bd84 --- /dev/null +++ b/src/main/java/moe/nea/pcj/json/JsonLikeError.java @@ -0,0 +1,4 @@ +package moe.nea.pcj.json; + +public interface JsonLikeError { +} diff --git a/src/main/java/moe/nea/pcj/JsonLikeOperations.java b/src/main/java/moe/nea/pcj/json/JsonLikeOperations.java index 2188568..7bb0162 100644 --- a/src/main/java/moe/nea/pcj/JsonLikeOperations.java +++ b/src/main/java/moe/nea/pcj/json/JsonLikeOperations.java @@ -1,4 +1,8 @@ -package moe.nea.pcj; +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> { @@ -8,7 +12,7 @@ public interface JsonLikeOperations<Format> extends Operation<Format> { Format createNumeric(Number value); - Result<Number, ? extends JsonLikeError> getInt(Format element); + Result<Number, ? extends JsonLikeError> getNumeric(Format element); Format createString(String value); @@ -18,11 +22,11 @@ public interface JsonLikeOperations<Format> extends Operation<Format> { Result<Boolean, ? extends JsonLikeError> getBoolean(Format format); - RecordBuilder<? extends Format, Format> createObject(); + RecordBuilder<Format> createObject(); - Result<RecordView<? extends Format>, ? extends JsonLikeError> getObject(Format format); + Result<? extends RecordView<Format>, ? extends JsonLikeError> getObject(Format format); - ListBuilder<? extends Format, Format> createList(); + ListBuilder<Format, Format> createList(); - Result<ListView<? extends Format>, ? extends JsonLikeError> getList(Format format); + Result<? extends ListView<Format>, ? extends JsonLikeError> getList(Format format); } diff --git a/src/main/java/moe/nea/pcj/ListBuilder.java b/src/main/java/moe/nea/pcj/json/ListBuilder.java index 9f6e9a3..c6e9220 100644 --- a/src/main/java/moe/nea/pcj/ListBuilder.java +++ b/src/main/java/moe/nea/pcj/json/ListBuilder.java @@ -1,4 +1,4 @@ -package moe.nea.pcj; +package moe.nea.pcj.json; public interface ListBuilder<Format, ElementFormat> extends ListView<ElementFormat> { Format complete(); diff --git a/src/main/java/moe/nea/pcj/ListView.java b/src/main/java/moe/nea/pcj/json/ListView.java index 57c229a..dcc6e37 100644 --- a/src/main/java/moe/nea/pcj/ListView.java +++ b/src/main/java/moe/nea/pcj/json/ListView.java @@ -1,4 +1,4 @@ -package moe.nea.pcj; +package moe.nea.pcj.json; import java.util.Optional; diff --git a/src/main/java/moe/nea/pcj/json/MapCodec.java b/src/main/java/moe/nea/pcj/json/MapCodec.java new file mode 100644 index 0000000..468e4cf --- /dev/null +++ b/src/main/java/moe/nea/pcj/json/MapCodec.java @@ -0,0 +1,17 @@ +package moe.nea.pcj.json; + +import moe.nea.pcj.Result; + +import java.util.function.Function; + +public interface MapCodec<T, Format> { + Result<T, JsonLikeError> decode( + RecordView<Format> record, + JsonLikeOperations<Format> ops); + + Result<RecordBuilder<Format>, JsonLikeError> encode(T value, JsonLikeOperations<Format> ops); + + 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 new file mode 100644 index 0000000..3dad05c --- /dev/null +++ b/src/main/java/moe/nea/pcj/json/MissingKey.java @@ -0,0 +1,4 @@ +package moe.nea.pcj.json; + +public record MissingKey(String missingKey) implements JsonLikeError { +} diff --git a/src/main/java/moe/nea/pcj/json/RecordBuilder.java b/src/main/java/moe/nea/pcj/json/RecordBuilder.java new file mode 100644 index 0000000..c610f27 --- /dev/null +++ b/src/main/java/moe/nea/pcj/json/RecordBuilder.java @@ -0,0 +1,12 @@ +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 new file mode 100644 index 0000000..7ba8815 --- /dev/null +++ b/src/main/java/moe/nea/pcj/json/RecordCodec.java @@ -0,0 +1,59 @@ +package moe.nea.pcj.json; + +import moe.nea.pcj.Codec; +import moe.nea.pcj.Result; +import moe.nea.pcj.Tuple; + +import java.util.function.Function; +import java.util.stream.Stream; + +public record RecordCodec<O, T, Format>( + MapCodec<T, Format> codec, + Function<O, T> getter +) { + + private Result<RecordBuilder<Format>, JsonLikeError> enc(O data, JsonLikeOperations<Format> ops) { + return codec().encode(getter().apply(data), ops); + } + + private Result<T, JsonLikeError> dec(RecordView<Format> data, JsonLikeOperations<Format> ops) { + return codec().decode(data, ops); + } + + private 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)); + } + + abstract static class RecordCompleteCodec<O, Format> implements JsonCodec<O, Format> { + @Override + public Result<O, JsonLikeError> decode(Format format, JsonLikeOperations<Format> ops) { + return Result.<RecordView<Format>, JsonLikeError>cast(ops.getObject(format)) + .flatMap(record -> (decode(record, ops))); + } + + protected abstract Result<O, JsonLikeError> decode(RecordView<Format> record, JsonLikeOperations<Format> ops); + } + + public static <T1, T2, O, Format> JsonCodec<O, Format> join( + RecordCodec<O, T1, Format> arg1, + RecordCodec<O, T2, Format> arg2, + Tuple.Func2<O, T1, T2> joiner + ) { + return new RecordCompleteCodec<>() { + + @Override + public Result<Format, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) { + return Stream.of(arg1.enc(data, ops), arg2.enc(data, ops)) + .reduce(Result.ok(ops.createObject()), RecordCodec::merge) + .map(RecordBuilder::complete); + } + + @Override + public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) { + return Tuple.Tuple2.collect(new Tuple.Tuple2<>(arg1, arg2) + .map(it -> it.dec(format, ops), it -> it.dec(format, ops))) + .map(it -> it.applyTo(joiner)); + } + }; + } +} diff --git a/src/main/java/moe/nea/pcj/RecordView.java b/src/main/java/moe/nea/pcj/json/RecordView.java index 84057ba..968a936 100644 --- a/src/main/java/moe/nea/pcj/RecordView.java +++ b/src/main/java/moe/nea/pcj/json/RecordView.java @@ -1,10 +1,10 @@ -package moe.nea.pcj; +package moe.nea.pcj.json; import java.util.Collection; import java.util.Optional; public interface RecordView<Format> { - Collection<Format> getKeys(); + 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 new file mode 100644 index 0000000..7bee7c1 --- /dev/null +++ b/src/main/java/moe/nea/pcj/json/UnexpectedJsonElement.java @@ -0,0 +1,7 @@ +package moe.nea.pcj.json; + +public record UnexpectedJsonElement( + String expectedType, + Object actualJsonObject +) implements JsonLikeError { +} diff --git a/src/main/java/moe/nea/pcj/json/package-info.java b/src/main/java/moe/nea/pcj/json/package-info.java new file mode 100644 index 0000000..a5aace0 --- /dev/null +++ b/src/main/java/moe/nea/pcj/json/package-info.java @@ -0,0 +1,4 @@ +@NullMarked +package moe.nea.pcj.json; + +import org.jspecify.annotations.NullMarked;
\ No newline at end of file |