Optional.ifAbsentThrow()? - java-8

Question

Suppose I need to find a value of a certain order, then get its id, and then its localized-id. And if I can't do it, I want to throw and exception:
return values.stream()
.filter(value -> value.getOrder("order") == order)
.findAny()
.map(Attribute::getId)
.map(Id::getLocalizedId)
.orElseThrow(() -> new RuntimeException("Could not get the localized id of the value of order " + order));
The problem is that the exception is not very detailed: it tells me I can't get the localized-id, but not why.
I miss some Optional.ifAbsentThrow method that would allow me to do this:
return values.stream()
.filter(value -> value.getOrder("order") == order)
.findAny()
.ifAbsentThrow(() -> new RuntimeException("Could not find value of order " + order));
.map(Attribute::getId)
.ifAbsentThrow(() -> new RuntimeException("Value of order " + order + " has no id"));
.map(Id::getLocalizedId)
.orElseThrow(() -> new RuntimeException("Could get the id but not the localized id of the value of order " + order));
To solve this problem, I have created the following ifAbsentThrow method:
public static <T, X extends RuntimeException> Predicate<T> ifAbsentThrow(Supplier<? extends X> exceptionSupplier) throws RuntimeException {
return valor -> {
if (valor == null) throw exceptionSupplier.get();
return true;
};
}
And I use it like this:
return values.stream()
.filter(value -> value.getOrder("order") == order)
.findAny()
.filter(ifAbsentThrow(() -> new RuntimeException("Could not find value of order " + order));
.map(Attribute::getId)
.filter(ifAbsentThrow(() -> new RuntimeException("Value of order " + order + " has no id"));
.map(Id::getLocalizedId)
.orElseThrow(() -> new RuntimeException("Could get the id but not the localized id of the value of order " + order));
My Questions:
1) Am I missing something here? Is Optional really missing this
functionality or I shouldn't be doing this for some reason?
2) Is there a better, recommended way of throwing more detailed exceptions
for missing values?
Edit: It now seems to me that Optional.ifAbsentThrow does not exist because it would be a way of dealing with null values, and Optional is all about not using null values in the first place. Optional clearly doesn't play well with null values, it gets verbose if you mix them. However, in the real world I find it difficult to deal with this all-or-nothing proposition: Some code gets translated to Optionals, while other remains using nullable values. To help me mix them, and refactor nullables to Optionals only when necessary, I believe I will be using the GetNonNull class below, built upon knowledge I gained from #Alex and #Holgers answers in this page.

Answer 1

Optional is meant to encapsulate a possibly absent value. If you perform an operation like ifAbsentThrow there is no point in carrying the value as an Optional as you already know it’s not absent on normal completion. So orElseThrow does what you intend but returns an ordinary object as it’s not optional anymore.
Of course, you can apply a function to an ordinary object and wrap its result into an Optional again, as Alex suggested, but ask yourself whether this is really an improvement over the straight-forward code:
Attribute a=values.stream().filter(value -> value.getOrder("order") == order).findAny()
.orElseThrow(() -> new RuntimeException("Could not find value of order " + order));
Id id=a.getId();
if(id==null)
throw new RuntimeException("Value of order " + order + " has no id");
String name=id.getName();
if(name==null)
throw new RuntimeException(
"Could get the id but not the localized id of the value of order " + order);
return name;
You can also create a utility method providing the operation of applying a function and throwing appropriately if the function returned null:
static <T,R, E extends Throwable> R get(T o, Function<T,R> f, Supplier<E> s) throws E {
return Optional.ofNullable(f.apply(o)).orElseThrow(s);
}
using this method, your operation becomes:
return get(ContainingClass.<Attribute,Id,RuntimeException>get(
values.stream().filter(value -> value.getOrder("order") == order).findAny()
.orElseThrow( () -> new RuntimeException("Could not find value of order " + order)),
Attribute::getId,() -> new RuntimeException("Value of order " + order + " has no id")),
Id::getName, () -> new RuntimeException(
"Could get the id but not the localized id of the value of order " + order));
(Unfortunately, the type inference of the compiler hit its limit here)
The last resort would be the creation of an alternative to Optional which does not only carry a possibly absent value but an optional error:
public final class Failable<T,E extends Throwable> {
private final T value;
private final E failure;
private Failable(T value, E failure) {
this.value=value;
this.failure=failure;
if(value==null && failure==null) throw new NullPointerException();
}
public T get() throws E {
if(failure!=null) throw failure;
return value;
}
public <R> Failable<R,E> map(Function<T,R> f, Supplier<E> s) {
if(value!=null) {
R result=f.apply(value);
return new Failable<>(result, result!=null? null: s.get());
}
// already failed, types of R and T are irrelevant
#SuppressWarnings("unchecked") Failable<R,E> f0=(Failable)this;
return f0;
}
public static <T,E extends Throwable> Failable<T,E> of(Optional<T> o, Supplier<E> s) {
return o.map(t -> new Failable<>(t, (E)null))
.orElseGet(()->new Failable<>(null, s.get()));
}
}
Using this class, you could code your operation as
return Failable.of(
values.stream().filter(value -> value.getOrder("order") == order).findAny(),
() -> new RuntimeException("Could not find value of order " + order))
.map(Attribute::getId, ()->new RuntimeException("Value of order "+order+" has no id"))
.map(Id::getName, ()->new RuntimeException(
"Could get the id but not the localized id of the value of order " + order)).get();

