The main class is called Try
.
Try
has a few overloaded static constructors for instantiating lazy computations which is called Try.of()
.
Try
instance may be constructed via one of these five arguments:
Runnable
Consumer<T> with arg
,Supplier<T>
,Function<T, V> with arg
,BiFunction<T, U, V> with two args
Try
has two sub-classes: Success<T>
which holds the successful value and Failure
which holds the exception.
Try
may be used in different ways, so without further ado let's see the examples below:
problem description: try getting the element from the list, if it fails return stringified 0, or else return the stringified square of the success value.
solution with pure java:
public static String getAndThenDoubleAndThenStringify(List<Integer> list, int index) {
String result;
try {
int number = list.get(index);
result = String.valueOf(number * 2);
} catch (Exception e) {
result = "0";
}
return result;
}
solution with fluenTry
:
public static String getAndThenDoubleAndThenStringify(List<Integer> list, int index) {
return Try.of(list, index, List::get).map(n -> n * 2).fold(String::valueOf, "0");
}
Here is a Failed computation which returns Failure(ArithmeticException)
instead of blowing up the calling stack by throwing an exception and succeeds with pure value with the help of fold
combinator:
double result = Try.of(() -> Math.random() * 2 * 5)
.flatMap(n -> Try.of(() -> n + 1))
.flatMap(n -> Try.of(() -> 55 / 0)) // This is where the `Success` turns into `Failure`
.map(Math::sqrt)
.fold(Function.identity(), 0.0); // but with the help of `fold` we turn that into pure value
Let's see another example:
problem description: try to parse json string into Person
instance, if succeeds return true or else return false.
solution with pure java:
public static Optional<Person> parseJson(String json) {
var jsonParser = new JsonParser<Person>();
Optional<Person> result;
try {
result = Optional.of(jsonParser.fromJson(json));
} catch (JsonParsingException jpe) {
result = Optional.empty();
}
return result;
}
solution with fluenTry
- takes a string argument and the Function<T, V>
instance as a second argument, finally calles toOptional()
which converts the Try<T>
into Optional<T>
:
public static Optional<Person> parseJson(String json) {
var parser = new JsonParser<Person>();
return Try.of(json, parser::fromJson).toOptional();
}
Let's see something related to java Enums:
problem description: Write a method on Weekend enum which returns true of the passed string is a Weekend day or else return false.
solution with pure java:
public enum Weekend {
SATURDAY,
SUNDAY;
public static boolean isWeekend(String day) {
try {
String normalized = day.trim().toUpperCase();
Weekend.valueOf(normalized);
return true;
} catch (IllegalArgumentException iae) {
return false;
}
}
}
with fluenTry:
- takes a Supplier<String>
as an argument, then maps
and finally folds
to either true
or false
:
public enum Weekend {
SATURDAY,
SUNDAY;
public static boolean isWeekend(String day) {
return Try.of(() -> day.trim().toUpperCase()).map(Weekend::valueOf).fold(d -> true, false);
}
}