Dude, where is my currying or why java cannot make it right ?

Currying is great. If you want to make oh so pretty functions with clear calls it’s the way to go. So why Big O when adding Java lambdas couldn’t make call to functional interfaces seamless but called explicitly ? Let me give you example of what I mean.

In Scala we can do

def add(x: Int): Int => Int = y => x + y

add(1)(2)

Pretty as hell. Or using compiler resolving for simplification

def add(x: Int)(y: Int): Int = x + y

add(1)(2)

In javascript we do

function add(x) {
    return function(y) {
        return x + y;
    };
}

add(1)(2)

Still ok. Maybe even easier to read.

But Java ? Oh, that’s just another pair of shoes.

Function<Integer, Function<Integer, Integer>> add = (x) -> (y) -> x + y;

add.apply(1).apply(2)

Declaration is still very pretty, despite awful and long as month type. But call ? What the fuck ? What happened ? Where did you took turn from good to worst ?

My proposition: for Java 10 don’t care about new features, just fix functional ones.