├── README.md
├── .gitignore
├── .gitattributes
├── src
    ├── main
    │   └── java
    │   │   └── com
    │   │       └── ps
    │   │           └── functional
    │   │               ├── monad
    │   │                   ├── optional
    │   │                   │   └── Optionals.java
    │   │                   └── result
    │   │                   │   ├── Failure.java
    │   │                   │   ├── Success.java
    │   │                   │   ├── ErrorType.java
    │   │                   │   └── Result.java
    │   │               └── util
    │   │                   └── FunctionUtils.java
    └── test
    │   └── groovy
    │       └── com
    │           └── ps
    │               └── functional
    │                   ├── util
    │                       └── FunctionUtilsSpec.groovy
    │                   └── monad
    │                       ├── optional
    │                           └── OptionalsSpec.groovy
    │                       └── result
    │                           └── ResultSpec.groovy
├── pom.xml
└── LICENSE


/README.md:
--------------------------------------------------------------------------------
1 | # functional-java
2 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | *.iml
2 | .classpath
3 | .idea
4 | .project
5 | .settings
6 | target
7 | 


--------------------------------------------------------------------------------
/.gitattributes:
--------------------------------------------------------------------------------
 1 | #All files would be converted to LF ending
 2 | * text
 3 | 
 4 | #Always keep this files as Windows ones
 5 | *.cmd eol=crlf
 6 | 
 7 | #Always keep this files as unix ones
 8 | *.sh text eol=lf
 9 | *.dsv text eol=lf
10 | *.conf text eol=lf
11 | *.sql text eol=lf
12 | *.awk text eol=lf
13 | *.xml text eol=lf
14 | 
15 | # Denote all files that are truly binary and should not be modified.
16 | *.jar binary
17 | *.png binary
18 | *.jpg binary
19 | *.xcf binary
20 | *.gif binary
21 | *.pdf binary
22 | 


--------------------------------------------------------------------------------
/src/main/java/com/ps/functional/monad/optional/Optionals.java:
--------------------------------------------------------------------------------
 1 | package com.ps.functional.monad.optional;
 2 | 
 3 | import java.util.Optional;
 4 | import java.util.function.BiFunction;
 5 | 
 6 | public interface Optionals {
 7 | 
 8 |     static <R, T, Z> Optional<Z> lift(Optional<T> left, Optional<R> right,
 9 |                                       BiFunction<? super T, ? super R, ? extends Z> function) {
10 |         return left.flatMap(leftVal -> right.map(rightVal -> function.apply(leftVal, rightVal)));
11 |     }
12 | 
13 |     static <R, T, Z> BiFunction<Optional<T>, Optional<R>, Optional<Z>> lift(BiFunction<? super T, ? super R, ? extends Z> function) {
14 |         return (left, right) -> left.flatMap(leftVal -> right.map(rightVal -> function.apply(leftVal, rightVal)));
15 |     }
16 | 
17 | }


--------------------------------------------------------------------------------
/src/main/java/com/ps/functional/util/FunctionUtils.java:
--------------------------------------------------------------------------------
 1 | package com.ps.functional.util;
 2 | 
 3 | import java.util.function.BiFunction;
 4 | import java.util.function.Function;
 5 | import java.util.function.Predicate;
 6 | 
 7 | public interface FunctionUtils {
 8 | 
 9 |     /*
10 |         Casts any one argument method reference to a Function type
11 |      */
12 |     static <T, R> Function<T, R> function(Function<T, R> function) {
13 |         return function;
14 |     }
15 | 
16 |     /*
17 |         Casts any two arguments method reference to a BiFunction type
18 |     */
19 |     static <T, U, R> BiFunction<T, U, R> biFunction(BiFunction<T, U, R> biFunction) {
20 |         return biFunction;
21 |     }
22 | 
23 |     /*
24 |        Negates the predicate
25 |     */
26 |     static <T> Predicate<T> not(Predicate<T> predicate) {
27 |         return predicate.negate();
28 |     }
29 | 
30 | }


