Why Currying functions is important in Java

Currying functions is the ability to pass some of the method parameters now, and the rest of those parameters later, so if a function has 2 parameter, we can invoke it with the first parameter, which will return another function waiting for the 2nd parameter ... when we pass the second parameter to this new function, the whole function is executed

This concept is very common in functional programming, but in Java, it is not ... so we have to make some work around stuff.

The following example is for some operations in Java, using Rx-Java, Guava and Retro-lambda, which helps in cutting too many lines of code using "method reference"

public void withoutFunctionsCurrying(){
    Observable.fromArray("1","2","3")
            .doOnNext(this::printNumbers)
            .map(Integer::valueOf)
            .map(this::multiplyByTwo)
            .map(this::formatToDoubleValue)
            .forEach(this::printFinalNumbers);
}

private void printNumbers(String number){
    Log.d("NUMBERS",number);
}

private int multiplyByTwo(int value){
    return IntMath.checkedMultiply(2,value);
}

private String formatToDoubleValue(int value){
    return Joiner.on(": ").join("double value",value);
}

private void printFinalNumbers(String number){
    Log.d("FINAL NUMBERS",number);
}

But the real issue begins when ever we need to pass a function that takes 2 parameters, so for example, in the first doOnNext(), we cannot pass Log::d since this method takes 2 parameters, and doOnNext() is waiting for a function that takes one parameter, so we have to create printNumbers() method just to add the first parameter

private void printNumbers(String number){
    Log.d("NUMBERS",number);
}

then we can pass reference to this method which takes one String parameter.

This approach is nice, but it results in declaring 4 extra methods that will be used only for this method.

On the other hand, if we used currying the code will end up like this :

public void withFunctionsCurrying() {
    Observable.fromArray("1", "2", "3")
            .doOnNext(Curry.toConsumer(Log::d, "NUMBERS"))
            .map(Integer::valueOf)
            .map(Curry.toFunction(IntMath::checkedMultiply, 2))
            .map(Curry.toFunction(Joiner.on(": ")::join, "double value"))
            .forEach(Curry.toConsumer(Log::d, "FINAL NUMBERS"));
}

* I used J-Curry library for Currying functions, but you can use what ever technique you prefer

so now when ever there is a function that takes 2 parameters, we can curry it and pass to it the first parameter, it will return another function that is expecting only one last parameter (which will be emitted by Rx-Java operator)

I hope that Kotlin should provide such powerful feature.