Skip to main content

Currying

FunctionalCode simplificationFunctional decompositionGenericImmutableAbout 4 min

Also known as

  • Partial Function Application

Intent

Currying decomposes a function that takes multiple arguments into a sequence of functions that each take a single argument. It helps in creating a higher-order function by partial application of its arguments.

Explanation

Real-world example

Currying in programming can be compared to an assembly line in a factory. Imagine a car manufacturing process where each station on the assembly line performs a specific task, such as installing the engine, painting the car, and adding the wheels. Each station takes a partially completed car and performs a single operation before passing it to the next station. Similarly, in currying, a function that requires multiple arguments is broken down into a series of functions, each taking a single argument and returning another function until all arguments are provided. This step-by-step processing simplifies complex tasks by dividing them into manageable, sequential operations.

In plain words

Decompose a function that take multiple arguments into multiple functions that take a single argument.

Wikipedia says

In mathematics and computer science, currying is the technique of translating a function that takes multiple arguments into a sequence of families of functions, each taking a single argument.

Programmatic example

Consider a librarian who wants to populate their library with books. The librarian wants functions which can create books corresponding to specific genres and authors. Currying makes this possible by writing a curried book builder function and utilising partial application.

We have a Book class and Genre enum.

public class Book {
    private final Genre genre;
    private final String author;
    private final String title;
    private final LocalDate publicationDate;

    Book(Genre genre, String author, String title, LocalDate publicationDate) {
        this.genre = genre;
        this.author = author;
        this.title = title;
        this.publicationDate = publicationDate;
    }
}

public enum Genre {
    FANTASY,
    HORROR,
    SCI_FI
}

We could easily create a Book object with the following method:

Book createBook(Genre genre, String author, String title, LocalDate publicationDate) {
    return new Book(genre, author, title, publicationDate);
}

However, what if we only wanted to create books from the FANTASY genre? Passing the FANTASY parameter with each method call would be repetitive. Alternatively, we could define a new method specifically for creating FANTASY books, but it would be impractical to create a separate method for each genre. The solution is to use a curried function.

/**
 * Curried book builder/creator function.
 */
static Function<Genre, Function<String, Function<String, Function<LocalDate, Book>>>> book_creator
        = bookGenre
        -> bookAuthor
        -> bookTitle
        -> bookPublicationDate
        -> new Book(bookGenre, bookAuthor, bookTitle, bookPublicationDate);

Note that the order of the parameters is important. genre must come before author, author must come before title and so on. We must be considerate of this when writing curried functions to take full advantage of partial application. Using the above function, we can define a new function fantasyBookFunc, to generate FANTASY books as follows:

Function<String, Function<String, Function<LocalDate, Book>>> fantasyBookFunc = Book.book_creator.apply(Genre.FANTASY);

Unfortunately, the type signature of BOOK_CREATOR and fantasyBookFunc are difficult to read and understand. We can improve this by using the builder patternopen in new window and functional interfaces.


/**
 * Implements the builder pattern using functional interfaces to create a more readable book
 * creator function. This function is equivalent to the BOOK_CREATOR function.
 */
public static AddGenre builder() {
    return genre
            -> author
            -> title
            -> publicationDate
            -> new Book(genre, author, title, publicationDate);
}

/**
 * Functional interface which adds the genre to a book.
 */
public interface AddGenre {
    Book.AddAuthor withGenre(Genre genre);
}

/**
 * Functional interface which adds the author to a book.
 */
public interface AddAuthor {
    Book.AddTitle withAuthor(String author);
}

/**
 * Functional interface which adds the title to a book.
 */
public interface AddTitle {
    Book.AddPublicationDate withTitle(String title);
}

/**
 * Functional interface which adds the publication date to a book.
 */
public interface AddPublicationDate {
    Book withPublicationDate(LocalDate publicationDate);
}

The semantics of the builder function can easily be understood. The builder function returns a function AddGenre, which adds the genre to the book. Similarity, the AddGenre function returns another function AddTitle, which adds the title to the book and so on, until the AddPublicationDate function returns a Book. For example, we could create a Book as follows:

Book book = Book.builder().withGenre(Genre.FANTASY)
    .withAuthor("Author")
    .withTitle("Title")
    .withPublicationDate(LocalDate.of(2000, 7, 2));

The below example demonstrates how partial application can be used with the builder function to create specialised book builder functions.

