Functors in Java

1. Overview

In this tutorial, we’ll demonstrate how to create functors in Java. To begin, let’s go through a few specifics regarding the nature of the term “functor.” Then we’ll look at some code examples of how it can be used in Java.

2. What’s a Functor?

The term “Functor” comes from the field of mathematics, specifically from a subfield referred to as “category theory.” In computer programming, a functor can be considered a utility class that allows us to map values encased in a particular context. Additionally, it represents a structure-preserving mapping between two categories.

Two laws rule the functors:

• Identity: When a Functor is mapped over by an identity function, which is a function that returns the same value as the parameter it was passed, we are required to get the initial Functor (the container and its content remain unchanged).
• Composition/Associativity: It should be the same as mapping over one function after the other when a Functor is used to map over the composite of two parts.

3. Functors in Functional Programming

A functor is a design pattern used in functional programming inspired by the definition used in category theory. It enables a generic type to apply a function inside of it without affecting the structure of the generic type. In programming languages like Scala, we can find a lot of uses for Functors.

4. Functors in Java

Java and most other contemporary programming languages do not include anything considered a suitable built-in equivalent of functors. However, since Java 8, functional programming elements were introduced into the language. The idea of functional programming‘s still relatively novel in the Java programming language.

The Functor can be implemented in Java using the Function interface from java.util.function package. Here’s an example of a Functor class in Java that takes a Function object and applies it to a value:

public class Functor<T> {
    private final T value;
    public Functor(T value) {
        this.value = value;
    }
    public <R> Functor<R> map(Function<T, R> mapper) {
        return new Functor<>(mapper.apply(value));
    }
    // getter
}

As we can notice, the map() method is responsible for performing operations. For the new class, we define a final value attribute. This attribute is where the function will be applied. Additionally, we need a method to compare values. Let’s add this function to the Functor class:

public class Functor<T> {
    // Definitions
    boolean eq(T other) {
        return value.equals(other);
    }
    // Getter
}

In this example, the Functor class is generic since it accepts a type parameter T that specifies the type of the value stored within the class. The map method takes a Function object that takes a value of type T and returns a value of type R. The map method then creates a new Functor object by applying the function to the original value and returns it.

Here is an example of how this functor class can be used:

@Test
public void whenProvideAValue_ShouldMapTheValue() {
    Functor<Integer> functor = new Functor<>(5);
    Function<Integer, Integer> addThree = (num) -> num + 3;
    Functor<Integer> mappedFunctor = functor.map(addThree);
    assertEquals(8, mappedFunctor.getValue());
}

5. Laws Validator

So, we need to put things to the test. After our first approach, let’s use our Functor class to demonstrate the Functor Laws. First is the Identity Law. In this case, our code snippet is:

@Test
public void whenApplyAnIdentityToAFunctor_thenResultIsEqualsToInitialValue() {
    String value = "baeldung";
    //Identity
    Functor<String> identity = new Functor<>(value).map(Function.identity());
    assertTrue(identity.eq(value));
}

In the example just presented, we use the identity method available in the Function class. The value returned by the result Functor is unaffected and remains the same as the value handed in as the argument. This behavior’s evidence that the Identity law is being followed.

The next step’s to apply the second law. Before jumping into our implementation, we need to define some assumptions.

• f is a function that maps types T and R to one another.
• g is a function that maps types R and U to one another.

Afterward, we are ready to implement our test to demonstrate the Composition/Associativity law. Here’s the bit of code we implemented:

@Test
public void whenApplyAFunctionToOtherFunction_thenResultIsEqualsBetweenBoth() {
    int value = 100;
    Function<Integer, String> f = Object::toString;
    Function<String, Long> g = Long::valueOf;
    Functor<Long> left = new Functor<>(value).map(f).map(g);
    Functor<Long> right = new Functor<>(value).map(f.andThen(g));
    assertTrue(left.eq(100L));
    assertTrue(right.eq(100L));
}

From our code snippet, we define two functions labeled f and g. Afterward, we build two Functors, one named left and the other called the right, using two distinct mapping strategies. Both Functors end up producing the same output in the end. As a result, our implementation of the second law was successfully applied.

6. Functors Before Java 8

Until now, we’ve seen code examples that use the java.util.function.Function interface, which was introduced in Java 8. Suppose we are using an earlier version of Java. In that case, we can use a similar interface or create our own functional interface to represent a function that takes a single argument and returns a result.

On the other side, we can design a Functor by using Enum’s capabilities. Although it is not the optimal answer, it does conform to the Functor laws, and maybe most importantly, it does the job. Let’s define our EnumFunctor class:

public enum EnumFunctor {
    PLUS {
        public int apply(int a, int b) {
            return a + b;
        }
    }, MINUS {
        public int apply(int a, int b) {
            return a - b;
        }
    }, MULTIPLY {
        public int apply(int a, int b) {
            return a * b;
        }
    }, DIVIDE {
        public int apply(int a, int b) {
            return a / b;
        }
    };
    public abstract int apply(int a, int b);
}

The apply method is called on each of the constant values in this example, with two integers as parameters. The method executes the necessary mathematical operation and returns the result. Furthermore, the abstract keyword is used in this example to indicate that the apply process is not implemented in the Enum itself but must be implemented by each constant value. Now, let’s test our implementation:

@Test
public void whenApplyOperationsToEnumFunctors_thenGetTheProperResult() {
    assertEquals(15, EnumFunctor.PLUS.apply(10, 5));
    assertEquals(5, EnumFunctor.MINUS.apply(10, 5));
    assertEquals(50, EnumFunctor.MULTIPLY.apply(10, 5));
    assertEquals(2, EnumFunctor.DIVIDE.apply(10, 5));
}

7. Conclusion

In this article, we first described what a Functor is. Then, we step into its laws’ definitions. After that, we implemented some code examples in Java 8 to demonstrate the use of the Functor. Besides, we demonstrated, through examples, both Functor laws. In the end, we briefly explained how to use Functors in Java versions before Java 8 and provided an example with an Enum.

As usual, the code is available on over on GitHub.