[isis] 02/02: ISIS-2297: adds type composition support for Railway

[ah...@apache.org]

This is an automated email from the ASF dual-hosted git repository.

ahuber pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/isis.git

commit 1fa0dac61f349035a1da7ba1b570451ff4c1a1f5
Author: Andi Huber <ah...@apache.org>
AuthorDate: Wed Apr 6 18:41:17 2022 +0200

    ISIS-2297: adds type composition support for Railway<F, S>
---
 .../org/apache/isis/commons/functional/Either.java |  8 ++---
 .../apache/isis/commons/functional/Railway.java    | 42 +++++++++++++++++++---
 2 files changed, 41 insertions(+), 9 deletions(-)

diff --git a/commons/src/main/java/org/apache/isis/commons/functional/Either.java b/commons/src/main/java/org/apache/isis/commons/functional/Either.java
index 6c9a88c7ae..60670693ca 100644
--- a/commons/src/main/java/org/apache/isis/commons/functional/Either.java
+++ b/commons/src/main/java/org/apache/isis/commons/functional/Either.java
@@ -155,11 +155,9 @@ public interface Either<L, R>  {
         @Override public final boolean isRight() { return true; }
 
         @Override public final <T> Either<T, R> mapLeft(final @NonNull Function<L, T> leftMapper){
-            return Either.right(right);
-        }
+            return Either.right(right); }
         @Override public final <T> Either<L, T> mapRight(final @NonNull Function<R, T> rightMapper){
-            return Either.right(rightMapper.apply(right));
-        }
+            return Either.right(rightMapper.apply(right)); }
 
         @Override
         public final <X, Y> Either<X, Y> map(
@@ -225,7 +223,7 @@ public interface Either<L, R>  {
             return getEither().fold(leftMapper, rightMapper);
         }
 
-        @Override  default void accept(
+        @Override default void accept(
                 final @NonNull Consumer<L> leftConsumer,
                 final @NonNull Consumer<R> rightConsumer) {
             getEither().accept(leftConsumer, rightConsumer);
diff --git a/commons/src/main/java/org/apache/isis/commons/functional/Railway.java b/commons/src/main/java/org/apache/isis/commons/functional/Railway.java
index 60f5249ba1..5761efe2d1 100644
--- a/commons/src/main/java/org/apache/isis/commons/functional/Railway.java
+++ b/commons/src/main/java/org/apache/isis/commons/functional/Railway.java
@@ -87,7 +87,7 @@ public interface Railway<F, S> {
     /**
      * Peeks into the contained {@code success} if this is a {@link Success}.
      */
-    Railway<F, S> ifSuccess(final @NonNull Consumer<S> valueConsumer);
+    Railway<F, S> ifSuccess(final @NonNull Consumer<S> successConsumer);
     /**
      * Peeks into the contained {@code failure} if this is a {@link Failure}.
      */
@@ -145,8 +145,8 @@ public interface Railway<F, S> {
         @Override public Optional<F> getFailure() { return Optional.empty(); }
 
         @Override
-        public Success<F, S> ifSuccess(final @NonNull Consumer<S> valueConsumer) {
-            valueConsumer.accept(success);
+        public Success<F, S> ifSuccess(final @NonNull Consumer<S> successConsumer) {
+            successConsumer.accept(success);
             return this;
         }
 
@@ -195,7 +195,7 @@ public interface Railway<F, S> {
         @Override public Optional<F> getFailure() { return Optional.of(failure); }
 
         @Override
-        public Failure<F, S> ifSuccess(final @NonNull Consumer<S> valueConsumer) {
+        public Failure<F, S> ifSuccess(final @NonNull Consumer<S> successConsumer) {
             return this;
         }
 
@@ -229,4 +229,38 @@ public interface Railway<F, S> {
 
     }
 
+    // -- TYPE COMPOSITION
+
+    public static interface HasRailway<F, S> extends Railway<F, S> {
+
+        Railway<F, S> getRailway();
+
+        @Override default boolean isSuccess() { return getRailway().isSuccess(); }
+        @Override default boolean isFailure() { return getRailway().isFailure(); }
+
+        @Override default Optional<S> getSuccess() { return getRailway().getSuccess(); }
+        @Override default Optional<F> getFailure() { return getRailway().getFailure(); }
+
+        @Override default Railway<F, S> ifSuccess(final @NonNull Consumer<S> successConsumer) {
+            return getRailway().ifSuccess(successConsumer); }
+        @Override default Railway<F, S> ifFailure(final @NonNull Consumer<F> failureConsumer) {
+            return getRailway().ifFailure(failureConsumer); }
+
+        @Override default <R> Railway<F, R> mapSuccess(final @NonNull Function<S, R> successMapper) {
+            return getRailway().mapSuccess(successMapper); }
+        @Override default <R> Railway<R, S> mapFailure(final @NonNull Function<F, R> failureMapper) {
+            return getRailway().mapFailure(failureMapper); }
+
+        @Override default <R> R fold(
+                final @NonNull Function<F, R> failureMapper,
+                final @NonNull Function<S, R> successMapper) {
+            return getRailway().fold(failureMapper, successMapper);
+        }
+
+        @Override default public Railway<F, S> chain(final @NonNull Function<S, Railway<F, S>> chainingFunction){
+            return getRailway().chain(chainingFunction);
+        }
+    }
+
+
 }