Unable to find a reference to the return in this method

Question

I was checking out this repository for a redux-like implementation for android. Here in a file, I found a method implementation as below:

@Override
public Dispatcher create(Store<AppState> store, Dispatcher 
nextDispatcher) {
   return action -> {
    log("dispatching action: " + action);
    nextDispatcher.dispatch(action);
    log("new state: " + store.getState());
       };
}

I am not able to understand how the return of this method works, as there is no reference to action?? Also would like to know how to convert this method implementation to Kotlin, as the Android Studio's Kotlin converter is not helping in this case. Would be grateful for any help on this. Thanks!

It's Kotlin related: https://stackoverflow.com/questions/42646016/what-does-the-arrow-operator-do-in-kotlin — emandt, Oct 09 '18 at 15:49
Thanks @emandt, but how does it work in Java? Since the snippet of Java. — Madhu Bhat, Oct 09 '18 at 15:54

score 5 · Accepted Answer · answered Oct 09 '18 at 16:17

What you have is lambda. It's a shortened form of writing some pieces of code. Of course, not everything has lambda, but this does. In your case, you create an anonymous class matching Dispatcher.

With Java 8 language features (or Java 8 itself if you're not on Android) enables interfaces with one method, optionally annotated @FunctionalInterface, to be declared with lambda. I.e. this:

Runnable x = new Runnable() {
    @Override public void run(){
        // Foo bar
    }
};

Is the same as:

Runnable x = () -> {
    // Foo bar
};

This applies to all one-method interfaces. They can be annotated @FunctionalInterface, but it's not required.

Dispatcher is one, from the code you posted. The syntax is pretty basic:

() -> {
     // () means 0 args. It can contain arguments if necessary 
    return "return value if applicable";
}

With arguments:

oneArg -> {
    //Method body
}
(arg1, arg2) -> {
    // MethodBody
}

Methods with return types can be simplified to one-liners if you feel like it:

() -> "some string return type"

And the same pattern with arguments; I'm not going to add examples for that again. The same as above still applies.

I've used varying parenthesis in this answer. There is actually some "rules" around the use of them. The compiler will complain if the syntax is wrong, but generally:

One argument doesn't need () around it. It's optional here.
Zero or two and up arguments require them.

It doesn't need explicit type declaration in Kotlin or Java; it's handled automatically. As for Java, it doesn't need i.e. int x if the interface declares a function with an int argument.

There are some exceptions in Kotlin (I've encountered the compiler complaining it failed to infer types, just manually setting the type made it compile again), but there's not many.

Anyways, action here is the single argument defined in the method. You're basically doing lambda-based inheritance, so you're required to have it in the method, but you don't have to use it (depending on your implementation).

In Kotlin, lambda for interfaces is slightly different. Interfaces declared in Java can be used in Kotlin lambda:

override fun create(store: Store<AppState>, nextDispatcher: Dispatcher) /*: Dispatcher*/
        = Dispatcher { x -> //Arguments declared here
            // add your actions here
        }

However, this bug prevents Kotlin-declared interfaces from being declared this way. You'd need to use object : WhateverInterface and add the body. (Encountered that in 1.2.70 too, so it's not fixed yet).

score 1 · Answer 2 · answered Oct 09 '18 at 15:59

Basically it's a Lambda.

One issue with anonymous classes is that if the implementation of your anonymous class is very simple, such as an interface that contains only one method, then the syntax of anonymous classes may seem unwieldy and unclear. In these cases, you're usually trying to pass functionality as an argument to another method, such as what action should be taken when someone clicks a button. Lambda expressions enable you to do this, to treat functionality as method argument, or code as data.

Dispatcher is an one class interface. One class interfaces are called Functional Interfaces and from java 8 can be represented by a lambda. So what you are seeing is an implementation of Dispatchers dispatch method.

Unable to find a reference to the return in this method

2 Answers2