Optionals in Kotlin

In No more Ifs I wrote a little bit about the new Optional class in Java 8. It enables the developer to work with optional values without a complex nested structure of if-then-else expressions. A colleague of mine, being a big fan of Kotlin, dropped a hint that using Kotlin, it would be much easier. He could even prove it. šŸ™‚

In the blog article I used an example of parsing a list of parameters for a float value. The parameters were given as a map from a key to a value. To parse the parameters, you have first look for the key, then check if it is mapped to a unique value and finally convert the string value to a float. Every step can fail and lead to no result value. This is an implementation using Java in combination with Vavr:
[code language=”Java”]
Option<Float> readFloatParameterUsingOption(
String parameterName,
Map<String, Set> parameters) {
return Option.of(parameters.get(parameterName))
.filter(values -> values.size() == 1)
.map(values -> values.iterator().next())
.flatMap(Function1.lift(Float::parseFloat));
}
[/code]

Kotlin has a built-in operator .? that evaluate its right part only if the left part is not null. If the left part is null, the expression is evaluated to a null value. In combination with the standard library of Kotlin and the [] syntax to access maps, the same algorithm can be written as:
[code language=”Java”]
fun readFloatParamK(
name: String,
params: Map<String, Set>): Float? =
params[name]
?.run { if (size != 1) null else this }
?.first()
?.toFloatOrNull()
[/code]
This is IMHO a well readable and concise way of writing the algorithm and, thus, another argument to use Kotlin.

You can find the Java and the Kotlin code here:
https://github.com/akquinet/NoMoreIfs