diff options
| author | Linnea Gräf <nea@nea.moe> | 2024-11-16 17:20:52 +0100 |
|---|---|---|
| committer | Linnea Gräf <nea@nea.moe> | 2024-11-16 17:20:52 +0100 |
| commit | aad6ebad69685abd4b7711039d91d5c19dfbf61f (patch) | |
| tree | 27eb2b806ac01db251b08ed5794ac81a50603327 /core/src/main/java/moe | |
| parent | 63cb7a0e19e7afd06637dddb848d0254cbff5795 (diff) | |
| download | profunctor-codecs-java-aad6ebad69685abd4b7711039d91d5c19dfbf61f.tar.gz profunctor-codecs-java-aad6ebad69685abd4b7711039d91d5c19dfbf61f.tar.bz2 profunctor-codecs-java-aad6ebad69685abd4b7711039d91d5c19dfbf61f.zip | |
chore: create subproject for core
Diffstat (limited to 'core/src/main/java/moe')
29 files changed, 1910 insertions, 0 deletions
diff --git a/core/src/main/java/moe/nea/pcj/Codec.java b/core/src/main/java/moe/nea/pcj/Codec.java new file mode 100644 index 0000000..121e05f --- /dev/null +++ b/core/src/main/java/moe/nea/pcj/Codec.java @@ -0,0 +1,6 @@ +package moe.nea.pcj; + +public interface Codec<Typ, Format, Op extends Operation<Format>, DeErr, CoErr> + extends Decode<Typ, Format, Op, DeErr>, Encode<Typ, Format, Op, CoErr> { + +} diff --git a/core/src/main/java/moe/nea/pcj/Decode.java b/core/src/main/java/moe/nea/pcj/Decode.java new file mode 100644 index 0000000..d10c98a --- /dev/null +++ b/core/src/main/java/moe/nea/pcj/Decode.java @@ -0,0 +1,5 @@ +package moe.nea.pcj; + +public interface Decode<Typ, Format, Op extends Operation<Format>, Err> { + Result<? extends Typ, ? extends Err> decode(Format format, Op ops); +} diff --git a/core/src/main/java/moe/nea/pcj/Encode.java b/core/src/main/java/moe/nea/pcj/Encode.java new file mode 100644 index 0000000..834ce66 --- /dev/null +++ b/core/src/main/java/moe/nea/pcj/Encode.java @@ -0,0 +1,5 @@ +package moe.nea.pcj; + +public interface Encode<Typ, Format, Op extends Operation<Format>, Err> { + Result<? extends Format, ? extends Err> encode(Typ data, Op ops); +} diff --git a/core/src/main/java/moe/nea/pcj/Operation.java b/core/src/main/java/moe/nea/pcj/Operation.java new file mode 100644 index 0000000..90995ef --- /dev/null +++ b/core/src/main/java/moe/nea/pcj/Operation.java @@ -0,0 +1,4 @@ +package moe.nea.pcj; + +public interface Operation<Format> { +} diff --git a/core/src/main/java/moe/nea/pcj/Result.java b/core/src/main/java/moe/nea/pcj/Result.java new file mode 100644 index 0000000..a9c2494 --- /dev/null +++ b/core/src/main/java/moe/nea/pcj/Result.java @@ -0,0 +1,165 @@ +package moe.nea.pcj; + +import org.jspecify.annotations.Nullable; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.Objects; +import java.util.Optional; +import java.util.function.Function; + +public sealed interface Result<Good, Bad> permits Result.Ok, Result.Fail { + default boolean isOk() { + return errors().isEmpty(); + } + + Optional<Good> value(); + + Optional<Good> partial(); + + default Optional<Good> valueOrPartial() { + return value().or(this::partial); + } + + List<Bad> errors(); + + default <Next> Result<Next, Bad> map(Function<Good, Next> mapper) { + return flatMap(mapper.andThen(Result::ok)); + } + + <Next> Result<Next, Bad> flatMap(Function<Good, Result<? extends Next, ? extends Bad>> mapper); + + default <NextBad> Result<Good, NextBad> mapError(Function<Bad, NextBad> mapper) { + return mapErrors(it -> it.stream().map(mapper).toList()); + } + + <NextBad> Result<Good, NextBad> mapErrors(Function<List<Bad>, List<NextBad>> mapper); + + default Result<Good, Bad> appendError(Bad error) { + return appendErrors(List.of(error)); + } + + Result<Good, Bad> appendErrors(List<Bad> error); + + record Ok<Good, Bad>(Good okValue) implements Result<Good, Bad> { + @Override + public Result<Good, Bad> appendErrors(List<Bad> errors) { + if (errors.isEmpty()) return new Ok<>(okValue); + return new Fail<>(okValue, errors); + } + + @Override + public <NextBad> Result<Good, NextBad> mapErrors(Function<List<Bad>, List<NextBad>> mapper) { + return new Ok<>(okValue); + } + + @Override + public Optional<Good> partial() { + return Optional.empty(); + } + + @Override + public List<Bad> errors() { + return List.of(); + } + + @Override + public <Next> Result<Next, Bad> flatMap(Function<Good, Result<? extends Next, ? extends Bad>> mapper) { + return Result.cast(mapper.apply(okValue)); + } + + @Override + public Optional<Good> value() { + return Optional.of(okValue); + } + + @Override + public int hashCode() { + return Objects.hash(okValue); + } + + @Override + public boolean equals(Object obj) { + if (obj == this) return true; + if (obj instanceof Result.Ok<?, ?> ok) { + return Objects.equals(ok.okValue, this.okValue); + } + return false; + } + } + + record Fail<Good, Bad>(@Nullable Good partialValue, List<Bad> badValue) implements Result<Good, Bad> { + public Fail { + if (badValue.isEmpty()) + throw new IllegalArgumentException("Cannot create failure without any error values"); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) return true; + if (obj instanceof Result.Fail<?, ?> fail) { + return Objects.equals(partialValue, fail.partialValue) && badValue.equals(fail.badValue); + } + return false; + } + + @Override + public int hashCode() { + return Objects.hash(partialValue, badValue); + } + + @Override + public Optional<Good> value() { + return Optional.empty(); + } + + @Override + public Optional<Good> partial() { + return Optional.ofNullable(partialValue); + } + + @Override + public List<Bad> errors() { + return Collections.unmodifiableList(badValue); + } + + @Override + public <Next> Result<Next, Bad> flatMap(Function<Good, Result<? extends Next, ? extends Bad>> mapper) { + if (partialValue != null) { + return Result.<Next, Bad>cast(mapper.apply(partialValue)).appendErrors(badValue); + } + return new Fail<>(null, badValue); + } + + @Override + public <NextBad> Result<Good, NextBad> mapErrors(Function<List<Bad>, List<NextBad>> mapper) { + return new Fail<>(partialValue, mapper.apply(badValue)); + } + + @Override + public Result<Good, Bad> appendErrors(List<Bad> errors) { + var nextErrors = new ArrayList<>(badValue); + nextErrors.addAll(errors); + return new Fail<>(partialValue, nextErrors); + } + } + + static <Good, Bad> Result<Good, Bad> ok(Good value) { + return new Ok<>(value); + } + + static <Good, Bad> Result.Fail<Good, Bad> fail(Bad error) { + return new Fail<>(null, List.of(error)); + } + + + static <Good, Bad> Result<Good, Bad> cast(Result<? extends Good, ? extends Bad> c) { + //noinspection unchecked + return (Result<Good, Bad>) c; + } + + static <Good, Bad> Result.Fail<Good, Bad> partial(@Nullable Good partial, Bad error) { + return new Fail<>(partial, List.of(error)); + } +} diff --git a/core/src/main/java/moe/nea/pcj/Tuple.java b/core/src/main/java/moe/nea/pcj/Tuple.java new file mode 100644 index 0000000..e6207ff --- /dev/null +++ b/core/src/main/java/moe/nea/pcj/Tuple.java @@ -0,0 +1,1030 @@ +// @generated by gentuples.ts +package moe.nea.pcj; + +@SuppressWarnings("unused") +public interface Tuple { + class Tuple0 implements Tuple { + public <R> R applyTo(Func0<R> func) { + return func.apply(); + } + + public static <R> Result<Tuple0, R> collect(Tuple0 tuple) { + return + Result.ok(new Tuple0()) + ; + } + + public Tuple0 map() { + return new Tuple0(); + } + + public Tuple0 join(Tuple0 other) { + return new Tuple0(); + } + + public <E0> Tuple1<E0> join(Tuple1<E0> other) { + return new Tuple1<>(other.element0); + } + + public <E0, E1> Tuple2<E0, E1> join(Tuple2<E0, E1> other) { + return new Tuple2<>(other.element0, other.element1); + } + + public <E0, E1, E2> Tuple3<E0, E1, E2> join(Tuple3<E0, E1, E2> other) { + return new Tuple3<>(other.element0, other.element1, other.element2); + } + + public <E0, E1, E2, E3> Tuple4<E0, E1, E2, E3> join(Tuple4<E0, E1, E2, E3> other) { + return new Tuple4<>(other.element0, other.element1, other.element2, other.element3); + } + + public <E0, E1, E2, E3, E4> Tuple5<E0, E1, E2, E3, E4> join(Tuple5<E0, E1, E2, E3, E4> other) { + return new Tuple5<>(other.element0, other.element1, other.element2, other.element3, other.element4); + } + + public <E0, E1, E2, E3, E4, E5> Tuple6<E0, E1, E2, E3, E4, E5> join(Tuple6<E0, E1, E2, E3, E4, E5> other) { + return new Tuple6<>(other.element0, other.element1, other.element2, other.element3, other.element4, other.element5); + } + + public <E0, E1, E2, E3, E4, E5, E6> Tuple7<E0, E1, E2, E3, E4, E5, E6> join(Tuple7<E0, E1, E2, E3, E4, E5, E6> other) { + return new Tuple7<>(other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6); + } + + public <E0, E1, E2, E3, E4, E5, E6, E7> Tuple8<E0, E1, E2, E3, E4, E5, E6, E7> join(Tuple8<E0, E1, E2, E3, E4, E5, E6, E7> other) { + return new Tuple8<>(other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7); + } + + public <E0, E1, E2, E3, E4, E5, E6, E7, E8> Tuple9<E0, E1, E2, E3, E4, E5, E6, E7, E8> join(Tuple9<E0, E1, E2, E3, E4, E5, E6, E7, E8> other) { + return new Tuple9<>(other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8); + } + + public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> Tuple10<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> join(Tuple10<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> other) { + return new Tuple10<>(other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9); + } + + public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> Tuple11<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> join(Tuple11<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> other) { + return new Tuple11<>(other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9, other.element10); + } + + public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11> Tuple12<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11> join(Tuple12<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11> other) { + return new Tuple12<>(other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9, other.element10, other.element11); + } + + public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11, E12> Tuple13<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11, E12> join(Tuple13<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11, E12> other) { + return new Tuple13<>(other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9, other.element10, other.element11, other.element12); + } + + public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11, E12, E13> Tuple14<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11, E12, E13> join(Tuple14<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11, E12, E13> other) { + return new Tuple14<>(other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9, other.element10, other.element11, other.element12, other.element13); + } + } + + @FunctionalInterface + interface Func0<R> { + R apply(); + } + + record Tuple1<T0>(T0 element0) { + public <R> R applyTo(Func1<R, T0> func) { + return func.apply(this.element0); + } + + public static <R, T0> Result<Tuple1<T0>, R> collect(Tuple1<Result<T0, R>> tuple) { + return + tuple.element0.flatMap(element0 -> + Result.ok(new Tuple1<>(element0)) + ) + ; + } + + public <E0> Tuple1<E0> map(Func1<E0, T0> map0) { + return new Tuple1<>(map0.apply(this.element0)); + } + + public Tuple1<T0> join(Tuple0 other) { + return new Tuple1<>(this.element0); + } + + public <E0> Tuple2<T0, E0> join(Tuple1<E0> other) { + return new Tuple2<>(this.element0, other.element0); + } + + public <E0, E1> Tuple3<T0, E0, E1> join(Tuple2<E0, E1> other) { + return new Tuple3<>(this.element0, other.element0, other.element1); + } + + public <E0, E1, E2> Tuple4<T0, E0, E1, E2> join(Tuple3<E0, E1, E2> other) { + return new Tuple4<>(this.element0, other.element0, other.element1, other.element2); + } + + public <E0, E1, E2, E3> Tuple5<T0, E0, E1, E2, E3> join(Tuple4<E0, E1, E2, E3> other) { + return new Tuple5<>(this.element0, other.element0, other.element1, other.element2, other.element3); + } + + public <E0, E1, E2, E3, E4> Tuple6<T0, E0, E1, E2, E3, E4> join(Tuple5<E0, E1, E2, E3, E4> other) { + return new Tuple6<>(this.element0, other.element0, other.element1, other.element2, other.element3, other.element4); + } + + public <E0, E1, E2, E3, E4, E5> Tuple7<T0, E0, E1, E2, E3, E4, E5> join(Tuple6<E0, E1, E2, E3, E4, E5> other) { + return new Tuple7<>(this.element0, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5); + } + + public <E0, E1, E2, E3, E4, E5, E6> Tuple8<T0, E0, E1, E2, E3, E4, E5, E6> join(Tuple7<E0, E1, E2, E3, E4, E5, E6> other) { + return new Tuple8<>(this.element0, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6); + } + + public <E0, E1, E2, E3, E4, E5, E6, E7> Tuple9<T0, E0, E1, E2, E3, E4, E5, E6, E7> join(Tuple8<E0, E1, E2, E3, E4, E5, E6, E7> other) { + return new Tuple9<>(this.element0, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7); + } + + public <E0, E1, E2, E3, E4, E5, E6, E7, E8> Tuple10<T0, E0, E1, E2, E3, E4, E5, E6, E7, E8> join(Tuple9<E0, E1, E2, E3, E4, E5, E6, E7, E8> other) { + return new Tuple10<>(this.element0, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8); + } + + public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> Tuple11<T0, E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> join(Tuple10<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> other) { + return new Tuple11<>(this.element0, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9); + } + + public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> Tuple12<T0, E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> join(Tuple11<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> other) { + return new Tuple12<>(this.element0, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9, other.element10); + } + + public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11> Tuple13<T0, E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11> join(Tuple12<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11> other) { + return new Tuple13<>(this.element0, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9, other.element10, other.element11); + } + + public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11, E12> Tuple14<T0, E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11, E12> join(Tuple13<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11, E12> other) { + return new Tuple14<>(this.element0, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9, other.element10, other.element11, other.element12); + } + } + + @FunctionalInterface + interface Func1<R, T0> { + R apply(T0 arg0); + } + + record Tuple2<T0, T1>(T0 element0, T1 element1) { + public <R> R applyTo(Func2<R, T0, T1> func) { + return func.apply(this.element0, this.element1); + } + + public static <R, T0, T1> Result<Tuple2<T0, T1>, R> collect(Tuple2<Result<T0, R>, Result<T1, R>> tuple) { + return + tuple.element0.flatMap(element0 -> + tuple.element1.flatMap(element1 -> + Result.ok(new Tuple2<>(element0, element1)) + ) + ) + ; + } + + public <E0, E1> Tuple2<E0, E1> map(Func1<E0, T0> map0, Func1<E1, T1> map1) { + return new Tuple2<>(map0.apply(this.element0), map1.apply(this.element1)); + } + + public Tuple2<T0, T1> join(Tuple0 other) { + return new Tuple2<>(this.element0, this.element1); + } + + public <E0> Tuple3<T0, T1, E0> join(Tuple1<E0> other) { + return new Tuple3<>(this.element0, this.element1, other.element0); + } + + public <E0, E1> Tuple4<T0, T1, E0, E1> join(Tuple2<E0, E1> other) { + return new Tuple4<>(this.element0, this.element1, other.element0, other.element1); + } + + public <E0, E1, E2> Tuple5<T0, T1, E0, E1, E2> join(Tuple3<E0, E1, E2> other) { + return new Tuple5<>(this.element0, this.element1, other.element0, other.element1, other.element2); + } + + public <E0, E1, E2, E3> Tuple6<T0, T1, E0, E1, E2, E3> join(Tuple4<E0, E1, E2, E3> other) { + return new Tuple6<>(this.element0, this.element1, other.element0, other.element1, other.element2, other.element3); + } + + public <E0, E1, E2, E3, E4> Tuple7<T0, T1, E0, E1, E2, E3, E4> join(Tuple5<E0, E1, E2, E3, E4> other) { + return new Tuple7<>(this.element0, this.element1, other.element0, other.element1, other.element2, other.element3, other.element4); + } + + public <E0, E1, E2, E3, E4, E5> Tuple8<T0, T1, E0, E1, E2, E3, E4, E5> join(Tuple6<E0, E1, E2, E3, E4, E5> other) { + return new Tuple8<>(this.element0, this.element1, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5); + } + + public <E0, E1, E2, E3, E4, E5, E6> Tuple9<T0, T1, E0, E1, E2, E3, E4, E5, E6> join(Tuple7<E0, E1, E2, E3, E4, E5, E6> other) { + return new Tuple9<>(this.element0, this.element1, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6); + } + + public <E0, E1, E2, E3, E4, E5, E6, E7> Tuple10<T0, T1, E0, E1, E2, E3, E4, E5, E6, E7> join(Tuple8<E0, E1, E2, E3, E4, E5, E6, E7> other) { + return new Tuple10<>(this.element0, this.element1, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7); + } + + public <E0, E1, E2, E3, E4, E5, E6, E7, E8> Tuple11<T0, T1, E0, E1, E2, E3, E4, E5, E6, E7, E8> join(Tuple9<E0, E1, E2, E3, E4, E5, E6, E7, E8> other) { + return new Tuple11<>(this.element0, this.element1, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8); + } + + public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> Tuple12<T0, T1, E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> join(Tuple10<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> other) { + return new Tuple12<>(this.element0, this.element1, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9); + } + + public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> Tuple13<T0, T1, E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> join(Tuple11<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> other) { + return new Tuple13<>(this.element0, this.element1, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9, other.element10); + } + + public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11> Tuple14<T0, T1, E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11> join(Tuple12<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11> other) { + return new Tuple14<>(this.element0, this.element1, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9, other.element10, other.element11); + } + } + + @FunctionalInterface + interface Func2<R, T0, T1> { + R apply(T0 arg0, T1 arg1); + } + + record Tuple3<T0, T1, T2>(T0 element0, T1 element1, T2 element2) { + public <R> R applyTo(Func3<R, T0, T1, T2> func) { + return func.apply(this.element0, this.element1, this.element2); + } + + public static <R, T0, T1, T2> Result<Tuple3<T0, T1, T2>, R> collect(Tuple3<Result<T0, R>, Result<T1, R>, Result<T2, R>> tuple) { + return + tuple.element0.flatMap(element0 -> + tuple.element1.flatMap(element1 -> + tuple.element2.flatMap(element2 -> + Result.ok(new Tuple3<>(element0, element1, element2)) + ) + ) + ) + ; + } + + public <E0, E1, E2> Tuple3<E0, E1, E2> map(Func1<E0, T0> map0, Func1<E1, T1> map1, Func1<E2, T2> map2) { + return new Tuple3<>(map0.apply(this.element0), map1.apply(this.element1), map2.apply(this.element2)); + } + + public Tuple3<T0, T1, T2> join(Tuple0 other) { + return new Tuple3<>(this.element0, this.element1, this.element2); + } + + public <E0> Tuple4<T0, T1, T2, E0> join(Tuple1<E0> other) { + return new Tuple4<>(this.element0, this.element1, this.element2, other.element0); + } + + public <E0, E1> Tuple5<T0, T1, T2, E0, E1> join(Tuple2<E0, E1> other) { + return new Tuple5<>(this.element0, this.element1, this.element2, other.element0, other.element1); + } + + public <E0, E1, E2> Tuple6<T0, T1, T2, E0, E1, E2> join(Tuple3<E0, E1, E2> other) { + return new Tuple6<>(this.element0, this.element1, this.element2, other.element0, other.element1, other.element2); + } + + public <E0, E1, E2, E3> Tuple7<T0, T1, T2, E0, E1, E2, E3> join(Tuple4<E0, E1, E2, E3> other) { + return new Tuple7<>(this.element0, this.element1, this.element2, other.element0, other.element1, other.element2, other.element3); + } + + public <E0, E1, E2, E3, E4> Tuple8<T0, T1, T2, E0, E1, E2, E3, E4> join(Tuple5<E0, E1, E2, E3, E4> other) { + return new Tuple8<>(this.element0, this.element1, this.element2, other.element0, other.element1, other.element2, other.element3, other.element4); + } + + public <E0, E1, E2, E3, E4, E5> Tuple9<T0, T1, T2, E0, E1, E2, E3, E4, E5> join(Tuple6<E0, E1, E2, E3, E4, E5> other) { + return new Tuple9<>(this.element0, this.element1, this.element2, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5); + } + + public <E0, E1, E2, E3, E4, E5, E6> Tuple10<T0, T1, T2, E0, E1, E2, E3, E4, E5, E6> join(Tuple7<E0, E1, E2, E3, E4, E5, E6> other) { + return new Tuple10<>(this.element0, this.element1, this.element2, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6); + } + + public <E0, E1, E2, E3, E4, E5, E6, E7> Tuple11<T0, T1, T2, E0, E1, E2, E3, E4, E5, E6, E7> join(Tuple8<E0, E1, E2, E3, E4, E5, E6, E7> other) { + return new Tuple11<>(this.element0, this.element1, this.element2, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7); + } + + public <E0, E1, E2, E3, E4, E5, E6, E7, E8> Tuple12<T0, T1, T2, E0, E1, E2, E3, E4, E5, E6, E7, E8> join(Tuple9<E0, E1, E2, E3, E4, E5, E6, E7, E8> other) { + return new Tuple12<>(this.element0, this.element1, this.element2, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8); + } + + public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> Tuple13<T0, T1, T2, E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> join(Tuple10<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> other) { + return new Tuple13<>(this.element0, this.element1, this.element2, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9); + } + + public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> Tuple14<T0, T1, T2, E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> join(Tuple11<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> other) { + return new Tuple14<>(this.element0, this.element1, this.element2, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9, other.element10); + } + } + + @FunctionalInterface + interface Func3<R, T0, T1, T2> { + R apply(T0 arg0, T1 arg1, T2 arg2); + } + + record Tuple4<T0, T1, T2, T3>(T0 element0, T1 element1, T2 element2, T3 element3) { + public <R> R applyTo(Func4<R, T0, T1, T2, T3> func) { + return func.apply(this.element0, this.element1, this.element2, this.element3); + } + + public static <R, T0, T1, T2, T3> Result<Tuple4<T0, T1, T2, T3>, R> collect(Tuple4<Result<T0, R>, Result<T1, R>, Result<T2, R>, Result<T3, R>> tuple) { + return + tuple.element0.flatMap(element0 -> + tuple.element1.flatMap(element1 -> + tuple.element2.flatMap(element2 -> + tuple.element3.flatMap(element3 -> + Result.ok(new Tuple4<>(element0, element1, element2, element3)) + ) + ) + ) + ) + ; + } + + public <E0, E1, E2, E3> Tuple4<E0, E1, E2, E3> map(Func1<E0, T0> map0, Func1<E1, T1> map1, Func1<E2, T2> map2, Func1<E3, T3> map3) { + return new Tuple4<>(map0.apply(this.element0), map1.apply(this.element1), map2.apply(this.element2), map3.apply(this.element3)); + } + + public Tuple4<T0, T1, T2, T3> join(Tuple0 other) { + return new Tuple4<>(this.element0, this.element1, this.element2, this.element3); + } + + public <E0> Tuple5<T0, T1, T2, T3, E0> join(Tuple1<E0> other) { + return new Tuple5<>(this.element0, this.element1, this.element2, this.element3, other.element0); + } + + public <E0, E1> Tuple6<T0, T1, T2, T3, E0, E1> join(Tuple2<E0, E1> other) { + return new Tuple6<>(this.element0, this.element1, this.element2, this.element3, other.element0, other.element1); + } + + public <E0, E1, E2> Tuple7<T0, T1, T2, T3, E0, E1, E2> join(Tuple3<E0, E1, E2> other) { + return new Tuple7<>(this.element0, this.element1, this.element2, this.element3, other.element0, other.element1, other.element2); + } + + public <E0, E1, E2, E3> Tuple8<T0, T1, T2, T3, E0, E1, E2, E3> join(Tuple4<E0, E1, E2, E3> other) { + return new Tuple8<>(this.element0, this.element1, this.element2, this.element3, other.element0, other.element1, other.element2, other.element3); + } + + public <E0, E1, E2, E3, E4> Tuple9<T0, T1, T2, T3, E0, E1, E2, E3, E4> join(Tuple5<E0, E1, E2, E3, E4> other) { + return new Tuple9<>(this.element0, this.element1, this.element2, this.element3, other.element0, other.element1, other.element2, other.element3, other.element4); + } + + public <E0, E1, E2, E3, E4, E5> Tuple10<T0, T1, T2, T3, E0, E1, E2, E3, E4, E5> join(Tuple6<E0, E1, E2, E3, E4, E5> other) { + return new Tuple10<>(this.element0, this.element1, this.element2, this.element3, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5); + } + + public <E0, E1, E2, E3, E4, E5, E6> Tuple11<T0, T1, T2, T3, E0, E1, E2, E3, E4, E5, E6> join(Tuple7<E0, E1, E2, E3, E4, E5, E6> other) { + return new Tuple11<>(this.element0, this.element1, this.element2, this.element3, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6); + } + + public <E0, E1, E2, E3, E4, E5, E6, E7> Tuple12<T0, T1, T2, T3, E0, E1, E2, E3, E4, E5, E6, E7> join(Tuple8<E0, E1, E2, E3, E4, E5, E6, E7> other) { + return new Tuple12<>(this.element0, this.element1, this.element2, this.element3, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7); + } + + public <E0, E1, E2, E3, E4, E5, E6, E7, E8> Tuple13<T0, T1, T2, T3, E0, E1, E2, E3, E4, E5, E6, E7, E8> join(Tuple9<E0, E1, E2, E3, E4, E5, E6, E7, E8> other) { + return new Tuple13<>(this.element0, this.element1, this.element2, this.element3, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.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/core/src/main/java/moe/nea/pcj/Unit.java b/core/src/main/java/moe/nea/pcj/Unit.java new file mode 100644 index 0000000..435d763 --- /dev/null +++ b/core/src/main/java/moe/nea/pcj/Unit.java @@ -0,0 +1,5 @@ +package moe.nea.pcj; + +public enum Unit { + INSTANCE; +} diff --git a/core/src/main/java/moe/nea/pcj/json/AtField.java b/core/src/main/java/moe/nea/pcj/json/AtField.java new file mode 100644 index 0000000..3780e38 --- /dev/null +++ b/core/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/core/src/main/java/moe/nea/pcj/json/AtIndex.java b/core/src/main/java/moe/nea/pcj/json/AtIndex.java new file mode 100644 index 0000000..ec01112 --- /dev/null +++ b/core/src/main/java/moe/nea/pcj/json/AtIndex.java @@ -0,0 +1,4 @@ +package moe.nea.pcj.json; + +public record AtIndex(int index, JsonLikeError error) implements JsonLikeError { +} diff --git a/core/src/main/java/moe/nea/pcj/json/BasicCodecs.java b/core/src/main/java/moe/nea/pcj/json/BasicCodecs.java new file mode 100644 index 0000000..565711d --- /dev/null +++ b/core/src/main/java/moe/nea/pcj/json/BasicCodecs.java @@ -0,0 +1,47 @@ +package moe.nea.pcj.json; + +import moe.nea.pcj.Result; + +public class BasicCodecs<Format> { + protected BasicCodecs() {} + + public static <Format> BasicCodecs<Format> create() { + return new BasicCodecs<>(); + } + + public final JsonCodec<String, Format> STRING = new JsonCodec<>() { + @Override + public Result<String, ? extends JsonLikeError> decode(Format format, JsonLikeOperations<Format> ops) { + return ops.getString(format); + } + + @Override + public Result<Format, ? extends JsonLikeError> encode(String data, JsonLikeOperations<Format> ops) { + return Result.ok(ops.createString(data)); + } + }; + + public final JsonCodec<Float, Format> FLOAT = new JsonCodec<Float, Format>() { + @Override + public Result<? extends Float, ? extends JsonLikeError> decode(Format format, JsonLikeOperations<Format> ops) { + return ops.getNumeric(format).map(Number::floatValue); + } + + @Override + public Result<? extends Format, ? extends JsonLikeError> encode(Float data, JsonLikeOperations<Format> ops) { + return Result.ok(ops.createNumeric(data)); + } + }; + + public final JsonCodec<Integer, Format> INTEGER = new JsonCodec<>() { + @Override + public Result<? extends Integer, ? extends JsonLikeError> decode(Format format, JsonLikeOperations<Format> ops) { + return ops.getNumeric(format).map(Number::intValue); // TODO: filter for valid ints + } + + @Override + public Result<? extends Format, ? extends JsonLikeError> encode(Integer data, JsonLikeOperations<Format> ops) { + return Result.ok(ops.createNumeric(data)); + } + }; +}
\ No newline at end of file diff --git a/core/src/main/java/moe/nea/pcj/json/DuplicateJsonKey.java b/core/src/main/java/moe/nea/pcj/json/DuplicateJsonKey.java new file mode 100644 index 0000000..13d81db --- /dev/null +++ b/core/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/core/src/main/java/moe/nea/pcj/json/DuringKeyExtraction.java b/core/src/main/java/moe/nea/pcj/json/DuringKeyExtraction.java new file mode 100644 index 0000000..859f98f --- /dev/null +++ b/core/src/main/java/moe/nea/pcj/json/DuringKeyExtraction.java @@ -0,0 +1,4 @@ +package moe.nea.pcj.json; + +public record DuringKeyExtraction(JsonLikeError error) implements JsonLikeError { +} diff --git a/core/src/main/java/moe/nea/pcj/json/InSubType.java b/core/src/main/java/moe/nea/pcj/json/InSubType.java new file mode 100644 index 0000000..ae62a73 --- /dev/null +++ b/core/src/main/java/moe/nea/pcj/json/InSubType.java @@ -0,0 +1,4 @@ +package moe.nea.pcj.json; + +public record InSubType<T>(T typeTag, JsonLikeError error) implements JsonLikeError { +} diff --git a/core/src/main/java/moe/nea/pcj/json/JsonCodec.java b/core/src/main/java/moe/nea/pcj/json/JsonCodec.java new file mode 100644 index 0000000..c5c750b --- /dev/null +++ b/core/src/main/java/moe/nea/pcj/json/JsonCodec.java @@ -0,0 +1,84 @@ +package moe.nea.pcj.json; + +import moe.nea.pcj.Codec; +import moe.nea.pcj.Result; + +import java.util.ArrayList; +import java.util.List; + +public interface JsonCodec<T, Format> extends Codec< + T, Format, JsonLikeOperations<Format>, + JsonLikeError, JsonLikeError> { + + default JsonCodec<List<T>, Format> listOf() { + return new JsonCodec<>() { + @Override + public Result<Format, JsonLikeError> encode(List<T> data, JsonLikeOperations<Format> ops) { + var list = ops.createList(); + var erros = new ArrayList<JsonLikeError>(); + for (int i = 0; i < data.size(); i++) { + var datum = data.get(i); + final var index = i; + var result = JsonCodec.this.encode(datum, ops) + .mapError(it -> new AtIndex(index, it)); + erros.addAll(result.errors()); + result.valueOrPartial().ifPresent(list::add); + } + return Result.<Format, JsonLikeError>ok(list.complete()).appendErrors(erros); + } + + @Override + public Result<List<T>, JsonLikeError> decode(Format format, JsonLikeOperations<Format> ops) { + var view = Result.<ListView<Format>, JsonLikeError>cast(ops.getList(format)); + return view.flatMap(elements -> { + var acc = new ArrayList<T>(elements.length()); + var errors = new ArrayList<JsonLikeError>(); + for (int i = 0; i < elements.length(); i++) { + final var index = i; + var result = JsonCodec.this.decode(elements.getUnsafe(i), ops) + .mapError(it -> new AtIndex(index, it)); + errors.addAll(result.errors()); + result.valueOrPartial().ifPresent(acc::add); + } + return Result.<List<T>, JsonLikeError>ok(acc).appendErrors(errors); + }); + } + }; + } + + default JsonCodec<T, Format> named(String name) { + return new JsonCodec<>() { + @Override + public Result<? extends T, JsonLikeError> decode(Format format, JsonLikeOperations<Format> ops) { + return JsonCodec.this.decode(format, ops).mapError(it -> new NamedObject(name, it)); + } + + @Override + public Result<? extends Format, JsonLikeError> encode(T data, JsonLikeOperations<Format> ops) { + return JsonCodec.this.encode(data, ops).mapError(it -> new NamedObject(name, it)); + } + }; + } + + default MapCodec<T, Format> fieldOf(String key) { + return new MapCodec<>() { + @Override + public Result<T, JsonLikeError> decode(RecordView<Format> record, JsonLikeOperations<Format> ops) { + return record.get(key) + .map(element -> Result.<T, JsonLikeError>cast( + JsonCodec.this.decode(element, ops) + .mapError(it -> new AtField(key, it)))) + .orElseGet(() -> Result.fail(new MissingKey(key))); + } + + @Override + public Result<RecordBuilder<Format>, JsonLikeError> encode(T value, JsonLikeOperations<Format> ops) { + var record = ops.createObject(); + return Result.<Format, JsonLikeError>cast(JsonCodec.this.encode(value, ops)) + .<JsonLikeError>mapError(it -> new AtField(key, it)) + .flatMap(json -> Result.cast(record.add(key, json).map(unit -> record))); + } + + }; + } +} diff --git a/core/src/main/java/moe/nea/pcj/json/JsonLikeError.java b/core/src/main/java/moe/nea/pcj/json/JsonLikeError.java new file mode 100644 index 0000000..609bd84 --- /dev/null +++ b/core/src/main/java/moe/nea/pcj/json/JsonLikeError.java @@ -0,0 +1,4 @@ +package moe.nea.pcj.json; + +public interface JsonLikeError { +} diff --git a/core/src/main/java/moe/nea/pcj/json/JsonLikeOperations.java b/core/src/main/java/moe/nea/pcj/json/JsonLikeOperations.java new file mode 100644 index 0000000..ffefeda --- /dev/null +++ b/core/src/main/java/moe/nea/pcj/json/JsonLikeOperations.java @@ -0,0 +1,32 @@ +package moe.nea.pcj.json; + +import moe.nea.pcj.Operation; +import moe.nea.pcj.Result; +import moe.nea.pcj.Unit; + +public interface JsonLikeOperations<Format> extends Operation<Format> { + + Format createNull(Unit value); + + Result<Unit, ? extends JsonLikeError> getNull(Format element); + + Format createNumeric(Number value); + + Result<Number, ? extends JsonLikeError> getNumeric(Format element); + + Format createString(String value); + + Result<String, ? extends JsonLikeError> getString(Format element); + + Format createBoolean(boolean value); + + Result<Boolean, ? extends JsonLikeError> getBoolean(Format format); + + RecordBuilder<Format> createObject(); + + Result<? extends RecordView<Format>, ? extends JsonLikeError> getObject(Format format); + + ListBuilder<Format> createList(); + + Result<? extends ListView<Format>, ? extends JsonLikeError> getList(Format format); +} diff --git a/core/src/main/java/moe/nea/pcj/json/ListBuilder.java b/core/src/main/java/moe/nea/pcj/json/ListBuilder.java new file mode 100644 index 0000000..fd2a407 --- /dev/null +++ b/core/src/main/java/moe/nea/pcj/json/ListBuilder.java @@ -0,0 +1,9 @@ +package moe.nea.pcj.json; + +public interface ListBuilder<ElementFormat> extends ListView<ElementFormat> { + ElementFormat complete(); + + void add(ElementFormat value); + + void set(int index, ElementFormat value); +} diff --git a/core/src/main/java/moe/nea/pcj/json/ListView.java b/core/src/main/java/moe/nea/pcj/json/ListView.java new file mode 100644 index 0000000..dcc6e37 --- /dev/null +++ b/core/src/main/java/moe/nea/pcj/json/ListView.java @@ -0,0 +1,14 @@ +package moe.nea.pcj.json; + +import java.util.Optional; + +public interface ListView<Format> { + int length(); + + default Optional<Format> getSafe(int index) { + if (index < 0 || index >= length()) return Optional.empty(); + return Optional.of(getUnsafe(index)); + } + + Format getUnsafe(int index); +} diff --git a/core/src/main/java/moe/nea/pcj/json/MapCodec.java b/core/src/main/java/moe/nea/pcj/json/MapCodec.java new file mode 100644 index 0000000..9f343fd --- /dev/null +++ b/core/src/main/java/moe/nea/pcj/json/MapCodec.java @@ -0,0 +1,64 @@ +package moe.nea.pcj.json; + +import moe.nea.pcj.Result; + +import java.util.function.Function; + +public interface MapCodec<T, Format> { + Result<? extends T, JsonLikeError> decode( + RecordView<Format> record, + JsonLikeOperations<Format> ops); + + Result<RecordBuilder<Format>, JsonLikeError> encode(T value, JsonLikeOperations<Format> ops); + + default <O> MapCodec<? extends O, Format> dispatch( + Function<? super O, ? extends T> keyExtractor, + Function<? super T, Result<? extends MapCodec<? extends O, Format>, ? extends JsonLikeError>> codecGenerator + ) { + // TODO: the codecGenerator function is not exactly typesafe. there should be some limit on keyExtractor and codecGenerator working in tandem + return new MapCodec<>() { + @Override + public Result<O, JsonLikeError> decode(RecordView<Format> record, JsonLikeOperations<Format> ops) { // TODO: map errors + return MapCodec.this.decode(record, ops) + .flatMap(key -> codecGenerator + .apply(key) + .<JsonLikeError>mapError(DuringKeyExtraction::new) + .flatMap(codec -> codec.decode(record, ops) + .<JsonLikeError>mapError(it -> new InSubType<>(key, it)))); + } + + @Override + public Result<RecordBuilder<Format>, JsonLikeError> encode(O value, JsonLikeOperations<Format> ops) { + var key = keyExtractor.apply(value); + return Result.<MapCodec<? extends O, Format>, JsonLikeError>cast( + codecGenerator.apply(key) + .mapError(DuringKeyExtraction::new)) + .flatMap(codec -> MapCodec.this + .encode(key, ops) + .flatMap(keyEncoded -> ((MapCodec<O, Format>) codec) + .encode(value, ops) + .<JsonLikeError>mapError(it -> new InSubType<>(key, it)) + .flatMap(keyEncoded::mergeWith))); + } + }; + } + + default JsonCodec<T, Format> codec() { + return new JsonCodec<>() { + @Override + public Result<? extends T, ? extends JsonLikeError> decode(Format format, JsonLikeOperations<Format> ops) { + return Result.<RecordView<Format>, JsonLikeError>cast(ops.getObject(format)) + .flatMap(record -> MapCodec.this.decode(record, ops)); + } + + @Override + public Result<? extends Format, ? extends JsonLikeError> encode(T data, JsonLikeOperations<Format> ops) { + return Result.cast(MapCodec.this.encode(data, ops)).map(RecordBuilder::complete); + } + }; + } + + default <O> RecordCodec<O, T, Format> withGetter(Function<O, T> getter) { + return new RecordCodec<>(this, getter); + } +} diff --git a/core/src/main/java/moe/nea/pcj/json/MissingKey.java b/core/src/main/java/moe/nea/pcj/json/MissingKey.java new file mode 100644 index 0000000..3dad05c --- /dev/null +++ b/core/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/core/src/main/java/moe/nea/pcj/json/NamedObject.java b/core/src/main/java/moe/nea/pcj/json/NamedObject.java new file mode 100644 index 0000000..aedc87b --- /dev/null +++ b/core/src/main/java/moe/nea/pcj/json/NamedObject.java @@ -0,0 +1,4 @@ +package moe.nea.pcj.json; + +public record NamedObject(String name, JsonLikeError error) implements JsonLikeError { +} diff --git a/core/src/main/java/moe/nea/pcj/json/RecordBuilder.java b/core/src/main/java/moe/nea/pcj/json/RecordBuilder.java new file mode 100644 index 0000000..c610f27 --- /dev/null +++ b/core/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/core/src/main/java/moe/nea/pcj/json/RecordCodec.java b/core/src/main/java/moe/nea/pcj/json/RecordCodec.java new file mode 100644 index 0000000..fa7aac7 --- /dev/null +++ b/core/src/main/java/moe/nea/pcj/json/RecordCodec.java @@ -0,0 +1,23 @@ +package moe.nea.pcj.json; + +import moe.nea.pcj.Result; + +import java.util.function.Function; + +public record RecordCodec<O, T, Format>( + MapCodec<T, Format> codec, + Function<O, T> getter +) { + + Result<RecordBuilder<Format>, JsonLikeError> enc(O data, JsonLikeOperations<Format> ops) { + return codec().encode(getter().apply(data), ops); + } + + Result<T, JsonLikeError> dec(RecordView<Format> data, JsonLikeOperations<Format> ops) { + return Result.cast(codec().decode(data, ops)); + } + + static <Format> Result<RecordBuilder<Format>, JsonLikeError> merge(Result<RecordBuilder<Format>, JsonLikeError> left, Result<RecordBuilder<Format>, JsonLikeError> right) { + return left.flatMap(l -> right.flatMap(l::mergeWith)); + } +} diff --git a/core/src/main/java/moe/nea/pcj/json/RecordJoiners.java b/core/src/main/java/moe/nea/pcj/json/RecordJoiners.java new file mode 100644 index 0000000..57bdd63 --- /dev/null +++ b/core/src/main/java/moe/nea/pcj/json/RecordJoiners.java @@ -0,0 +1,338 @@ +// @generated by genrecord.ts +package moe.nea.pcj.json; + +import moe.nea.pcj.*; +import java.util.stream.*; + +@SuppressWarnings("unused") +public class RecordJoiners { + public static <T0, O, Format> MapCodec<O, Format> join( + RecordCodec<O, T0, Format> arg0, + Tuple.Func1<O, T0> joiner + ) { + return new MapCodec<>() { + @Override + public Result<RecordBuilder<Format>, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) { + return Stream.of(arg0.enc(data, ops)) + .reduce(Result.ok(ops.createObject()), RecordCodec::merge); + } + @Override + public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) { + return Tuple.Tuple1.collect(new Tuple.Tuple1<>(arg0.dec(format, ops))) + .map(it -> it.applyTo(joiner)); + } + }; + } + public static <T0, T1, O, Format> MapCodec<O, Format> join( + RecordCodec<O, T0, Format> arg0, + RecordCodec<O, T1, Format> arg1, + Tuple.Func2<O, T0, T1> joiner + ) { + return new MapCodec<>() { + @Override + public Result<RecordBuilder<Format>, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) { + return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops)) + .reduce(Result.ok(ops.createObject()), RecordCodec::merge); + } + @Override + public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) { + return Tuple.Tuple2.collect(new Tuple.Tuple2<>(arg0.dec(format, ops), arg1.dec(format, ops))) + .map(it -> it.applyTo(joiner)); + } + }; + } + public static <T0, T1, T2, O, Format> MapCodec<O, Format> join( + RecordCodec<O, T0, Format> arg0, + RecordCodec<O, T1, Format> arg1, + RecordCodec<O, T2, Format> arg2, + Tuple.Func3<O, T0, T1, T2> joiner + ) { + return new MapCodec<>() { + @Override + public Result<RecordBuilder<Format>, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) { + return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops), arg2.enc(data, ops)) + .reduce(Result.ok(ops.createObject()), RecordCodec::merge); + } + @Override + public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) { + return Tuple.Tuple3.collect(new Tuple.Tuple3<>(arg0.dec(format, ops), arg1.dec(format, ops), arg2.dec(format, ops))) + .map(it -> it.applyTo(joiner)); + } + }; + } + public static <T0, T1, T2, T3, O, Format> MapCodec<O, Format> join( + RecordCodec<O, T0, Format> arg0, + RecordCodec<O, T1, Format> arg1, + RecordCodec<O, T2, Format> arg2, + RecordCodec<O, T3, Format> arg3, + Tuple.Func4<O, T0, T1, T2, T3> joiner + ) { + return new MapCodec<>() { + @Override + public Result<RecordBuilder<Format>, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) { + return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops), arg2.enc(data, ops), arg3.enc(data, ops)) + .reduce(Result.ok(ops.createObject()), RecordCodec::merge); + } + @Override + public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) { + return Tuple.Tuple4.collect(new Tuple.Tuple4<>(arg0.dec(format, ops), arg1.dec(format, ops), arg2.dec(format, ops), arg3.dec(format, ops))) + .map(it -> it.applyTo(joiner)); + } + }; + } + public static <T0, T1, T2, T3, T4, O, Format> MapCodec<O, Format> join( + RecordCodec<O, T0, Format> arg0, + RecordCodec<O, T1, Format> arg1, + RecordCodec<O, T2, Format> arg2, + RecordCodec<O, T3, Format> arg3, + RecordCodec<O, T4, Format> arg4, + Tuple.Func5<O, T0, T1, T2, T3, T4> joiner + ) { + return new MapCodec<>() { + @Override + public Result<RecordBuilder<Format>, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) { + return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops), arg2.enc(data, ops), arg3.enc(data, ops), arg4.enc(data, ops)) + .reduce(Result.ok(ops.createObject()), RecordCodec::merge); + } + @Override + public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) { + return Tuple.Tuple5.collect(new Tuple.Tuple5<>(arg0.dec(format, ops), arg1.dec(format, ops), arg2.dec(format, ops), arg3.dec(format, ops), arg4.dec(format, ops))) + .map(it -> it.applyTo(joiner)); + } + }; + } + public static <T0, T1, T2, T3, T4, T5, O, Format> MapCodec<O, Format> join( + RecordCodec<O, T0, Format> arg0, + RecordCodec<O, T1, Format> arg1, + RecordCodec<O, T2, Format> arg2, + RecordCodec<O, T3, Format> arg3, + RecordCodec<O, T4, Format> arg4, + RecordCodec<O, T5, Format> arg5, + Tuple.Func6<O, T0, T1, T2, T3, T4, T5> joiner + ) { + return new MapCodec<>() { + @Override + public Result<RecordBuilder<Format>, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) { + return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops), arg2.enc(data, ops), arg3.enc(data, ops), arg4.enc(data, ops), arg5.enc(data, ops)) + .reduce(Result.ok(ops.createObject()), RecordCodec::merge); + } + @Override + public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) { + return Tuple.Tuple6.collect(new Tuple.Tuple6<>(arg0.dec(format, ops), arg1.dec(format, ops), arg2.dec(format, ops), arg3.dec(format, ops), arg4.dec(format, ops), arg5.dec(format, ops))) + .map(it -> it.applyTo(joiner)); + } + }; + } + public static <T0, T1, T2, T3, T4, T5, T6, O, Format> MapCodec<O, Format> join( + RecordCodec<O, T0, Format> arg0, + RecordCodec<O, T1, Format> arg1, + RecordCodec<O, T2, Format> arg2, + RecordCodec<O, T3, Format> arg3, + RecordCodec<O, T4, Format> arg4, + RecordCodec<O, T5, Format> arg5, + RecordCodec<O, T6, Format> arg6, + Tuple.Func7<O, T0, T1, T2, T3, T4, T5, T6> joiner + ) { + return new MapCodec<>() { + @Override + public Result<RecordBuilder<Format>, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) { + return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops), arg2.enc(data, ops), arg3.enc(data, ops), arg4.enc(data, ops), arg5.enc(data, ops), arg6.enc(data, ops)) + .reduce(Result.ok(ops.createObject()), RecordCodec::merge); + } + @Override + public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) { + return Tuple.Tuple7.collect(new Tuple.Tuple7<>(arg0.dec(format, ops), arg1.dec(format, ops), arg2.dec(format, ops), arg3.dec(format, ops), arg4.dec(format, ops), arg5.dec(format, ops), arg6.dec(format, ops))) + .map(it -> it.applyTo(joiner)); + } + }; + } + public static <T0, T1, T2, T3, T4, T5, T6, T7, O, Format> MapCodec<O, Format> join( + RecordCodec<O, T0, Format> arg0, + RecordCodec<O, T1, Format> arg1, + RecordCodec<O, T2, Format> arg2, + RecordCodec<O, T3, Format> arg3, + RecordCodec<O, T4, Format> arg4, + RecordCodec<O, T5, Format> arg5, + RecordCodec<O, T6, Format> arg6, + RecordCodec<O, T7, Format> arg7, + Tuple.Func8<O, T0, T1, T2, T3, T4, T5, T6, T7> joiner + ) { + return new MapCodec<>() { + @Override + public Result<RecordBuilder<Format>, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) { + return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops), arg2.enc(data, ops), arg3.enc(data, ops), arg4.enc(data, ops), arg5.enc(data, ops), arg6.enc(data, ops), arg7.enc(data, ops)) + .reduce(Result.ok(ops.createObject()), RecordCodec::merge); + } + @Override + public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) { + return Tuple.Tuple8.collect(new Tuple.Tuple8<>(arg0.dec(format, ops), arg1.dec(format, ops), arg2.dec(format, ops), arg3.dec(format, ops), arg4.dec(format, ops), arg5.dec(format, ops), arg6.dec(format, ops), arg7.dec(format, ops))) + .map(it -> it.applyTo(joiner)); + } + }; + } + public static <T0, T1, T2, T3, T4, T5, T6, T7, T8, O, Format> MapCodec<O, Format> join( + RecordCodec<O, T0, Format> arg0, + RecordCodec<O, T1, Format> arg1, + RecordCodec<O, T2, Format> arg2, + RecordCodec<O, T3, Format> arg3, + RecordCodec<O, T4, Format> arg4, + RecordCodec<O, T5, Format> arg5, + RecordCodec<O, T6, Format> arg6, + RecordCodec<O, T7, Format> arg7, + RecordCodec<O, T8, Format> arg8, + Tuple.Func9<O, T0, T1, T2, T3, T4, T5, T6, T7, T8> joiner + ) { + return new MapCodec<>() { + @Override + public Result<RecordBuilder<Format>, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) { + return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops), arg2.enc(data, ops), arg3.enc(data, ops), arg4.enc(data, ops), arg5.enc(data, ops), arg6.enc(data, ops), arg7.enc(data, ops), arg8.enc(data, ops)) + .reduce(Result.ok(ops.createObject()), RecordCodec::merge); + } + @Override + public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) { + return Tuple.Tuple9.collect(new Tuple.Tuple9<>(arg0.dec(format, ops), arg1.dec(format, ops), arg2.dec(format, ops), arg3.dec(format, ops), arg4.dec(format, ops), arg5.dec(format, ops), arg6.dec(format, ops), arg7.dec(format, ops), arg8.dec(format, ops))) + .map(it -> it.applyTo(joiner)); + } + }; + } + public static <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, O, Format> MapCodec<O, Format> join( + RecordCodec<O, T0, Format> arg0, + RecordCodec<O, T1, Format> arg1, + RecordCodec<O, T2, Format> arg2, + RecordCodec<O, T3, Format> arg3, + RecordCodec<O, T4, Format> arg4, + RecordCodec<O, T5, Format> arg5, + RecordCodec<O, T6, Format> arg6, + RecordCodec<O, T7, Format> arg7, + RecordCodec<O, T8, Format> arg8, + RecordCodec<O, T9, Format> arg9, + Tuple.Func10<O, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> joiner + ) { + return new MapCodec<>() { + @Override + public Result<RecordBuilder<Format>, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) { + return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops), arg2.enc(data, ops), arg3.enc(data, ops), arg4.enc(data, ops), arg5.enc(data, ops), arg6.enc(data, ops), arg7.enc(data, ops), arg8.enc(data, ops), arg9.enc(data, ops)) + .reduce(Result.ok(ops.createObject()), RecordCodec::merge); + } + @Override + public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) { + return Tuple.Tuple10.collect(new Tuple.Tuple10<>(arg0.dec(format, ops), arg1.dec(format, ops), arg2.dec(format, ops), arg3.dec(format, ops), arg4.dec(format, ops), arg5.dec(format, ops), arg6.dec(format, ops), arg7.dec(format, ops), arg8.dec(format, ops), arg9.dec(format, ops))) + .map(it -> it.applyTo(joiner)); + } + }; + } + public static <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, O, Format> MapCodec<O, Format> join( + RecordCodec<O, T0, Format> arg0, + RecordCodec<O, T1, Format> arg1, + RecordCodec<O, T2, Format> arg2, + RecordCodec<O, T3, Format> arg3, + RecordCodec<O, T4, Format> arg4, + RecordCodec<O, T5, Format> arg5, + RecordCodec<O, T6, Format> arg6, + RecordCodec<O, T7, Format> arg7, + RecordCodec<O, T8, Format> arg8, + RecordCodec<O, T9, Format> arg9, + RecordCodec<O, T10, Format> arg10, + Tuple.Func11<O, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> joiner + ) { + return new MapCodec<>() { + @Override + public Result<RecordBuilder<Format>, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) { + return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops), arg2.enc(data, ops), arg3.enc(data, ops), arg4.enc(data, ops), arg5.enc(data, ops), arg6.enc(data, ops), arg7.enc(data, ops), arg8.enc(data, ops), arg9.enc(data, ops), arg10.enc(data, ops)) + .reduce(Result.ok(ops.createObject()), RecordCodec::merge); + } + @Override + public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) { + return Tuple.Tuple11.collect(new Tuple.Tuple11<>(arg0.dec(format, ops), arg1.dec(format, ops), arg2.dec(format, ops), arg3.dec(format, ops), arg4.dec(format, ops), arg5.dec(format, ops), arg6.dec(format, ops), arg7.dec(format, ops), arg8.dec(format, ops), arg9.dec(format, ops), arg10.dec(format, ops))) + .map(it -> it.applyTo(joiner)); + } + }; + } + public static <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, O, Format> MapCodec<O, Format> join( + RecordCodec<O, T0, Format> arg0, + RecordCodec<O, T1, Format> arg1, + RecordCodec<O, T2, Format> arg2, + RecordCodec<O, T3, Format> arg3, + RecordCodec<O, T4, Format> arg4, + RecordCodec<O, T5, Format> arg5, + RecordCodec<O, T6, Format> arg6, + RecordCodec<O, T7, Format> arg7, + RecordCodec<O, T8, Format> arg8, + RecordCodec<O, T9, Format> arg9, + RecordCodec<O, T10, Format> arg10, + RecordCodec<O, T11, Format> arg11, + Tuple.Func12<O, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> joiner + ) { + return new MapCodec<>() { + @Override + public Result<RecordBuilder<Format>, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) { + return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops), arg2.enc(data, ops), arg3.enc(data, ops), arg4.enc(data, ops), arg5.enc(data, ops), arg6.enc(data, ops), arg7.enc(data, ops), arg8.enc(data, ops), arg9.enc(data, ops), arg10.enc(data, ops), arg11.enc(data, ops)) + .reduce(Result.ok(ops.createObject()), RecordCodec::merge); + } + @Override + public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) { + return Tuple.Tuple12.collect(new Tuple.Tuple12<>(arg0.dec(format, ops), arg1.dec(format, ops), arg2.dec(format, ops), arg3.dec(format, ops), arg4.dec(format, ops), arg5.dec(format, ops), arg6.dec(format, ops), arg7.dec(format, ops), arg8.dec(format, ops), arg9.dec(format, ops), arg10.dec(format, ops), arg11.dec(format, ops))) + .map(it -> it.applyTo(joiner)); + } + }; + } + public static <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, O, Format> MapCodec<O, Format> join( + RecordCodec<O, T0, Format> arg0, + RecordCodec<O, T1, Format> arg1, + RecordCodec<O, T2, Format> arg2, + RecordCodec<O, T3, Format> arg3, + RecordCodec<O, T4, Format> arg4, + RecordCodec<O, T5, Format> arg5, + RecordCodec<O, T6, Format> arg6, + RecordCodec<O, T7, Format> arg7, + RecordCodec<O, T8, Format> arg8, + RecordCodec<O, T9, Format> arg9, + RecordCodec<O, T10, Format> arg10, + RecordCodec<O, T11, Format> arg11, + RecordCodec<O, T12, Format> arg12, + Tuple.Func13<O, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> joiner + ) { + return new MapCodec<>() { + @Override + public Result<RecordBuilder<Format>, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) { + return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops), arg2.enc(data, ops), arg3.enc(data, ops), arg4.enc(data, ops), arg5.enc(data, ops), arg6.enc(data, ops), arg7.enc(data, ops), arg8.enc(data, ops), arg9.enc(data, ops), arg10.enc(data, ops), arg11.enc(data, ops), arg12.enc(data, ops)) + .reduce(Result.ok(ops.createObject()), RecordCodec::merge); + } + @Override + public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) { + return Tuple.Tuple13.collect(new Tuple.Tuple13<>(arg0.dec(format, ops), arg1.dec(format, ops), arg2.dec(format, ops), arg3.dec(format, ops), arg4.dec(format, ops), arg5.dec(format, ops), arg6.dec(format, ops), arg7.dec(format, ops), arg8.dec(format, ops), arg9.dec(format, ops), arg10.dec(format, ops), arg11.dec(format, ops), arg12.dec(format, ops))) + .map(it -> it.applyTo(joiner)); + } + }; + } + public static <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, O, Format> MapCodec<O, Format> join( + RecordCodec<O, T0, Format> arg0, + RecordCodec<O, T1, Format> arg1, + RecordCodec<O, T2, Format> arg2, + RecordCodec<O, T3, Format> arg3, + RecordCodec<O, T4, Format> arg4, + RecordCodec<O, T5, Format> arg5, + RecordCodec<O, T6, Format> arg6, + RecordCodec<O, T7, Format> arg7, + RecordCodec<O, T8, Format> arg8, + RecordCodec<O, T9, Format> arg9, + RecordCodec<O, T10, Format> arg10, + RecordCodec<O, T11, Format> arg11, + RecordCodec<O, T12, Format> arg12, + RecordCodec<O, T13, Format> arg13, + Tuple.Func14<O, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> joiner + ) { + return new MapCodec<>() { + @Override + public Result<RecordBuilder<Format>, JsonLikeError> encode(O data, JsonLikeOperations<Format> ops) { + return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops), arg2.enc(data, ops), arg3.enc(data, ops), arg4.enc(data, ops), arg5.enc(data, ops), arg6.enc(data, ops), arg7.enc(data, ops), arg8.enc(data, ops), arg9.enc(data, ops), arg10.enc(data, ops), arg11.enc(data, ops), arg12.enc(data, ops), arg13.enc(data, ops)) + .reduce(Result.ok(ops.createObject()), RecordCodec::merge); + } + @Override + public Result<O, JsonLikeError> decode(RecordView<Format> format, JsonLikeOperations<Format> ops) { + return Tuple.Tuple14.collect(new Tuple.Tuple14<>(arg0.dec(format, ops), arg1.dec(format, ops), arg2.dec(format, ops), arg3.dec(format, ops), arg4.dec(format, ops), arg5.dec(format, ops), arg6.dec(format, ops), arg7.dec(format, ops), arg8.dec(format, ops), arg9.dec(format, ops), arg10.dec(format, ops), arg11.dec(format, ops), arg12.dec(format, ops), arg13.dec(format, ops))) + .map(it -> it.applyTo(joiner)); + } + }; + } +} diff --git a/core/src/main/java/moe/nea/pcj/json/RecordView.java b/core/src/main/java/moe/nea/pcj/json/RecordView.java new file mode 100644 index 0000000..968a936 --- /dev/null +++ b/core/src/main/java/moe/nea/pcj/json/RecordView.java @@ -0,0 +1,10 @@ +package moe.nea.pcj.json; + +import java.util.Collection; +import java.util.Optional; + +public interface RecordView<Format> { + Collection<String> getKeys(); + + Optional<Format> get(String key); +} diff --git a/core/src/main/java/moe/nea/pcj/json/UnexpectedJsonElement.java b/core/src/main/java/moe/nea/pcj/json/UnexpectedJsonElement.java new file mode 100644 index 0000000..7bee7c1 --- /dev/null +++ b/core/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/core/src/main/java/moe/nea/pcj/json/UnknownSubtype.java b/core/src/main/java/moe/nea/pcj/json/UnknownSubtype.java new file mode 100644 index 0000000..942a7dc --- /dev/null +++ b/core/src/main/java/moe/nea/pcj/json/UnknownSubtype.java @@ -0,0 +1,10 @@ +package moe.nea.pcj.json; + +import java.util.Set; + +public record UnknownSubtype<T>(T actual, Set<T> expectedTypes) implements JsonLikeError { + @SafeVarargs + public UnknownSubtype(T actual, T... expected) { + this(actual, Set.of(expected)); + } +} diff --git a/core/src/main/java/moe/nea/pcj/json/package-info.java b/core/src/main/java/moe/nea/pcj/json/package-info.java new file mode 100644 index 0000000..a5aace0 --- /dev/null +++ b/core/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 diff --git a/core/src/main/java/moe/nea/pcj/package-info.java b/core/src/main/java/moe/nea/pcj/package-info.java new file mode 100644 index 0000000..8adfc56 --- /dev/null +++ b/core/src/main/java/moe/nea/pcj/package-info.java @@ -0,0 +1,4 @@ +@NullMarked +package moe.nea.pcj; + +import org.jspecify.annotations.NullMarked;
\ No newline at end of file |