Iterables

[gk-brown]

The methods of Kilo's Optionals class are provided as a less verbose alternative to similar methods defined by java.util.Optional. For example, where you might write something like this using Optional:

var result = Optional.ofNullable(null).orElse(123); // 123

with Optionals it can be written as follows (similar to the null-coalescing or "Elvis" operator found in other languages):

var result = coalesce(null, () -> 123); // 123

Whereas this code could be used to determine the length of an optional string:

var result = Optional.ofNullable("hello").map(String::length).orElse(null)); // 5

it could be written more simply using Optionals as follows (similar to the safe call feature of other languages):

var result = map("hello", String::length); // 5

Similarly, Kilo's Iterables class offers a less complex alternative to the methods of java.util.stream.Stream. For example, where you might write something like this using Stream:

var values = listOf(1, 2, 3);

var result = values.stream().filter(value -> value < 3).collect(Collectors.toList()); // 1, 2

it could be written as follows using Iterables:

var result = listOf(filter(values, value -> value < 3)); // 1, 2

Whereas this code could be used to transform list of strings to a list of string lengths:

var values = listOf("a", "ab", "abc");

var result = values.stream().map(String::length).collect(Collectors.toList()); // 1, 2, 3

it could be written more simply using Iterables as follows:

var result = listOf(mapAll(values, String::length)); // 1, 2, 3

For a slightly more involved example, consider this code that groups a list of strings by length and then collects the result to a sorted map of string length to string count:

var values = listOf("a", "b", "c", "ab", "bc", "abc");

var result = values.stream()
    .collect(Collectors.groupingBy(String::length)).entrySet().stream()
        .collect(Collectors.toMap(Map.Entry::getKey, entry -> entry.getValue().size(), (v1, v2) -> {
            throw new IllegalStateException();
        }, TreeMap::new)); // 1: 3, 2: 2, 3: 1

With Iterables, it could be written as follows:

var result = sortedMapOf(mapAll(groupBy(values, String::length).entrySet(), entry -> {
    var length = entry.getKey();
    var size = entry.getValue().size();

    return entry(length, size);
})); // 1: 3, 2: 2, 3: 1

With the Stream version, you need to go to the end of the (very confusing) call chain to even see what type result will be. With the Iterables approach, it's immediately obvious that result will be a sorted map of length values to size values.

Another advantage of Iterables is that, unlike a Stream, an Iterable can be traversed using a traditional for-each loop. Developers are not forced to choose between one paradigm or the other.

For more information, see the README.