Foldable Collections / Data Structures

I've never been big into functional programming, so my recent work with VAVR, which more and more seems like some kind of java port back from scala or haskell, has been very new and different for me.  Some of the things I have seen have been really exciting -- flatMap and groupBy, for example, are very simple, straight-forward, and useful tools.

And then there is folding.  Foldable data structures (here is another reference).  Geometrically, the concept of folding is straight forward, too.  Imaging turning a page in a book -- this is folding the page over.  It is a simple as that.

Functionally speaking, however, things get a lot more interesting.  If we start with a list:

A B C D

And then we fold that list in either direction, we don't visibly reflect, as folding is not quite the same as reflection.  Instead, folding results in this list:

D C B A

Of course, this is a very simple example of folding because folding can become much more complicated than that.

VAVR has an API that allows a user to foldLeft or foldRight, and then the user can provide a function to describe the result of the fold, too.  And any object that implements foldable can be folded.  A map, for example, is foldable!

Here is some code I used (including code output) to help better understand programmatic folding.

import io.vavr.Tuple2;
import io.vavr.collection.List;
import io.vavr.collection.TreeMap;

public class Vavr {

    public static void main(String... args) {
        foldingExamples();
    }

    private static void foldingExamples() {
        //Given a Foldable data structure (ex: a TreeMap), fold it!
        TreeMap<String, List<Integer>> map = TreeMap.of(
                "Even", List.of(2, 4, 6, 8, 10),
                "NAN",  List.of(),
                "Odd",  List.of(1, 3, 5, 7, 9)
        ); //TreeMap will ensure we sort these by key: Even, NAN, Odd

        //Fold left means go in sorted order.  So starting with "^" and appending afterward, it is:
        //1. ^
        //2. ^Even
        //3. ^EvenNAN
        //4. ^EvenNANOdd
        String foldLeft = map.foldLeft("^", (resultStringStaringWithCarat, mapTuple) -> resultStringStaringWithCarat + treeMapTuple2ToString(mapTuple));

        //Still sorted order because fold left.  However, we are putting the tuple on the left as we go, so it is:
        //1. !
        //2. Even!
        //3. NANEven!
        //3. OddNANEven!
        String foldLeft2 = map.foldLeft("!", (resultStringStaringWithBang, mapTuple) ->  treeMapTuple2ToString(mapTuple) + resultStringStaringWithBang);
        System.out.println(foldLeft);
        System.out.println(foldLeft2);
        /*map.foldLeft("^", new BiFunction<String, Tuple2<String, List<Integer>>, String>() {
            @Override
            public String apply(String s, Tuple2<String, List<Integer>> stringListTuple2) {
                return s + stringListTuple2.toString();
            }
        });*/  //equivalent to basic call to foldLeft above.


        //Fold right means go in REVERSE sorted order.  So starting with "^" and appending afterward, it is:
        //1. !
        //2. !Odd
        //3. !OddNAN
        //4. !OddNANEven
        String foldRight = map.foldRight("!", (mapTuple, resultStringStartingWithPound) -> resultStringStartingWithPound +  treeMapTuple2ToString(mapTuple)); //notice how the order of mapTuple and result are switched -- this is forced!

        //Still sorted in reverse order because fold right.  However, we are putting the tuple on the left as we go, so it is:
        //1. ^
        //2. Odd^
        //3. NANOdd^
        //4. EvenNANOdd^
        String foldRight2 = map.foldRight("^", (mapTuple, resultStringStartingWithSplat) ->  treeMapTuple2ToString(mapTuple) + resultStringStartingWithSplat);

        System.out.println(foldRight);
        System.out.println(foldRight2);
    }

    private static String treeMapTuple2ToString(Tuple2<String, List<Integer>> tuple2) {
        return tuple2._1+tuple2._2.mkString("(", ",", ")");
    }
}

/* Output
^Even(2,4,6,8,10)NAN()Odd(1,3,5,7,9)
Odd(1,3,5,7,9)NAN()Even(2,4,6,8,10)!
!Odd(1,3,5,7,9)NAN()Even(2,4,6,8,10)
Even(2,4,6,8,10)NAN()Odd(1,3,5,7,9)^
 */
};