Partial Function Application in Java 8

I’ve been doing some Java lately, and the new functional additions in Java 8 are interesting. Java still has a long way to go, but they made functional programming in Java easier. For example, we can now do simple partial application.

For reference, here is what partial application looks like in Clojure (using the built in function):

(defn add [x y] (+ x y))

(def adder (partial add 5))

(adder 1)
;; 6

And here is a simple implementation with Java 8:

public class Example {
    public static int add(int x, int y) {
        return x + y;
    }

    public static <T, U, R> Function<U, R> partial(BiFunction<T, U, R> f, T x) {
        return (y) -> f.apply(x, y);
    }

    public static void main(String[] args) {
        Function<Integer, Integer> adder = partial(Example::add, 5);
        System.out.println(adder.apply(2)); // 7
    }
}

We can also define functions using lambdas:

BiFunction<Integer, Integer, Integer> minus = (x, y) -> x - y;
Function<Integer, Integer> subtractor = partial(minus, 10);
System.out.println(subtractor.apply(4)); // 6

This Java version is more limited than the Clojure one. It can only take a two argument function, whereas Clojure’s supports arbitrarily many arguments.

Java has a BiFunction (function with two arguments), but no TriFunction or more. If we want to write a version of partial that accepts more arguments, we need to write our own TriFunction:

@FunctionalInterface
interface TriFunction<T, U, V, R> {
    R apply(T a, U b, V c);
}

Then, we can make a version of partial that accepts a TriFunction:

public static <T, U, V, R> Function<V, R> partial(TriFunction<T, U, V, R> f, T x, U y) {
    return (z) -> f.apply(x, y, z);
}

And use it in much the same way:

Function<Integer, Integer> adder3 = partial(Example::add3, 1, 2);
System.out.println(adder3.apply(3)); // 6

This version allows us to pass in two arguments to partial, but it doesn’t allow us to pass in a single argument and return a function that takes two arguments:

BiFunction<Integer, Integer, Integer> adder3_2 = partial(Example::add3, 1);
System.out.println(adder3_2.apply(2, 3)); // 6

To implement this, we need yet another version of partial:

public static <T, U, V, R> BiFunction<U, V, R> partial(TriFunction<T, U, V, R> f, T x) {
    return (y, z) -> f.apply(x, y, z);
}

The moral of the story is that Java 8 allows us to implement partial, but we have to implement all of the variations separately.

Here is the full example:

@FunctionalInterface
interface TriFunction<T, U, V, R> {
    R apply(T a, U b, V c);
}

public class Example {
    public static int add(int x, int y) {
        return x + y;
    }

    public static int add3(int x, int y, int z) {
        return x + y + z;
    }

    public static <T, U, R> Function<U, R> partial(BiFunction<T, U, R> f, T x) {
        return (y) -> f.apply(x, y);
    }

    public static <T, U, V, R> Function<V, R> partial(TriFunction<T, U, V, R> f, T x, U y) {
        return (z) -> f.apply(x, y, z);
    }

    public static <T, U, V, R> BiFunction<U, V, R> partial(TriFunction<T, U, V, R> f, T x) {
        return (y, z) -> f.apply(x, y, z);
    }

    public static void main(String[] args) {
        Function<Integer, Integer> adder = partial(Example::add, 5);
        System.out.println(adder.apply(1)); // 6

        BiFunction<Integer, Integer, Integer> minus = (x, y) -> x - y;
        Function<Integer, Integer> subtractor = partial(minus, 10);
        System.out.println(subtractor.apply(4)); // 6

        Function<Integer, Integer> adder3 = partial(Example::add3, 1, 2);
        System.out.println(adder3.apply(3)); // 6

        BiFunction<Integer, Integer, Integer> adder3_2 = partial(Example::add3, 1);
        System.out.println(adder3_2.apply(2, 3)); // 6
    }
}