using Java8's Optional in a functional way for updating source with default value

Question

This is probably more a question about functional programming than about Java 8 specifically, but it's what I'm using right now.

I have a source object (could represent a repository, or a session..., doesn't matter here) that has a method retrieveSomething() that returns an Optional<SomethingA>. I have a method somewhere that returns a Something, by calling retrieveSomething() and providing a default value in case the optional was empty, as follows:

return source.retrieveSomething()
             .orElseGet(() -> provideDefaultValue());

Now I want to modify this code so that in case the source didn't contain any value yet (so the optional was empty), the source is updated with the provided default value.

Of course, I could easily do that inside a lambda expression code block:

return source.retrieveSomething()
             .orElseGet(() -> {
                     Something sth = provideDefaultValue()
                     source.putSomething(sth);
                     return sth;
                 });

But if I understand correctly, I'm not supposed to use functions that cause side effects. So what's the "correct" (functional) way to do this, keeping the benefit of using Optional (in real code I'm actually also performing a map operation on it, but that's irrelevant here) ?

Answer 1

You could follow the way Java does this with Map.computeIfAbsent()

which takes a second parameter which is a function on how to compute and insert the record:

So your code would become:

Something something = source.computeIfAbsent(sth, (k)->provideDefaultValue());

An advantage of using a lambda to compute the default instead of just passing it in, is the lambda will only be evaluated if it needs to be so if computing the default is expensive, you only have to pay it when you need it.

Answer 2

From a conceptual standpoint, you use the optional pattern to deal with the absence of a return value. This means, if your source instance doesn't contain a value for you to use, you have the choice of providing a default value to use in its place.

It is not advised to modify the Optional directly to provide its value; that instance may be temporal and will differ on subsequent calls to retrieve it.

Since a function call truly governs what's returned by that Optional, the only approach you have if you truly want to go down this route is to modify how that value is computed. This really should be done from within the function providing the Optional, but it could be done outside of it if necessary.

Since there's not enough code structure here to truly write up some example, I will describe the steps:

• Outside of the method providing the Optional, you write the same closure as you did before, with the side effect of adjusting the value used to compute the original Optional. This is likely a field of some sort.

• Inside of the method providing the Optional, you ensure that you don't expose provideDefaultValue anywhere else (since they won't need it), and use a boolean conditional before you package the Optional.

  return value == null ? Optional.of(provideDefaultValue()) : Optional.of(value);
  

  ...but that really defeats the purpose of the Optional, as you're still doing a null check.

  A slightly better approach to the above would be to compute value in such a way that it was either itself or the default value, and return the Optional of that...

  value = computeValue();
  if(null == value) {
      value = provideDefaultValue();
  }
  return Optional.of(value);
  

  ...but again, seriously defeating the purpose of Optional, as you're doing null checks.

Answer 3

An answer I came up with myself, which I'm not entirely satisfied with, but may serve as an example of what I'm looking for:

I could implement something similar to a Pair<V1,V2> class and then map the Optional<Something> to a Pair<Something, Boolean> where the Boolean value would indicate whether or not the value was a generated default:

Pair<Something, Boolean> somethingMaybeDefault = 
    source.retrieveSomething()
          .map(sth -> new Pair<Something, Boolean>(sth, false))
          .orElseGet(() -> new Pair<Something, Boolean>(provideDefaultValue(), true));

Then I'd update in case the boolean is false:

if (somethingMaybeDefault.value2()) {
    source.putSomething(somethingMaybeDefault.value1());
}

And finally return the new value:

return somethingMaybeDefault.value1();

Of course, this uses imperative style for the update, but at least the functions remain pure. I'm not sure this is the best possible answer though.