public static void main(String[] args) {
    LOGGER.info("Librarian begins their work.");

    // Defining genre book functions
    Book.AddAuthor fantasyBookFunc = Book.builder().withGenre(Genre.FANTASY);
    Book.AddAuthor horrorBookFunc = Book.builder().withGenre(Genre.HORROR);
    Book.AddAuthor scifiBookFunc = Book.builder().withGenre(Genre.SCIFI);

    // Defining author book functions
    Book.AddTitle kingFantasyBooksFunc = fantasyBookFunc.withAuthor("Stephen King");
    Book.AddTitle kingHorrorBooksFunc = horrorBookFunc.withAuthor("Stephen King");
    Book.AddTitle rowlingFantasyBooksFunc = fantasyBookFunc.withAuthor("J.K. Rowling");

    // Creates books by Stephen King (horror and fantasy genres)
    Book shining = kingHorrorBooksFunc.withTitle("The Shining")
            .withPublicationDate(LocalDate.of(1977, 1, 28));
    Book darkTower = kingFantasyBooksFunc.withTitle("The Dark Tower: Gunslinger")
            .withPublicationDate(LocalDate.of(1982, 6, 10));

    // Creates fantasy books by J.K. Rowling
    Book chamberOfSecrets = rowlingFantasyBooksFunc.withTitle("Harry Potter and the Chamber of Secrets")
            .withPublicationDate(LocalDate.of(1998, 7, 2));

    // Create sci-fi books
    Book dune = scifiBookFunc.withAuthor("Frank Herbert")
            .withTitle("Dune")
            .withPublicationDate(LocalDate.of(1965, 8, 1));
    Book foundation = scifiBookFunc.withAuthor("Isaac Asimov")
            .withTitle("Foundation")
            .withPublicationDate(LocalDate.of(1942, 5, 1));

    LOGGER.info("Stephen King Books:");
    LOGGER.info(shining.toString());
    LOGGER.info(darkTower.toString());

    LOGGER.info("J.K. Rowling Books:");
    LOGGER.info(chamberOfSecrets.toString());

    LOGGER.info("Sci-fi Books:");
    LOGGER.info(dune.toString());
    LOGGER.info(foundation.toString());
}

Program output:

09:04:52.499 [main] INFO com.iluwatar.currying.App -- Librarian begins their work.
09:04:52.502 [main] INFO com.iluwatar.currying.App -- Stephen King Books:
09:04:52.506 [main] INFO com.iluwatar.currying.App -- Book{genre=HORROR, author='Stephen King', title='The Shining', publicationDate=1977-01-28}
09:04:52.506 [main] INFO com.iluwatar.currying.App -- Book{genre=FANTASY, author='Stephen King', title='The Dark Tower: Gunslinger', publicationDate=1982-06-10}
09:04:52.506 [main] INFO com.iluwatar.currying.App -- J.K. Rowling Books:
09:04:52.506 [main] INFO com.iluwatar.currying.App -- Book{genre=FANTASY, author='J.K. Rowling', title='Harry Potter and the Chamber of Secrets', publicationDate=1998-07-02}
09:04:52.506 [main] INFO com.iluwatar.currying.App -- Sci-fi Books:
09:04:52.506 [main] INFO com.iluwatar.currying.App -- Book{genre=SCIFI, author='Frank Herbert', title='Dune', publicationDate=1965-08-01}
09:04:52.506 [main] INFO com.iluwatar.currying.App -- Book{genre=SCIFI, author='Isaac Asimov', title='Foundation', publicationDate=1942-05-01}

Class diagram

Currying
Currying

Applicability

  • When functions need to be called with some arguments preset.
  • In functional programming languages or paradigms to simplify functions that take multiple arguments.
  • To improve code reusability and composability by breaking down functions into simpler, unary functions.

Tutorials

Known uses

  • Functional programming languages like Haskell, Scala, and JavaScript.
  • Event handling in UIs where a function with specific parameters needs to be triggered upon an event.
  • APIs that require configuration with multiple parameters.

Consequences

Benefits:

  • Increases function reusability by allowing the creation of specialized functions from more generic ones.
  • Enhances code readability and maintainability by breaking complex functions into simpler, single-argument functions.
  • Facilitates function composition, leading to more declarative and concise code.

Trade-offs:

  • Can lead to performance overhead due to the creation of additional closures.
  • May make debugging more challenging, as it introduces additional layers of function calls.
  • Can be less intuitive for developers unfamiliar with functional programming concepts.
  • As shown in the programmatic example above, curried functions with several parameters have a cumbersome type signature in Java.
  • Function Composition: Currying is often used in conjunction with function composition to enable more readable and concise code.
  • Decoratoropen in new window: While not the same, currying shares the decorator pattern's concept of wrapping functionality.
  • Factoryopen in new window: Currying can be used to create factory functions that produce variations of a function with certain arguments preset.

Credits