Answer 2

Yes, Optional does not have an ifAbsentThrow method which returns the Optional if it is present. The closest is orElseThrow which returns the value from the optional.
Since your way doesn't actually work, there certainly is a better way to do it.
It doesn't work because this is the implementation of Optional#filter:
public Optional<T> filter(Predicate<? super T> predicate) {
Objects.requireNonNull(predicate);
if (!isPresent())
return this;
else
return predicate.test(value) ? this : empty();
}
As you can see, it doesn't use the Predicate if it is not present, so your filters are doing nothing.
One way you could do it is to use orElseThrow and then re-wrap the result after applying your mapping function with ofNullable:
Optional<Attribute> o = //get your first optional from the stream.
return Optional.ofNullable(Optional.ofNullable(
o.orElseThrow(() -> new RuntimeException("Could not find value of order " + order))
.getId())
.orElseThrow(() -> new RuntimeException("Value of order " + order + " has no id"))
.getName())
.orElseThrow(() -> new RuntimeException("Could get the id but not the localized id of the value of order " + order));
You could also break that up into separate statements if you think that would be more readable.
Another way would be to change Attribute#getId and Id#getName to return Optionals instead of null. Then it would look like this:
return values.stream()
.filter(value -> value.getOrder("order") == order)
.findAny()
.orElseThrow(() -> new RuntimeException("Could not find value of order " + order))
.getId()
.orElseThrow(() -> new RuntimeException("Value of order " + order + " has no id"))
.getName()
.orElseThrow(() -> new RuntimeException("Could get the id but not the localized id of the value of order " + order));
I would prefer this way because you don't need to re-wrap the return values with ofNullable and it lets other people calling those methods know that the return values are optional, but if you can't change them then the first way would work fine.

Answer 3

The hypothetical ifAbsentThrow(...) method can be expressed with existing methods of Optional like this:
.map(Optional::of).orElseThrow(...)
Then your original example becomes:
return values.stream()
.filter(value -> value.getOrder("order") == order)
.findAny()
.map(Optional::of)
.orElseThrow(() -> new RuntimeException("Could not find value of order " + order))
.map(Attribute::getId)
.map(Optional::of)
.orElseThrow(() -> new RuntimeException("Value of order " + order + " has no id"))
.map(Id::getLocalizedId)
.orElseThrow(() -> new RuntimeException("Could get the id but not the localized id of the value of order " + order));

Answer 4

