[Haskell-cafe] Why functional programming matters

Mattias Bengtsson moonlite at dtek.chalmers.se
Thu Jan 24 17:24:22 EST 2008

On Thu, 2008-01-24 at 21:11 +0000, Paul Johnson wrote:
>    // Get the Foo that was most recently updated.
>    Foo latestUpdate (Iterator <Foo> iterator) {
>    }
> This takes an iterator over some collection of Foos and finds the one 
> with the highest value of updateTime.  9 lines of code, or 12 with the 
> closing curly brackets.
> In Haskell this is so short and obvious you probably wouldn't bother 
> declaring it as a function, but if you did, here it is:
>    -- Find the Foo that was most recently updated.
>    latestUpdate :: [Foo] -> Foo
>    latestUpdate foos = maximumBy (comparing updateTime) foos
> Of course you could always write it in point-free format, but I think 
> that would be over-egging things.

To have a fair comparison you'd have to use some typeclass (Foldable
would be right?) that supports different types of collections.

> import Data.Foldable as F
> latestUpdate :: Foldable a => [a] -> a
> latestUpdate = F.maximumBy (comparing updateTime)

But yeah your point is very very valid. I've programmed some Java in my
days and while i wouldn't call myself an expert i don't see any
immediate "unawkward" abstractions that can be performed in the java
If you have all Foo's implement a method "getProperty(String)" that
takes a String and returns the property of that class instance you
_could_ implement the static method (correct java-lingo?)
maximumBy(String s) that is roughly like this:

class MyClass {
  public static Foo maximumBy (Iterator <Foo> iterator, String s) {
     long max = 0;
     Foo maxFoo = Null;
     while (iterator.hasNext()) {
        item = iterator.getNext();
        if (item.getProperty(s).compareTo(max)) {
           max = item.updateTime;
           maxFoo = item;
     return maxFoo;

and then
Foo latestUpdate (Iterator <Foo> i) {
   return MyClass.maximumBy(i,"latestUpdate");

Totally untested code ofcourse...
The awkward part obviously comes from the fact that properties aren't
functions that you can pass to the maximumBy-method.

Anyhow, Haskell's nice Polymorphism is surely a good argument for it
(but not for functional programming per se right?)


More information about the Haskell-Cafe mailing list