--------------------------------------------------------------------------------
/src/test/groovy/com/ps/functional/util/FunctionUtilsSpec.groovy:
--------------------------------------------------------------------------------
 1 | package com.ps.functional.util
 2 | 
 3 | import spock.lang.Specification
 4 | 
 5 | import java.util.function.BiFunction
 6 | import java.util.function.Function
 7 | import java.util.function.Predicate
 8 | 
 9 | class FunctionUtilsSpec extends Specification {
10 | 
11 |     def "function method should just return the passed argument "() {
12 |         given:
13 |         Function addOne = {it + 1}
14 | 
15 |         expect:
16 |         FunctionUtils.function(addOne).is(addOne)
17 |     }
18 | 
19 |     def "biFunction method should just return the passed argument "() {
20 |         given:
21 |         BiFunction add = { a, b -> a + b}
22 | 
23 |         expect:
24 |         FunctionUtils.biFunction(add).is(add)
25 |     }
26 | 
27 |     def "method not should negate the predicate "() {
28 |         given:
29 |         Predicate equalsOne = { x -> x == 1 }
30 |         Predicate notEqualsOne = FunctionUtils.not(equalsOne)
31 | 
32 |         expect:
33 |         equalsOne.test(1)
34 |         !notEqualsOne.test(1)
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/src/test/groovy/com/ps/functional/monad/optional/OptionalsSpec.groovy:
--------------------------------------------------------------------------------
 1 | package com.ps.functional.monad.optional
 2 | 
 3 | import spock.lang.Specification
 4 | 
 5 | import java.util.function.BiFunction
 6 | 
 7 | class OptionalsSpec extends Specification {
 8 | 
 9 |     BiFunction<Integer, Integer, String> sumString = { a, b -> a + b + "" } as BiFunction
10 | 
11 |     BiFunction<Optional<Integer>, Optional<Integer>, Optional<String>> liftedSumString = Optionals.lift(sumString)
12 | 
13 |     def "Lift should lift any biFunction to operate on Optionals"() {
14 |         given:
15 |         Optional<Integer> first = Optional.of(1)
16 |         Optional<Integer> second = Optional.of(2)
17 | 
18 |         expect:
19 |         liftedSumString.apply(first, second).get() == "3"
20 |     }
21 | 
22 |     def "If one of the arguments of apply is empty then the result should be empty "() {
23 |         expect:
24 |         liftedSumString.apply(Optional.of(1), Optional.of(2)).isPresent()
25 |         !liftedSumString.apply(Optional.of(1), Optional.empty()).isPresent()
26 |         !liftedSumString.apply(Optional.empty(), Optional.of(1)).isPresent()
27 |         !liftedSumString.apply(Optional.empty(), Optional.empty()).isPresent()
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/main/java/com/ps/functional/monad/result/Failure.java:
--------------------------------------------------------------------------------
 1 | package com.ps.functional.monad.result;
 2 | 
 3 | import java.util.NoSuchElementException;
 4 | 
 5 | public final class Failure<T> implements Result<T> {
 6 | 
 7 |     private static final String NO_MORE_INFO = "";
 8 | 
 9 |     private final ErrorType error;
10 | 
11 |     private final String optionalErrorMessage;
12 | 
13 |     private Failure(ErrorType error) {
14 |         this.error = error;
15 |         this.optionalErrorMessage = NO_MORE_INFO;
16 |     }
17 | 
18 |     private Failure(ErrorType error, String optionalErrorMessage) {
19 |         this.error = error;
20 |         this.optionalErrorMessage = optionalErrorMessage;
21 |     }
22 | 
23 |     public static <T> Result<T> of(ErrorType error) {
24 |         return new Failure<>(error);
25 |     }
26 | 
27 |     public static <T> Result<T> of(ErrorType error, String errorMessage) {
28 |         return new Failure<>(error, errorMessage);
29 |     }
30 | 
31 |     @Override
32 |     public boolean isSuccess() {
33 |         return false;
34 |     }
35 | 
36 |     @Override
37 |     public ErrorType getError() {
38 |         return error;
39 |     }
40 | 
41 |     @Override
42 |     public String getOptionalErrorMessage() {
43 |         return optionalErrorMessage;
44 |     }
45 | 
46 |     @Override
47 |     public T getResult() {
48 |         throw new NoSuchElementException("There is no result is Failure");
49 |     }
50 | 
51 |     @Override
52 |     public String toString() {
53 |         return String.format("Failure[%s, optional: %s]", error.show(), optionalErrorMessage);
54 |     }
55 | 
56 | }
57 | 


--------------------------------------------------------------------------------
/src/main/java/com/ps/functional/monad/result/Success.java:
--------------------------------------------------------------------------------
 1 | package com.ps.functional.monad.result;
 2 | 
 3 | import java.util.NoSuchElementException;
 4 | import java.util.Optional;
 5 | 
 6 | public final class Success<T> implements Result<T> {
 7 | 
 8 |     public static final Result<Void> SUCCESS = new Success<>(null);
 9 | 
10 |     public static final Result OPTIONAL_SUCCESS = Success.ofOptional(null);
11 | 
12 |     @SuppressWarnings("unchecked")
13 |     static <T> Result<Optional<T>> emptyOptional() {
14 |         return (Result<Optional<T>>) OPTIONAL_SUCCESS;
15 |     }
16 | 
17 |     private final T result;
18 | 
19 |     public static <T> Result<T> of(T result) {
20 |         return new Success<>(result);
21 |     }
22 | 
23 |     public static <T> Result<Optional<T>> ofOptional(T result) {
24 |         return new Success<>(Optional.ofNullable(result));
25 |     }
26 | 
27 |     private Success(T result) {
28 |         this.result = result;
29 |     }
30 | 
31 |     @Override
32 |     public boolean isSuccess() {
33 |         return true;
34 |     }
35 | 
36 |     @Override
37 |     public ErrorType getError() {
38 |         throw new NoSuchElementException("There is no error in Success");
39 |     }
40 | 
41 |     @Override
42 |     public String getOptionalErrorMessage() {
43 |         throw new NoSuchElementException("There is no optional error message in Success");
44 |     }
45 | 
46 |     @Override
47 |     public T getResult() {
48 |         return result;
49 |     }
50 | 
51 |     @Override
52 |     public String toString() {
53 |         final String value = result != null ? result.toString() : "";
54 |         return String.format("Success[%s]", value);
55 |     }
56 | }
57 | 


--------------------------------------------------------------------------------
/src/main/java/com/ps/functional/monad/result/ErrorType.java:
--------------------------------------------------------------------------------
 1 | package com.ps.functional.monad.result;
 2 | 
 3 | import java.util.Objects;
 4 | 
 5 | public class ErrorType {
 6 | 
 7 |     public enum Severity {
 8 |         CRITICAL, MODERATE, MINOR, WARNING, DEBUG, UNKNOWN
 9 |     }
10 | 
11 |     public enum ErrorSource {
12 |         INTERNAL, CLIENT, EXTERNAL, UNKNOWN, MULTIPLE
13 |     }
14 | 
15 |     private final String message;
16 | 
17 |     private final int code;
18 | 
19 |     private final Severity severity;
20 | 
21 |     private final ErrorSource errorSource;
22 | 
23 |     private final String errorName;
24 | 
25 |     private ErrorType(
26 |             String message,
27 |             int code,
28 |             ErrorType.Severity severity,
29 |             ErrorType.ErrorSource errorSource,
30 |             String name) {
31 |         this.message = Objects.requireNonNull(message, "message");
32 |         this.code = code;
33 |         this.severity = Objects.requireNonNull(severity, "severity");
34 |         this.errorSource = Objects.requireNonNull(errorSource, "errorSource");
35 |         this.errorName = Objects.requireNonNull(name, "errorName");
36 |     }
37 | 
38 |     public static ErrorType of(
39 |             String message,
40 |             int code,
41 |             ErrorType.Severity severity,
42 |             ErrorType.ErrorSource errorSource,
43 |             String errorName) {
44 |         return new ErrorType(message, code, severity, errorSource, errorName);
45 |     }
46 | 
47 |     public String getMessage() {
48 |         return message;
49 |     }
50 | 
51 |     public int getCode() {
52 |         return code;
53 |     }
54 | 
55 |     public Severity getSeverity() {
56 |         return severity;
57 |     }
58 | 
59 |     public ErrorSource getErrorSource() {
60 |         return errorSource;
61 |     }
62 | 
63 |     public String getErrorName() {
64 |         return errorName;
65 |     }
66 | 
67 |     public String show() {
68 |         return code + " - " + errorName + ", Sev: " + severity.toString() +
69 |                 ", Source: " + errorSource.toString() + ", Message: " + message;
70 |     }
71 |     
72 | }
73 | 


--------------------------------------------------------------------------------
/src/main/java/com/ps/functional/monad/result/Result.java:
--------------------------------------------------------------------------------
 1 | package com.ps.functional.monad.result;
 2 | 
 3 | import com.ps.functional.monad.optional.Optionals;
 4 | 
 5 | import java.util.Optional;
 6 | import java.util.function.BiFunction;
 7 | import java.util.function.Consumer;
 8 | import java.util.function.Function;
 9 | 
10 | public interface Result<T> {
11 | 
12 |     boolean isSuccess();
13 | 
14 |     default boolean isFailure() {
15 |         return !isSuccess();
16 |     }
17 | 
18 |     ErrorType getError();
19 | 
20 |     String getOptionalErrorMessage();
21 | 
22 |     T getResult();
23 | 
24 |     /*
25 |         Use this method when you want to apply a function on the insides of the Result
26 |         without unwrapping it. Mapper won't be invoked if the Result is Failure
27 |      */
28 |     default <R> Result<R> map(Function<? super T, ? extends R> mapper) {
29 |         return isSuccess() ?
30 |                 Success.of(mapper.apply(getResult())) :
31 |                 (Failure<R>) this;
32 |     }
33 | 
34 |     /*
35 |         Use this method when you your mapping function is returning a Result<T> (which will make
36 |         the return type the Result<Result<T>> using just 'map').
37 |      */
38 |     default <R> Result<R> flatMap(Function<? super T, Result<R>> mapper) {
39 |         return isSuccess() ?
40 |                 mapper.apply(getResult()) :
41 |                 (Failure<R>) this;
42 |     }
43 | 
44 |     /*
45 |         Use this method if you want to reduce your Result to some type R. For example at the
46 |         end of the flow, you could convert it to two different client responses depending on
47 |         the insides.
48 |      */
49 |     default <R> R fold(Function<? super T, ? extends R> successFunction, Function<Failure<R>, ? extends R> failureFunction) {
50 |         return isSuccess() ?
51 |                 successFunction.apply(getResult()) :
52 |                 failureFunction.apply((Failure<R>) this);
53 |     }
54 | 
55 |     /*
56 |         Use this method when you have two instances of Result and you want to invoke a function on
57 |         their insides without unwrapping them separately. If both of them are Failures then only
58 |         the first (this) Failure will be returned.
59 |      */
60 |     default <R, Z> Result<Z> lift(Result<R> other, BiFunction<? super T, ? super R, ? extends Z> function) {
61 |         return flatMap(first -> other.map(second -> function.apply(first, second)));
62 |     }
63 | 
64 |     /*
65 |         Use this method when you have two instances of Result<Optional> and you want to invoke a function on
66 |         their insides without unwrapping them separately. If both of them are Failures then only
67 |         the first (this) Failure will be returned.
68 |      */
69 |     static <R, T, Z> Result<Optional<Z>> liftOptional(Result<Optional<T>> left, Result<Optional<R>> right,
70 |                                                       BiFunction<? super T, ? super R, ? extends Z> function) {
71 |         return left.lift(right, (a, b) -> Optionals.lift(a, b, function));
72 |     }
73 | 
74 |     default Result<T> ifSuccess(Consumer<? super T> successConsumer) {
75 |         if (isSuccess()) {
76 |             successConsumer.accept(this.getResult());
77 |         }
78 |         return this;
79 |     }
80 | 
81 |     default Result<T> ifFailure(Consumer<Failure<T>> failureConsumer) {
82 |         if (isFailure()) {
83 |             failureConsumer.accept((Failure<T>) this);
84 |         }
85 |         return this;
86 |     }
87 | }


--------------------------------------------------------------------------------
/pom.xml:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="UTF-8"?>
  2 | <project xmlns="http://maven.apache.org/POM/4.0.0"
  3 |          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4 |          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5 |     <modelVersion>4.0.0</modelVersion>
  6 | 
  7 |     <groupId>com.ps.functional</groupId>
  8 |     <artifactId>functional-java</artifactId>
  9 |     <version>1.0-SNAPSHOT</version>
 10 | 
 11 |     <dependencies>
 12 |         <!--Test dependencies-->
 13 |         <dependency>
 14 |             <groupId>org.spockframework</groupId>
 15 |             <artifactId>spock-core</artifactId>
 16 |             <version>1.0-groovy-2.4</version>
 17 |             <scope>test</scope>
 18 |         </dependency>
 19 |         <dependency>
 20 |             <groupId>org.codehaus.groovy</groupId>
 21 |             <artifactId>groovy-all</artifactId>
 22 |             <version>2.4.7</version>
 23 |             <scope>test</scope>
 24 |         </dependency>
 25 |         <dependency>
 26 |             <groupId>org.objenesis</groupId>
 27 |             <artifactId>objenesis</artifactId>
 28 |             <version>1.2</version>
 29 |             <scope>test</scope>
 30 |         </dependency>
 31 |         <dependency>
 32 |             <groupId>cglib</groupId>
 33 |             <artifactId>cglib-nodep</artifactId>
 34 |             <version>3.1</version>
 35 |             <scope>test</scope>
 36 |         </dependency>
 37 |     </dependencies>
 38 | 
 39 |     <build>
 40 |         <plugins>
 41 |             <plugin>
 42 |                 <groupId>org.apache.maven.plugins</groupId>
 43 |                 <artifactId>maven-compiler-plugin</artifactId>
 44 |                 <version>3.3</version>
 45 |                 <configuration>
 46 |                     <compilerVersion>1.8</compilerVersion>
 47 |                     <source>1.8</source>
 48 |                     <target>1.8</target>
 49 |                 </configuration>
 50 |             </plugin>
 51 |             <plugin>
 52 |                 <groupId>org.codehaus.mojo</groupId>
 53 |                 <artifactId>build-helper-maven-plugin</artifactId>
 54 |                 <version>1.12</version>
 55 |                 <executions>
 56 |                     <execution>
 57 |                         <id>add-test-source</id>
 58 |                         <phase>generate-test-sources</phase>
 59 |                         <goals>
 60 |                             <goal>add-test-source</goal>
 61 |                         </goals>
 62 |                         <configuration>
 63 |                             <sources>
 64 |                                 <source>src/test/java</source>
 65 |                                 <source>src/test/groovy</source>
 66 |                             </sources>
 67 |                         </configuration>
 68 |                     </execution>
 69 |                 </executions>
 70 |             </plugin>
 71 | 
 72 |             <plugin>
 73 |                 <groupId>org.codehaus.gmavenplus</groupId>
 74 |                 <artifactId>gmavenplus-plugin</artifactId>
 75 |                 <version>1.5</version>
 76 |                 <executions>
 77 |                     <execution>
 78 |                         <goals>
 79 |                             <goal>testCompile</goal>
 80 |                         </goals>
 81 |                     </execution>
 82 |                 </executions>
 83 |             </plugin>
 84 |             <plugin>
 85 |                 <artifactId>maven-surefire-plugin</artifactId>
 86 |                 <version>2.19</version>
 87 |                 <configuration>
 88 |                     <additionalClasspathElements>
 89 |                         <additionalClasspathElement>../groovy</additionalClasspathElement>
 90 |                         <additionalClasspathElement>../java</additionalClasspathElement>
 91 |                     </additionalClasspathElements>
 92 |                     <useFile>false</useFile>
 93 |                     <includes>
 94 |                         <include>**/*Spec.java</include>
 95 |                         <include>**/*Test.java</include>
 96 |                         <include>**/*Test.groovy</include>
 97 |                         <include>**/*Spec.groovy</include>
 98 |                     </includes>
 99 |                     <excludes>
100 |                         <exclude>**/component/**</exclude>
101 |                     </excludes>
102 |                 </configuration>
103 |             </plugin>
104 |         </plugins>
105 |     </build>
106 | </project>


--------------------------------------------------------------------------------
/src/test/groovy/com/ps/functional/monad/result/ResultSpec.groovy:
--------------------------------------------------------------------------------
  1 | package com.ps.functional.monad.result
  2 | 
  3 | import spock.lang.Specification
  4 | 
  5 | import java.util.function.Consumer
  6 | import java.util.function.Function
  7 | import static com.ps.functional.monad.result.Success.SUCCESS
  8 | 
  9 | class ResultSpec extends Specification {
 10 | 
 11 |     def error = ErrorType.of("error occurred", 1, ErrorType.Severity.CRITICAL, ErrorType.ErrorSource.CLIENT, "ERROR")
 12 | 
 13 |     def "isSuccess should be true for Success and false for Failure "() {
 14 |         expect:
 15 |         SUCCESS.isSuccess()
 16 |         !Failure.of(error).isSuccess()
 17 |     }
 18 | 
 19 |     def "isFailure should be false for Success and true for Failure "() {
 20 |         expect:
 21 |         !SUCCESS.isFailure()
 22 |         Failure.of(error).isFailure()
 23 |     }
 24 | 
 25 |     def "For Failure getError should return the error "() {
 26 |         given:
 27 |         Result result = Failure.of(error)
 28 | 
 29 |         expect:
 30 |         result.error == error
 31 |     }
 32 | 
 33 |     def "For Success getError should throw an exception"() {
 34 |         when:
 35 |         SUCCESS.error
 36 | 
 37 |         then:
 38 |         thrown(NoSuchElementException)
 39 |     }
 40 | 
 41 |     def "For Success getResult should return the result inside "() {
 42 |         given:
 43 |         String someResult = "some result inside"
 44 |         Result daoResult = SUCCESS.of(someResult)
 45 | 
 46 |         expect:
 47 |         daoResult.getResult() == someResult
 48 |     }
 49 | 
 50 |     def "For Failure getResult should throw an exception "() {
 51 |         when:
 52 |         Failure.of(error).getResult()
 53 | 
 54 |         then:
 55 |         thrown(NoSuchElementException)
 56 |     }
 57 | 
 58 |     def "Fold operation should reduce the Success to single value using successFunction "() {
 59 |         given:
 60 |         String resultString = "result"
 61 |         Function otherFunction = Mock(Function)
 62 |         Result result = SUCCESS.of(resultString)
 63 | 
 64 |         when:
 65 |         String reduceResult = result.fold({ it.toUpperCase() }, otherFunction)
 66 | 
 67 |         then:
 68 |         reduceResult == resultString.toUpperCase()
 69 |         0 * otherFunction._
 70 |     }
 71 | 
 72 |     def "Fold operation should reduce the Failure to single value using failureFunction "() {
 73 |         given:
 74 |         Function otherFunction = Mock(Function)
 75 |         Result result = Failure.of(error)
 76 | 
 77 |         when:
 78 |         String reduceResult = result.fold(otherFunction, { it.getError().getMessage() })
 79 | 
 80 |         then:
 81 |         reduceResult == error.getMessage()
 82 |         0 * otherFunction._
 83 |     }
 84 | 
 85 |     def "toString should properly format the insides of Result "() {
 86 |         given:
 87 |         String result = "result"
 88 | 
 89 |         expect:
 90 |         SUCCESS.of(result).toString() == "Success[${result}]"
 91 |         Failure.of(error).toString() == "Failure[1 - ERROR, Sev: CRITICAL, Source: CLIENT, Message: error occurred, optional: ]"
 92 |         def failure = Failure.of(error, "optional")
 93 |         failure.toString().contains(error.show())
 94 |         failure.toString().contains("optional")
 95 |     }
 96 | 
 97 |     def "map should transform the successful result from one type to another"() {
 98 |         given:
 99 |         String result = "result"
100 | 
101 |         expect:
102 |         SUCCESS.of(result).map { it.charAt(0) }.getResult() == 'r'
103 |     }
104 | 
105 |     def "map should not modify the Failure "() {
106 |         expect:
107 |         Failure.of(error).map { it.charAt(0) }.error == error
108 |     }
109 | 
110 |     def "flatMap should transform the successful result from one type to another"() {
111 |         given:
112 |         String result = "result"
113 | 
114 |         expect:
115 |         SUCCESS.of(result).flatMap { SUCCESS.of(it.charAt(0)) }.getResult() == 'r'
116 |     }
117 | 
118 |     def "flatMap should not modify the Failure "() {
119 |         expect:
120 |         Failure.of(error).flatMap { SUCCESS.of(it.charAt(0)) }.error == error
121 |     }
122 | 
123 |     def "If one of Results is a failure, using lift should always return this failure"() {
124 |         given:
125 |         Result success = SUCCESS
126 |         Result failure = Failure.of(error)
127 |         Result otherFailure = Failure.of(null)
128 |         def transformer = { a, b -> 5 }
129 | 
130 |         expect:
131 |         success.lift(success, transformer).isSuccess()
132 |         success.lift(failure, transformer).isFailure()
133 |         failure.lift(failure, transformer).isFailure()
134 |         failure.lift(success, transformer).isFailure()
135 | 
136 |         and: "'this' should has precedence"
137 |         failure.lift(otherFailure, transformer).getError().is(error)
138 |     }
139 | 
140 |     def "lift should invoke function on insides of the Results"() {
141 |         given:
142 |         Result<String> resultString = SUCCESS.of("lululu")
143 |         Result<String> resultOtherString = SUCCESS.of(" tengo manzana")
144 | 
145 |         def function = { str, opt -> str + opt }
146 | 
147 |         when:
148 |         Result<String> result = resultString.lift(resultOtherString, function)
149 | 
150 |         then:
151 |         result.isSuccess()
152 |         result.getResult() == "lululu tengo manzana"
153 |     }
154 | 
155 |     def "Optional error message for Success should be empty "() {
156 |         when:
157 |         SUCCESS.getOptionalErrorMessage()
158 | 
159 |         then:
160 |         thrown(NoSuchElementException)
161 |     }
162 | 
163 |     def "liftOptional should invoke lift method from Optionals"() {
164 |         given:
165 |         Result<Optional> first = Success.of(Optional.of(1))
166 |         Result<Optional> second = Success.of(Optional.of(2))
167 | 
168 |         when:
169 |         def result = first.lift(second, { a, b -> a.get() + b.get() })
170 | 
171 |         then:
172 |         result.getResult() == 3
173 |     }
174 | 
175 |     def "ifSuccess should invoke success consumer with wrapped object only if it is a success"() {
176 |         given:
177 |         def object = new Object()
178 |         def success = Success.of(object)
179 |         def failure = Failure.of(Mock(ErrorType))
180 |         def successConsumer = Mock(Consumer.class)
181 | 
182 |         when:
183 |         success.ifSuccess(successConsumer)
184 | 
185 |         then:
186 |         1 * successConsumer.accept(object)
187 | 
188 |         when:
189 |         failure.ifSuccess(successConsumer)
190 | 
191 |         then:
192 |         0 * _
193 |     }
194 | 
195 |     def "ifFailure should invoke failure consumer with itself only if it is a failure"() {
196 |         given:
197 |         def object = new Object()
198 |         def success = Success.of(object)
199 |         def failure = Failure.of(Mock(ErrorType))
200 |         def failureConsumer = Mock(Consumer.class)
201 | 
202 |         when:
203 |         success.ifFailure(failureConsumer)
204 | 
205 |         then:
206 |         0 * _
207 | 
208 |         when:
209 |         failure.ifFailure(failureConsumer)
210 | 
211 |         then:
212 |         1 * failureConsumer.accept(failure)
213 |     }
214 | 
215 |     def "emptyOptional should return success with Optional.empty()"() {
216 |         when:
217 |         def result = Success.emptyOptional()
218 | 
219 |         then:
220 |         result.result == Optional.empty()
221 |         result instanceof Success
222 |     }
223 | 
224 |     def "ofOptional should return success with optional element"() {
225 |         when:
226 |         def success = Success.ofOptional(obj)
227 | 
228 |         then:
229 |         success instanceof Success
230 |         success.result instanceof Optional
231 |         obj != null ? success.result.get() == obj : success.result == Optional.empty()
232 | 
233 |         where:
234 |         obj << [null, new Object(), [:], [] as List]
235 | 
236 |     }
237 | }
238 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 |                                  Apache License
  2 |                            Version 2.0, January 2004
  3 |                         http://www.apache.org/licenses/
  4 | 
  5 |    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
  6 | 
  7 |    1. Definitions.
  8 | 
  9 |       "License" shall mean the terms and conditions for use, reproduction,
 10 |       and distribution as defined by Sections 1 through 9 of this document.
 11 | 
 12 |       "Licensor" shall mean the copyright owner or entity authorized by
 13 |       the copyright owner that is granting the License.
 14 | 
 15 |       "Legal Entity" shall mean the union of the acting entity and all
 16 |       other entities that control, are controlled by, or are under common
 17 |       control with that entity. For the purposes of this definition,
 18 |       "control" means (i) the power, direct or indirect, to cause the
 19 |       direction or management of such entity, whether by contract or
 20 |       otherwise, or (ii) ownership of fifty percent (50%) or more of the
 21 |       outstanding shares, or (iii) beneficial ownership of such entity.
 22 | 
 23 |       "You" (or "Your") shall mean an individual or Legal Entity
 24 |       exercising permissions granted by this License.
 25 | 
 26 |       "Source" form shall mean the preferred form for making modifications,
 27 |       including but not limited to software source code, documentation
 28 |       source, and configuration files.
 29 | 
 30 |       "Object" form shall mean any form resulting from mechanical
 31 |       transformation or translation of a Source form, including but
 32 |       not limited to compiled object code, generated documentation,
 33 |       and conversions to other media types.
 34 | 
 35 |       "Work" shall mean the work of authorship, whether in Source or
 36 |       Object form, made available under the License, as indicated by a
 37 |       copyright notice that is included in or attached to the work
 38 |       (an example is provided in the Appendix below).
 39 | 
 40 |       "Derivative Works" shall mean any work, whether in Source or Object
 41 |       form, that is based on (or derived from) the Work and for which the
 42 |       editorial revisions, annotations, elaborations, or other modifications
 43 |       represent, as a whole, an original work of authorship. For the purposes
 44 |       of this License, Derivative Works shall not include works that remain
 45 |       separable from, or merely link (or bind by name) to the interfaces of,
 46 |       the Work and Derivative Works thereof.
 47 | 
 48 |       "Contribution" shall mean any work of authorship, including
 49 |       the original version of the Work and any modifications or additions
 50 |       to that Work or Derivative Works thereof, that is intentionally
 51 |       submitted to Licensor for inclusion in the Work by the copyright owner
 52 |       or by an individual or Legal Entity authorized to submit on behalf of
 53 |       the copyright owner. For the purposes of this definition, "submitted"
 54 |       means any form of electronic, verbal, or written communication sent
 55 |       to the Licensor or its representatives, including but not limited to
 56 |       communication on electronic mailing lists, source code control systems,
 57 |       and issue tracking systems that are managed by, or on behalf of, the
 58 |       Licensor for the purpose of discussing and improving the Work, but
 59 |       excluding communication that is conspicuously marked or otherwise
 60 |       designated in writing by the copyright owner as "Not a Contribution."
 61 | 
 62 |       "Contributor" shall mean Licensor and any individual or Legal Entity
 63 |       on behalf of whom a Contribution has been received by Licensor and
 64 |       subsequently incorporated within the Work.
 65 | 
 66 |    2. Grant of Copyright License. Subject to the terms and conditions of
 67 |       this License, each Contributor hereby grants to You a perpetual,
 68 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 69 |       copyright license to reproduce, prepare Derivative Works of,
 70 |       publicly display, publicly perform, sublicense, and distribute the
 71 |       Work and such Derivative Works in Source or Object form.
 72 | 
 73 |    3. Grant of Patent License. Subject to the terms and conditions of
 74 |       this License, each Contributor hereby grants to You a perpetual,
 75 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 76 |       (except as stated in this section) patent license to make, have made,
 77 |       use, offer to sell, sell, import, and otherwise transfer the Work,
 78 |       where such license applies only to those patent claims licensable
 79 |       by such Contributor that are necessarily infringed by their
 80 |       Contribution(s) alone or by combination of their Contribution(s)
 81 |       with the Work to which such Contribution(s) was submitted. If You
 82 |       institute patent litigation against any entity (including a
 83 |       cross-claim or counterclaim in a lawsuit) alleging that the Work
 84 |       or a Contribution incorporated within the Work constitutes direct
 85 |       or contributory patent infringement, then any patent licenses
 86 |       granted to You under this License for that Work shall terminate
 87 |       as of the date such litigation is filed.
 88 | 
 89 |    4. Redistribution. You may reproduce and distribute copies of the
 90 |       Work or Derivative Works thereof in any medium, with or without
 91 |       modifications, and in Source or Object form, provided that You
 92 |       meet the following conditions:
 93 | 
 94 |       (a) You must give any other recipients of the Work or
 95 |           Derivative Works a copy of this License; and
 96 | 
 97 |       (b) You must cause any modified files to carry prominent notices
 98 |           stating that You changed the files; and
 99 | 
100 |       (c) You must retain, in the Source form of any Derivative Works
101 |           that You distribute, all copyright, patent, trademark, and
102 |           attribution notices from the Source form of the Work,
103 |           excluding those notices that do not pertain to any part of
104 |           the Derivative Works; and
105 | 
106 |       (d) If the Work includes a "NOTICE" text file as part of its
107 |           distribution, then any Derivative Works that You distribute must
108 |           include a readable copy of the attribution notices contained
109 |           within such NOTICE file, excluding those notices that do not
110 |           pertain to any part of the Derivative Works, in at least one
111 |           of the following places: within a NOTICE text file distributed
112 |           as part of the Derivative Works; within the Source form or
113 |           documentation, if provided along with the Derivative Works; or,
114 |           within a display generated by the Derivative Works, if and
115 |           wherever such third-party notices normally appear. The contents
116 |           of the NOTICE file are for informational purposes only and
117 |           do not modify the License. You may add Your own attribution
118 |           notices within Derivative Works that You distribute, alongside
119 |           or as an addendum to the NOTICE text from the Work, provided
120 |           that such additional attribution notices cannot be construed
121 |           as modifying the License.
122 | 
123 |       You may add Your own copyright statement to Your modifications and
124 |       may provide additional or different license terms and conditions
125 |       for use, reproduction, or distribution of Your modifications, or
126 |       for any such Derivative Works as a whole, provided Your use,
127 |       reproduction, and distribution of the Work otherwise complies with
128 |       the conditions stated in this License.
129 | 
130 |    5. Submission of Contributions. Unless You explicitly state otherwise,
131 |       any Contribution intentionally submitted for inclusion in the Work
132 |       by You to the Licensor shall be under the terms and conditions of
133 |       this License, without any additional terms or conditions.
134 |       Notwithstanding the above, nothing herein shall supersede or modify
135 |       the terms of any separate license agreement you may have executed
136 |       with Licensor regarding such Contributions.
137 | 
138 |    6. Trademarks. This License does not grant permission to use the trade
139 |       names, trademarks, service marks, or product names of the Licensor,
140 |       except as required for reasonable and customary use in describing the
141 |       origin of the Work and reproducing the content of the NOTICE file.
142 | 
143 |    7. Disclaimer of Warranty. Unless required by applicable law or
144 |       agreed to in writing, Licensor provides the Work (and each
145 |       Contributor provides its Contributions) on an "AS IS" BASIS,
146 |       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
147 |       implied, including, without limitation, any warranties or conditions
148 |       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
149 |       PARTICULAR PURPOSE. You are solely responsible for determining the
150 |       appropriateness of using or redistributing the Work and assume any
151 |       risks associated with Your exercise of permissions under this License.
152 | 
153 |    8. Limitation of Liability. In no event and under no legal theory,
154 |       whether in tort (including negligence), contract, or otherwise,
155 |       unless required by applicable law (such as deliberate and grossly
156 |       negligent acts) or agreed to in writing, shall any Contributor be
157 |       liable to You for damages, including any direct, indirect, special,
158 |       incidental, or consequential damages of any character arising as a
159 |       result of this License or out of the use or inability to use the
160 |       Work (including but not limited to damages for loss of goodwill,
161 |       work stoppage, computer failure or malfunction, or any and all
162 |       other commercial damages or losses), even if such Contributor
163 |       has been advised of the possibility of such damages.
164 | 
165 |    9. Accepting Warranty or Additional Liability. While redistributing
166 |       the Work or Derivative Works thereof, You may choose to offer,
167 |       and charge a fee for, acceptance of support, warranty, indemnity,
168 |       or other liability obligations and/or rights consistent with this
169 |       License. However, in accepting such obligations, You may act only
170 |       on Your own behalf and on Your sole responsibility, not on behalf
171 |       of any other Contributor, and only if You agree to indemnify,
172 |       defend, and hold each Contributor harmless for any liability
173 |       incurred by, or claims asserted against, such Contributor by reason
174 |       of your accepting any such warranty or additional liability.
175 | 
176 |    END OF TERMS AND CONDITIONS
177 | 
178 |    APPENDIX: How to apply the Apache License to your work.
179 | 
180 |       To apply the Apache License to your work, attach the following
181 |       boilerplate notice, with the fields enclosed by brackets "{}"
182 |       replaced with your own identifying information. (Don't include
183 |       the brackets!)  The text should be enclosed in the appropriate
184 |       comment syntax for the file format. We also recommend that a
185 |       file or class name and description of purpose be included on the
186 |       same "printed page" as the copyright notice for easier
187 |       identification within third-party archives.
188 | 
189 |    Copyright {yyyy} {name of copyright owner}
190 | 
191 |    Licensed under the Apache License, Version 2.0 (the "License");
192 |    you may not use this file except in compliance with the License.
193 |    You may obtain a copy of the License at
194 | 
195 |        http://www.apache.org/licenses/LICENSE-2.0
196 | 
197 |    Unless required by applicable law or agreed to in writing, software
198 |    distributed under the License is distributed on an "AS IS" BASIS,
199 |    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
200 |    See the License for the specific language governing permissions and
201 |    limitations under the License.
202 | 


--------------------------------------------------------------------------------