Java 8 partial function application /currying

Question

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

In the expression above, I can understand that function partial returns another function, Function<U, R>. That Function<U, R> itself returns a value of R. What does the rest static <T, U, R> stand for? I mean if Function<U, R> returns an R what is the deal with <T, U, R> ?

Those `` tell Java that `T`, `U`, and `R` are not supposed to be actual classes, but placeholders for generic classes. — tobias_k, Apr 11 '16 at 10:00
That's how you define a method with type parameters. See [Generic Methods](https://docs.oracle.com/javase/tutorial/extra/generics/methods.html) in Oracle's Java Tutorials. — Jesper, Apr 11 '16 at 10:04
Any method that adds generic type parameters beyond those of the class they are in must declare them before the return type. Static methods don't inherit any generic type parameters from the class they are in, so all of their type parameters must be declared before the return type. When you see static methods with type parameters that are the same as the parent class, it is only a coincidence that they are named the same. So, T, U and R is just the set of all generic types used in the method parameters and return type. — Hank D, Apr 11 '16 at 17:40
@hank-d so does that mean that a non static method would not have been decorated wit before the return type? what is meant with "adds generic type parameters beyond those of the class" ,can you please provide any links so I look it up? — microwth, Apr 12 '16 at 07:13
@mirowth, if you have a class MyClass and a member function that uses A, B, and another type parameter C, the member function could be declared something like "public returnType...". It only has to declare the extra type parameter C because A and B are already defined as class type parameters. static functions can't inherit A and B from the class, so it has to list all of them before the return type, i.e. "public static returnType..." — Hank D, Apr 13 '16 at 22:25
By the way, there is a naming convention for type parameters in the api. Generally, but not always, R is a return value's type, while T and, if needed, U, are parameter types. When the return type is the same as the param type, such as with UnaryOperator and BinaryOperator, it's just T — Hank D, Apr 13 '16 at 22:29
There is a good article about the partial function and currying in Java - https://engineering.sellerlabs.com/2020/04/partial-function-application-and-currying-in-java — foal, Nov 17 '20 at 08:17

T.J. Crowder · Accepted Answer · 2016-04-11T10:06:16.280

7

(I know it's not technically correct in Java terminology, but I'm going to say "argument" below where I mean "formal parameter" because mixing "formal parameter" and "type parameter" everywhere is confusing.)

T is the type parameter for the x argument.

partial accepts two arguments:

f, a function that accepts a T and a U and returns an R:
BiFunction<T, U, R> f
x, which is of type T:
T x

partial returns a new function that only accepts a U (not a T and a U) and returns R. Instead of expecting a T argument, the new function uses the x provided to partial when calling f.

In short: It returns a new function in which the first argument (of type T) has been partially-applied (curried) via partial's x argument.

The reason we have <T, U, R> near the beginning of the declaration is that that's how Java syntax lets us specify that partial is a generic method, using type parameters T, U, and R (otherwise, they look like type names, not type parameters).

edited Apr 11 '16 at 10:06

answered Apr 11 '16 at 10:00

T.J. Crowder

1,031,962
187
1,923
1,875

so in "static " the T is replaced by "BiFunction f" and U="T x" ? – microwth Apr 11 '16 at 10:21
1

@microwth: No, `T`, `U`, and `R` are all specified when the method is called, to give concrete types for those type parameters. What `partial` does is return a function accepting `U` and returning `R` that calls the original function accepting `T` and `U` and returning `R` with the specified value of `x`. E.g., if I have a method `Widget foo(String, List)`, I could use `partial` to get a ``Widget partialFoo(List)` that will call `foo` with `x` as the string. More in the generics tutorial: https://docs.oracle.com/javase/tutorial/extra/generics/methods.html – T.J. Crowder Apr 11 '16 at 10:29
@t-j-crowder "that calls the original function" you mean function "f"? So it's like "return (y) -> f.apply(x, y);" is "Function" and then ,when f.apply(x, y) runs it returns a value ,so it becomes return (y)->value, which is a function that satisfies the static . Is that correct ? – microwth Apr 11 '16 at 11:24
@microwth: `(y) -> f.apply(x, y)` creates a function, which is what `partial` returns. The function accepts `y`. The body of the function is effectively `return f.apply(x, y);` So when you call the function `partial` returns, it calls `f`, passing in `x` (the one you gave `partial`) for the first argument and `y` (the one you gave when calling the function `partial` returns) as the second argument, and then it returns whatever `f` returns. – T.J. Crowder Apr 11 '16 at 12:20

Java 8 partial function application /currying

1 Answers1