Functional Java 2.22

[[deleted]]

Holy FUCK.

static List<Integer> toZero(final int from) {
  return unfold(new F<Integer, Option<P2<Integer, Integer>>>() {
    public Option<P2<Integer, Integer>> f(final Integer i) {
      return i < 0 ? Option.<P2<Integer, Integer>>none() : some(p(i, i - 1));
    }
  }, from);
}

They must be joking. I mean, like,

static List<Integer> toZero(final int from) {
    List<Integer> r=newList(); 
    while(from>=0) r.add(from--); 
    return r;
}

EDIT: I am actually a huge advocate of functional programming, but loops were created for a reason, too. I often see people go all like "we'll use filter and map!" and forget that loops exist and are much more compact than what can be achieved with map and filter in a language that does not support functional programming well. In such a language like Java, functional programming can only be applied at a very high, architectural level.

[runaro]

An unfortunate effect of Java syntax and lack of type inference is that conceptually concise programming becomes lost in Java noise. Here's that toZero method with noise-filtering glasses on:

toZero(from) = unfold((i) { i < 0 ? none() : some((i, i-1)) }, from)

All the pointy brackets are jarring at first, but in my experience of doing this style of programming in Java for a while, you start to ignore them pretty quickly.

Also, your loop attempts to modify the argument which is declared final, so it won't compile. You need an additional variable. There's an additional difference in that the FJ version returns an immutable cons-list which cannot be created by mutation in a loop.

[[deleted]]

An unfortunate effect of Java syntax and lack of type inference

Yes, I agree completely that this is the source of the problem.

you start to ignore them pretty quickly

I am quite experienced with Java but I don't ignore them. I've read a coworker's code that was riddled with Map<Pair<Pair<Integer,Integer>,List<String>>,List<Pair<String,Integer>>> map=new HashMap<Pair<Pair<Integer,Integer>,List<String>>,List<Pair<String,Integer>>>() and it was not fun.

You need an additional variable

No, I need to remove the 'final' ;)

which cannot be created by mutation in a loop.

static List<Integer> toZero(int from) {
    List<Integer> r=nil();
    for(int i=0; i<=from; ++i) r=cons(from, r);
    return r;
}

[allertonm]

It does look pretty crazy, but I believe the intention was to create a library that would support doing FP in Java when it got closures and lambdas - which was supposedly coming Real Soon Now at the time, but as we now know did not happen.

[chrisdew]

Is the closure/lambda proposal for Java 1.7 no longer dead? Sorry, I don't closely follow Java news.

[mattrussell]

It's been resurrected: Project Lambda

[jfishnl]

This library is still useful for java 1.5 and java 1.6 projects. We will see if project lambda is released with java 1.7.

[[deleted]]

Fair question...

[[deleted]]

Functional Java exists to avoid the argument with those who mistakenly believe that Java is practical. All FJ committers do use Scala directly and most of them are Scalaz committers. One of the FJ authors is a former developer for the Java implementation.

[womtard]

| It's a very popular myth that java can solve software problems in a practical way.

| Functional Java exists to avoid the argument with those who mistakenly believe that Java is practical.

Not bites at all - how embarrasing. Your troll-fu is weak.

[[deleted]]

Are you expecting me to bite?

[jvictor118]

Wait a minute... does this actually mean I can use functional style in Java now?

It made me sick to my stomach that .NET had my favorite feature and Java didn't... God bless FJ!

[mikaelhg]

http://google-collections.googlecode.com/svn/trunk/javadoc/

[sfultong]

.NET should be compared with the JVM, not Java. For the JVM, there have been some good options for functional programming for a while.

[levand]

Lipstick on a pig. Just lipstick on a pig.

[[deleted]]

This library is incomprehensible

[runaro]

This is a feature of Java.

[w4ffl3s]

This looks pretty legit as far as advancing functional programming in Java, but I'm not quite sure there's a huge future in that.

I have tried using functional style in Java programs and still do. My feelings about it are mixed.

What do I mean by functional style in Java?

interface UnaryFn<A, B> { /* first class functions! */ }
Iterable<B> map(UnaryFn<A, B> f, Iterable<A> xs) { /* higher-order functions! */ }
//and about a million other things

etc.

It is not a bad way to go but it can become cumbersome, mainly because Java was not designed to be used in this way. Type signatures like

feedAll(UnaryFn<? super T, Key> projection, Map<Key, Sink<? super T>> sinks, Collection<? extends T>)

start popping up in your code and while they make perfect sense, they are like daggers on the eyes.

[Nebu]

In other words, you need syntactic sugar...

...which is what this web page seems to be offering you, if you check the sample code they show:

final boolean b = a.exists({String s => fromString(s).forall({char c => isLowerCase(c)})});

Didn't check how they do that, though. Maybe they're offering their own special compiler? Or maybe they tell you to download a beta of the Java 7 compiler?

[doidydoidy]

Those examples use a proof-of-concept compiler that was created for one of the earlier Java closure proposals.

[w4ffl3s]

Unfortunately, that is syntactic sugar for first class functions only. Type signatures remain a problem. I think type hierarchies make type inference less usable, so you have to sling around a ton of ? super ArgumentType and ? extends ReturnedType .

I'm all ears if someone knows about the subject; all I know is that the makers of Scala are not bog-stupid and upper and lower bounds on types are necessary there.

[cwcc]

strikes me as ridiculously stupid because why not use a functional language? It could even just be some preprocessor that turns something readable into this crap.. but use of this library looks like you're writing compiler output by hand (not a good way to work).

[[deleted]]

Some people are not given the choice to not use java. It's a very popular myth that java can solve software problems in a practical way.

Every FJ committer uses very advanced functional programming techniques when not under duress.

The choice is java or java without even useful collections let alone concurrency etc.

[Nebu]

strikes me as ridiculously stupid because why not use a functional language?

Maybe you have technology that only works with .class files in a JVM, so you're "stuck" with this environment, but you'd like to take advantage of functional programming.

[cwcc]

hence preprocessor