I am not trying to fit anything anywhere; merely, provide a layperson perspective of an existing problem to the laypeople - the Java programmers.

I have absolutely no ambition of using Java as a functional language. OK, this is a bit of a lie, since I use Scala quite a lot these days - whose very existence refutes your claim that it cannot be done. You might also wish to refer to my post titled Fix It Sun!, which outlines the single biggest bottleneck in software development progress - the inability to tail call on the Sun JVM (the IBM JVM works fine, so long as it is not an indirect tail call).

In the meantime, I will use Haskell/Scala et. al. and watch the Java programmers struggle with solving even the most basic of problems - that of partial function. I will make efforts to provide insight for those seek it of course, hence this post.

http://bracha.org/pluggable-types.pdf

That’s why the generic parameter R is declared on the method, so that you can call ‘accept’ and have it return anything.

You can use it like a CPS if you make R a Runnable, which I did for a short while, but, to be honest, I kept forgetting to tag ‘.run()’ to the end.
maybe.accept(functionThatReturnsARunnable,anotherRunnable).run();

A non-CPS use of the ‘functional’ Maybe:

For example, my automated tests operate on a JFrame. I wrapped JFrame so that I can instantiate my version in ‘headless’ mode, but sometimes you need to get at the original JFrame, e.g., to pass a ‘this’ pointer to a layout manager. So I have:

Maybe[javax.swing.JFrame] getRealFrame(); in my JFrame interface.

Suppose I want to find out whether the real frame is visible, and assume it’s not if it doesn’t exist. In reality I can call ‘isVisible()’ on my own JFrame interface, but let’s suppose I didn’t implement that..

Function[JFrame,Boolean] isVisible=new Function[JFrame,Boolean]()
{
public Boolean run(JFrame frame)
{
return frame.isVisible();
}
};

frame.getRealFrame().accept(isVisible,false);

Of course, Java’s syntax doesn’t make the above function definition pretty.

It’d be nicer if we could use delegates:

frame.getRealFrame().accept(JFrame.isVisible,false);

or closures:

frame.getRealFrame().accept({t.isVisible()},false);

Of course, simply ‘frame.isVisible()’ is preferable there, instead of that whole line, as each implementation of my JFrame wrapper interface knows for definite (no Maybes about it) whether it has a real frame or not.

By the way, nice lambdas. I’ll try not to mistake them for a wishbone.

I only intended to point out that it is possible (though a poor man’s implementation) to emulate an algebraic data type with Java. I intend to cover this topic much more thoroughly by first introducing intersection types [1] and working from there.