## 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.

res – REST with Spring (eBook) (everywhere)