Based on the knowledge I gained from #Alex and #Holgers answers in this page,
I have developed the following GetNonNull class, focused on readability:
Optional<Value> value = values.stream()
.filter(value -> value.getOrder("order") == order)
.findAny();
return GetNonNull
.mapOrThrow(value, () -> new RuntimeException("Got no value."))
.mapOrThrow(Value::getAttribute, () -> new RuntimeException("Got value, but no attribute."))
.mapOrThrow(Attribute::getId, () -> new RuntimeException("Got value and attribute, but no id."))
.mapOrThrow(Id::getLocalizedId, () -> new RuntimeException("Got value, attribute and id, but no localized id."))
.get();
I find this functional code very easy to read, and it concentrates all exception handling code together (no need to
add orElseThrow to the end of the stream). The GetNonNull name implies that the end result will never be null.
Compare it with the alternative imperative code:
if (valor == null) throw new RuntimeException("Got no value.");
Attribute attribute = valor.getAttribute();
if (attribute == null) throw new RuntimeException("Got value, but no attribute.");
Id id = attribute.getId();
if (id == null) throw new RuntimeException("Got value and attribute, but no id.");
String localizedId = id.getLocalizedId();
if (localizedId == null) throw new RuntimeException("Got value, attribute and id, but no localized id.");
return localizedId;
Instead of throwing, you may also return an Optional:
return GetNonNull
.mapOrThrow(value, () -> new RuntimeException("Got no value."))
.mapOrThrow(Value::getAttribute, () -> new RuntimeException("Got value, but no attribute."))
.mapOrThrow(Attribute::getId, () -> new RuntimeException("Got value and attribute, but no id."))
.getOptional(Id::getLocalizedId); // Changed here.
Or you may return a non-null default value:
return GetNonNull
.mapOrThrow(value, () -> new RuntimeException("Got no value."))
.mapOrThrow(Value::getAttribute, () -> new RuntimeException("Got value, but no attribute."))
.mapOrThrow(Attribute::getId, () -> new RuntimeException("Got value and attribute, but no id."))
.getOrDefault(Id::getLocalizedId, "DEFAULT"); // Changed here.
It is also Optional/null agnostic, i.e., nothing changes if the initial value is a regular nullable value, instead of an Optional:
Value value = ...; // Not an Optional.
return GetNonNull
.mapOrThrow(value, () -> new RuntimeException("Got no value."))
.mapOrThrow(Value::getAttribute, () -> new RuntimeException("Got value, but no attribute."))
.mapOrThrow(Attribute::getId, () -> new RuntimeException("Got value and attribute, but no id."))
.mapOrThrow(Id::getLocalizedId, () -> new RuntimeException("Got value, attribute and id, but no localized id."))
.get();
You can also use it as a simple functional get-default-value idiom. This:
Value value = ...;
if (value != null) return value;
else if (default != null) return default;
else throw new NullPointerExeption();
May be written as:
// Shorter and more readable then Optional.ofNullable(value).orElse(default).
// Also not the same, because here a NullPointerException is raised if default is null.
return GetNonNull.getOrDefault(value, default);
And this:
Optional<Value> value = ...;
if (value.isPresent()) return value;
else if (default != null) return default;
else throw new NullPointerExeption();
May also be written exactly the same:
return GetNonNull.getOrDefault(value, default);
Since the GetNonNull class is compatible with both nullables and Optionals, if some legacy imperative
code that use nullable values gets later refactored to use Optionals, the GetNonNull usage needs not to be changed.
Here it is:
public final class GetNonNull<T, E extends Throwable> {
private final T value;
private final E failure;
private GetNonNull(T value, E failure) {
this.value = value;
this.failure = failure;
if ((value == null) && (failure == null)) throw new NullPointerException();
}
public T get() throws E {
if (failure != null) throw failure;
return value;
}
public <R> Optional<R> getOptional(Function<T, R> f) throws E {
if (failure != null) throw failure;
if (value != null) {
R result = f.apply(value);
return Optional.ofNullable(result);
}
return Optional.empty();
}
public static <R> R getOrDefault(R o1, Supplier<R> supplier) {
if (o1 != null) return o1;
R result = supplier.get();
if (result != null) return result;
else throw new NullPointerException();
}
public static <R> R getOrDefault(R o1, R o2) {
if (o1 != null) return o1;
else if (o2 != null) return o2;
else throw new NullPointerException();
}
public static <R> R getOrDefault(Optional<R> o1, R o2) {
if (o1.isPresent()) return o1.get();
else if (o2 != null) return o2;
else throw new NullPointerException();
}
public <R> R getOrDefault(Function<T, R> f, R o) throws E {
if (failure != null) throw failure;
if (value != null) {
R result = f.apply(value);
if (result != null) return result;
else return o;
}
return o;
}
public <R> GetNonNull<R, E> mapOrThrow(Function<T, R> f, Supplier<E> s) {
if (value != null) {
R result = f.apply(value);
return new GetNonNull<>(result, (result != null) ? null : s.get());
}
return (GetNonNull)this;
}
public static <T, E extends Throwable> GetNonNull<T, E> getOrThrow(Optional<T> o, Supplier<E> s) {
return o.map(t -> new GetNonNull<>(t, (E)null)).orElseGet(() -> new GetNonNull<>(null, s.get()));
}
public static <T, E extends Throwable> GetNonNull<T, E> mapOrThrow(T o, Supplier<E> s) {
return getOrThrow(Optional.ofNullable(o), s);
}
}