Pages

Tuesday, April 24, 2018

VAVR - Using map(), flatMap(), Option and Try to get different return types

Simple map() operation in vavr.io takes as argument a function that has as a parameter the type of element contained in the list. The return type of the method in the function can be anything we want. The purpose of map is to transform from one type to another.

public List<BigDecimal> simpleMap(List<Integer> numbers) {
      return numbers.map(n -> m1(n));
   }

    private BigDecimal m1(Integer i) {
     return new BigDecimal(i);
   }


flatMap() uses the same mechanics as map but the only difference is that it will remove the duplication by collapsing the duplicates into a single entry. e.g 1,2,2,2,3 flatMapped will become 1,2,3
public List<BigDecimal> flatMapping(List<Integer> numbers) {
    return numbers.flatMap(n -> m2(n));
   }

   private List<BigDecimal> m2(Integer i) {
     return List.of(new BigDecimal(i));
   }

Sometimes a function can return List<Try<Option<?>>>> that is fine but perhaps Option is sometimes redundant. Notice that this method uses Try<Option>, that looks a bit overkill
public List<Try<Option<String>>> returningARedundantOption(List<Integer> numbers) {
        return numbers.map(n -> m3(n));
    }

    private Try<Option<String>> m3(Integer i) {
        //Imagine this option is the result of intereacting with other code
        // e.g some dao object
        return Try.success(Option.some(""));
    }

To solve the redundancy shown in the example above, we can perform an additional flatMap() so that we get rid of the Option by mapping it to a Try using the toTry() method inside Option. This way we get a List<Try<String>>.
public List<Try<String>> removingRedundancy(List<Integer> numbers) {
        return numbers.map(n -> {
            return m3(n).flatMap(Option::toTry);
        });
    }
    //Same as above
    public List<Try<String>> removingRedundancy(List<Integer> numbers) {
        return numbers.map(n -> m3(n).flatMap(Option::toTry));
    }

    private Try<Option<String>> m3(Integer i) {
        return Try.success(Option.some(""));
    }

In this final example we map a set of integers to a Try<Option<String>> and then we flatMap the result to Set<Try<String>> in order to transform that Set<Try<String>> into a Try<List<String>> we pass the result to Try.sequence() and we map the outcome to list.
public Try<List<String>> usingSequence(Set<Integer> ids) {
        Set<Try<String>> result = ids.map(id -> m4(id).flatMap(Option::toTry));
        return Try.sequence(result).map(Seq::toList);
    }

    //Same as above
    public Try<List<String>> spike2(Set<Integer> ids) {
        return Try.sequence(ids.map(id -> m4(id).flatMap(Option::toTry))).map(Seq::toList);
    }

    private Try<Option<String>>  m4(Integer id) {
        Try.success(Option.of("something" + id));
    }

For more information about the vavr.io framework: http://www.vavr.io/

Share with your friends