Currying in Java

1. Introduction

Since Java 8, we can define one- and two-parameter functions in Java, allowing us to inject their behaviors into other functions, by passing them in as parameters. But for functions with more parameters, we rely on external libraries like Vavr.

Another option is to use currying. By combining currying and functional interfaces, we can even define easy-to-read builders that force the user to provide all inputs.

In this tutorial, we’ll define currying and present its usage.

2. Simple Example

Let’s consider a concrete example of a letter with multiple parameters.

Our simplified first version needs only a body and a salutation:

class Letter {
    private String salutation;
    private String body;
    
    Letter(String salutation, String body){
        this.salutation = salutation;
        this.body = body;
    }
}

2.1. Creation by Method

Such an object can be easily created with a method:

Letter createLetter(String salutation, String body){
    return new Letter(salutation, body);
}

2.2. Creation with a BiFunction

The above method works just fine, but we may need to supply this behavior to something written in the functional style. Since Java 8, we can use BiFunction for this purpose:

BiFunction<String, String, Letter> SIMPLE_LETTER_CREATOR 
  = (salutation, body) -> new Letter(salutation, body);

2.3. Creation with a Sequence of Functions

We can also restate this as a sequence of functions each with one parameter:

Function<String, Function<String, Letter>> SIMPLE_CURRIED_LETTER_CREATOR 
  = salutation -> body -> new Letter(salutation, body);

We see that salutation maps to a function. The resulting function maps onto the new Letter object. See how the return type has changed from BiFunction. We’re only using the Function class. Such a transformation to a sequence of functions is called currying.

3. Advanced Example

In order to show the advantages of currying, let’s extend our Letter class constructor with more parameters:

class Letter {
    private String returningAddress;
    private String insideAddress;
    private LocalDate dateOfLetter;
    private String salutation;
    private String body;
    private String closing;

    Letter(String returningAddress, String insideAddress, LocalDate dateOfLetter, 
      String salutation, String body, String closing) {
        this.returningAddress = returningAddress;
        this.insideAddress = insideAddress;
        this.dateOfLetter = dateOfLetter;
        this.salutation = salutation;
        this.body = body;
        this.closing = closing;
    }
}

3.1. Creation by Method

Like before, we can create objects with a method:

Letter createLetter(String returnAddress, String insideAddress, LocalDate dateOfLetter, 
  String salutation, String body, String closing) {
    return new Letter(returnAddress, insideAddress, dateOfLetter, salutation, body, closing);
}

3.2. Functions for Arbitrary Arity

Arity is a measure of the number of parameters a function takes. Java provides existing functional interfaces for nullary (Supplier), unary (Function), and binary (BiFunction), but that’s it. Without defining a new Functional Interface, we can’t provide a function with six input parameters.

Currying is our way out. It transforms an arbitrary arity into a sequence of unary functions. So for our example, we get:

Function<String, Function<String, Function<LocalDate, Function<String,
  Function<String, Function<String, Letter>>>>>> LETTER_CREATOR =
  returnAddress
    -> closing
    -> dateOfLetter
    -> insideAddress
    -> salutation
    -> body
    -> new Letter(returnAddress, insideAddress, dateOfLetter, salutation, body, closing);

3.3. Verbose Type

Obviously, the above type is not quite readable. With this form, we use ‘apply’ six times to create a Letter:

LETTER_CREATOR
  .apply(RETURNING_ADDRESS)
  .apply(CLOSING)
  .apply(DATE_OF_LETTER)
  .apply(INSIDE_ADDRESS)
  .apply(SALUTATION)
  .apply(BODY);

3.4. Pre-Filling Values

With this chain of functions, we can create a helper which pre-fills out the first values and returns the function for onward completion of the letter object:

Function<String, Function<LocalDate, Function<String, Function<String, Function<String, Letter>>>>> 
  LETTER_CREATOR_PREFILLED = returningAddress -> LETTER_CREATOR.apply(returningAddress).apply(CLOSING);

Notice, that for this to be useful, we have to carefully choose the order of the parameters in the original function so that the less specific are the first ones.

4. Builder Pattern

To overcome the unfriendly type definition and the repeated usage of the standard apply method, meaning you have no clues about the correct order of inputs, we can use the builder pattern:

AddReturnAddress builder(){
    return returnAddress
      -> closing
      -> dateOfLetter
      -> insideAddress
      -> salutation
      -> body
      -> new Letter(returnAddress, insideAddress, dateOfLetter, salutation, body, closing);
}

Instead of a sequence of functions, we use a sequence of functional interfaces. Notice that the returning type of the above definition is AddReturnAddress. In the following we have only to define the intermediate interfaces:

interface AddReturnAddress {
    Letter.AddClosing withReturnAddress(String returnAddress);
}
    
interface AddClosing {
    Letter.AddDateOfLetter withClosing(String closing);
}
    
interface AddDateOfLetter {
    Letter.AddInsideAddress withDateOfLetter(LocalDate dateOfLetter);
}

interface AddInsideAddress {
    Letter.AddSalutation withInsideAddress(String insideAddress);
}

interface AddSalutation {
    Letter.AddBody withSalutation(String salutation);
}

interface AddBody {
    Letter withBody(String body);
}

So using this to create a Letter is quite self-explanatory:

Letter.builder()
  .withReturnAddress(RETURNING_ADDRESS)
  .withClosing(CLOSING)
  .withDateOfLetter(DATE_OF_LETTER)
  .withInsideAddress(INSIDE_ADDRESS)
  .withSalutation(SALUTATION)
  .withBody(BODY));

Like before, we can pre-fill the letter object:

AddDateOfLetter prefilledLetter = Letter.builder().
  withReturnAddress(RETURNING_ADDRESS).withClosing(CLOSING);

Notice that the interfaces ensure the filling order. So, we can’t just pre-fill closing.

5. Conclusion

We’ve seen how to apply currying, so we’re not constrained by the limited number of parameters supported by the standard Java functional interfaces. In addition, we can easily pre-fill the first few parameters. Furthermore, we’ve learned how to use this to create a readable builder.