Furthermore, talking about “making pseudo-closures by hiding methods inside objects” is most definitely not non-sense. It is, to the best of my knowledge, the closest to idiomatic way to simulate closures in Java. To be more explicit, I was talking about instantiating an object, which obviously has an internal lexical scope (often, but not necessarily, from an anonymous class). This object can then be passed around - almost like a closure in functional languages - and you can then have a ‘higher order function’ of sorts execute the code internal to that object. It’s a fairly standard technique in Java … you can find an introductory article discussing it here.

As for comparators: that’s exactly the ‘hack’ I was talking about in the previous point. Java’s sort function don’t really care about Comparator objects - it basically just uses them to encapsulate (and thus pass around) functions. It’s an ugly hack that was only created to make up for the lack of first class functions in Java.

Also, using dynamic proxies for memoization doesn’t work without rewriting the original method to be memoized. Continuing with my example of the Fibonacci sequence: if you just used dynamic proxies, the recursive calls would not be cached - only the initial calls would be. For example, if you did it my way and computed the 40th Fibonacci number, then you get the 1st through 39th Fibonacci numbers cached (memoized) for free. With dynamic proxies (without modifying the definition of the Fibonacci method), only the value of the 40th Fibonacci number will be cached and the 1st through 39th will be repeatedly computed. Also, I don’t think it’s possible to write a general memoization method in Java (that automatically and transparently makes another method memoize solutions) like you can in Lisp.

I would say that properly implementing the missing features in Java is extremely non-trivial - you’d basically have to write an interpreted functional language in Java. I’m not much of a compiler guy - but that definitely seems hard enough that it is at least on the same level as writing a webapp through the cgi in a low level language.

Since you “honestly” can’t think of a good way to solve these problems in Java: for your sorting example, Java has the Comparator interface. For memoization, you can use dynamic proxies. Lazy evaluation is an interesting topic, but your example is completely lame; you can do the exact same thing by coding up a simple Iterator in Java.

You’re right that all these things are uglier in Java, but they’re still simple, and not even close to comparable to writing a webapp in assembly.

Personally, I tend to agree with you: porting these things into Java is considerably more work. Java programmers are therefore reluctant to use such techniques. The resulting code tends to be longer and less elegant.

On the other hand, when I *read* Java code it is always easier than reading Haskell or Lisp code. An FP function seems like a machine where every moving part affects all others. A Java method, OTOH, is a series of computations. Each computation affects only the next one.

I know most FP wizards think exactly the opposite. By all means, I am not an FP wizard. Still, perhaps the Java skills of these wizards are not something to write home about?

The examples (sorting, fib., and primes) were contrived, but they were easy and short ways to demonstrate the techniques I really cared about (function passing, automatic memoization, and lazy evaluation).

I honestly can’t think of any better examples of those techniques that use an easily digestible (< 10 lines) amount of code. Do you have any better examples I can use for future reference?

There, fixed that for you. Seriously, three years ago called, it wants its pat observations back.

@Vladimir:You’re right, it is of course possible to do something similar to this in Java. But it would take more code, be uglier, and be much less flexible. Which I admitted in my first paragraph.

@Dave: I have done that. I worked writing a commercial lisp web application. Here is one of the libraries the company I worked for developed (and open sourced): http://clsql.b9.com/manual/prerequisites.html#id352140

It supports:
*MySQL
*PostgreSQL
*SQLite
*Direct ODBC interface.
*Oracle OCI.
*Allegro’s DB interface (AODBC).
*Relatively easy to extend support with CFFI

There are other libraries (such as Elephant or CommonSQL) that support similar sets of data stores.

The sorting, fibonacci sequence, and primes (which there are libraries for in all languages) weren’t the features I was trying to demonstrate. I was trying to demonstrate first-class-functions, automatic memoization, and lazy evaluation (which, to the best of my knowledge, there aren’t libraries for in Java).

And of course there are areas were Java is better than Lisp (performance springs to mind), but everyone already know those. I was trying to demonstrate some of the features of functional languages that the average programmer may not be familiar with.