[cfoley]

I've been looking through the functional interfaces for something like this (It's part of a REPL):

public interface ActionInterface {
	void call();
}

I want to use it like this:

	public void setQuitAction(ActionInterface action) {
		quitAction = action;
	}

// and somewhere else:

evaluator.setQuitAction(() -> isLooping = false);

I feel like there should be something like ActionInterface included with all those functional interfaces. All I can come up with is Runnable, which makes you think of threads not lambdas. What's the way to do this in Java?

Spoiler

What I'm doing is extracting the Eval part of the REPL so I can write test doubles for it. However, the Eval part needs to be able to tell the main loop to stop. I suspect this will be the target of further refactoring. Passing a lambda might not be the ideal solution but it's better than Eval knowing about the REPL class. Now I can mock out the Eval part when testing the REPL and I can even mock out the quit action when testing Eval.

If only I could find an appropriate interface to replace ActionInterface!

[Flukeshot]

This is a wild guess, but based on the correct use of .addActionListener is ( e -> /*insert method or code body here*/ );

I would suggest the correct use of your example would be evaluator.setQuitAction( action -> isLooping = false );

[cfoley]

Thanks for the thought but that would introduce an error. The e -> is short for (ActionEvent e) ->. My interface has no parameter so () -> is correct.

My example works. I'm not asking for help debugging. I just want to know if Java has an interface to replace my ActionInterface. If I thought Runnable had the correct semantics I would refactor to:

// Commenting as a metphore for deletion.
// public interface ActionInterface {
// 	void call();
// }
	public void setQuitAction(Runnable action) {
		quitAction = action;
	}

// and somewhere else:

evaluator.setQuitAction(() -> isLooping = false);

This post has been edited by cfoley: 20 May 2014 - 08:14 AM

[Ryano121]

Interesting. Seems the java.util.functions package doesn't include a generic functional interface that returns void and takes no parameters. I guess they deemed it to be a rare use case - not sure why though. Linq in .Net put in Action - which is essentially what you have done yourself.

I agree though that Runnable doesn't really fit that well. I don't really see an alternative though other than rolling your own.

[Ryano121]

After a bit more digging it seems like all the examples I've found are using Runnable in this use case e.g.

() -> { System.out.println("Hello World"); }

etc etc.

I think they are pushing to use Runnable in this case. My guess is they didn't want to have two identical functional interfaces.

[cfoley]

Thanks for digging around. I hoped that wasn't the case.

While reading your post, I remembered that the Javadocs have "uses of" pages. Check it out:
http://docs.oracle.c...e/Runnable.html

Every one of them is to do with threading except maybe one. It's in the BaseStream class. Now, I don't really know what close handlers are for but I wonder if it's to do with cleaning up parallel streams.

[CasiOo]

The Runnable interface is in the java.lang package and is not found in java.util.concurrent
But yeah it makes you think about threading, especially when you read the java docs for the class
Though I see no reason why not to use it if it fits your needs
Edit: ah I see that many of the threading classes are in the lang package I thought they were located in concurrent actually

If you don't want to use Runnable, and not implement your own interface, then you could use Consumer
Still a bit messy. I would still prefer Runnable, and after that your ActionInterface

	public Main() {
		setQuitAction((v) -> System.out.println("Test" + v)); 
	}
	
	public void setQuitAction(Consumer<Void> func) {
		func.accept(null);
	}

This post has been edited by CasiOo: 20 May 2014 - 09:56 AM

[cfoley]

Yeah, threads are one of the core concepts in Java. Whatever you think about the threading model, easy threading within the process was a design goal for Java. Threads are as indispensable as String or System.

java.util.concurrent is for abstractions over threading to make our lives easier.