Skip to main content

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:


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:


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) {

    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);
        /*map.foldLeft("^", new BiFunction<String, Tuple2<String, List<Integer>>, String>() {
            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);


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

/* Output


Popular posts from this blog

JHipster, Liquibase, MySQL, and initializing data, including booleans!

When generating a data model from JHipster JDL, we will often declare entities with Boolean fields.  I have so far abandoned H2 as a database because of liquibase issues, and both my dev and production databases will be MySQL.  This is relevant to the Boolean field desire there is a long history in software development of how to store Boolean data types in a SQL database whose standards classically do not support Boolean. In the current JHipster/Liquibase incarnation, tables in MySQL are generated for us, which is really nice.  The Boolean data types are stored as BIT  (1).  This is not a problem so far -- most developers seem to agree now that as a best practice, we should store values in databases as false = 0 and true = 1, and a BIT(1) is a great, simple way to do that. An issue arises when we try to use liquibase to set/update our database to the desired starting state.  For my project, I've chosen gradle instead of maven as a build tool, and gradle has a plugin for liquiba

Deploying Spring Boot talking to MySQL on AWS

In a recent post, I listed some very basic information about running a MySQL database on AWS.  In most cases, we don't want a database alone; we want an application that uses that database for CRUD. I've created a simple Spring Boot application that exposes a REST API to create and manage lists of things.  The list values are all stored in a MySQL database. When I went to deploy the application on AWS using Elastic Beanstalk, there were some really good, automatic things that happened to make my life easy: AWS can deploy a Spring Boot jar very easily by simply uploading the jar during setup. AWS creates security groups on the fly so I don't have to worry about extra security configuration. AWS automatically generates DNS information and provides me a URL for accessing the application. As I deployed the application and saw all of these things, I was pretty excited.  It is nice to have a lot of this stuff taken care of for me. Then, I tried to test my applica

Spring Security - Authority vs Role

I have spent a lot of time recently trying to understand the difference between Authority and Role in Spring Security.  This is a brief review of what I found. When creating a UserDetailsService or overriding configure(AuthenticationManagerBuilder auth) in the security config class that extends WebSecurityConfigurerAdapter, I basically get complete control over what I populate inside of the UserDetails that is used/returned.  This is important because the UserDetails interface really only cares about how to return one thing: Collection<? extends GrantedAuthority> getAuthorities(); A GrantedAuthority just seems like a glorified String wrapper that names some thing.  The question is... what is that thing? This is where the subtle difference between Authority and Role comes into play. I think that Role is an older thought/construct that automatically gets plugged into Authority if we just create a user with a Role.  But completely forget about the code and classes for a mi