Things like macros, STM, and the general simplicy of Clojure are all major wins IMO. I've worked in both static languages (C, C++, C#) and dynamic langauges (Clojure, Python, JS), and I have to say I'm about 3x more productive in a dynamic language like Python than I am in C# (and yes, I know the .NET platform like the back of my hand). I'm about 2x more productive in Clojure than I am in Python.

And I really cannot over stress the power of macros. Almost half of Clojure is written in clojure, and half of that is written in macros. In C# and F# I find myself writing the same code over and over again. In Clojure I simply wrap all that up in a macro and then have the language write that boilerplate code for me.

The interop features of Clojure far surpass F# in my opinion. Look at reify, proxy, and defrecord, they really don't have a comparison in F#. In addition, in Clojure almost everything is a function. A few examples:

(map :name [{:name "John"} {:name "Jim"}])
=> ("John", "Jim")

This sort of "everything is a function" philosophy runs throughout the entire system.

To end off with, the most telling thing for me, is that after 2 years I still have never really said "wow, F# had this feature, why doesn't Clojure have it?". True F# has tailcalls, but Clojure has recur and lazy-seq, and I've never needed anything else.

<disclaimer> I wrote the Clojure on Python VM port, so I'm biased. </disclaimer>

The simple fact is that F# today is much better supported than either Clojure or Scala; and unless Oracle adopts either of the later two, this will be the case for a long time to come.

One very basic feature missing from the JVM is support for tail calls. For a functional language support for tail calls is essential.

I think Scala has been able to work around the lack of tail call support in the JVM but I don't know about Clojure.

I have worked with both .Net and the JVM and have found that .Net comes with more out of the box and you don't need as much community support as in the case of Java/JVM.

F# has been really innovative with Computational Workflows (async monad, etc.); Active Patterns; and now Type Providers.

Personally I very much dislike Clojure - primarily for lack of static typing. In the untyped family there is Racket, a much, much better designed Lisp. With that being said, if you insist on using the JVM, have you tried Scala? Scala is not without its quirks (poor tail call support, language complexity), but at least it is statically typed. Its type system also has some advantage over F# in supporting more abstraction (higher kinds).

Side note: for community libraries for F#/.NET check out [link:nuget.org]

Another thought: is Java really that open-soure? OpenJDK is (and some other implementations are), Sun Java isn't - they seem to be in a similar relationship as Mono and .NET. I guess your argument would be that OpenJDK et al are more compatible and better established than Mono, but only time will tell how this will develop.

Hi Jacobo,

Given that this is a subjective thread, regarding the VM, I don't think F# is tied to Mono at all in the long run. Nor would I have doubts about Microsoft investing into .NET. In fact, the .NET has been historically much quicker to incorporate new features and ideas than the JVM, which has helped languages like F# come about and funneling the ideas behind them into other .NET languages. So all in all, the VM angle seems to fit better with .NET, at least in my opinion.

Community-wise, F# has a lot to "learn" from languages like Ruby, Scala or Clojure. My feeling is that the community is growing only slowly because recognition (of users and companies) is little or nothing, and Microsoft has consistently stumped on F# in favor of C#. I am not a big fan of keeping F# on the backburner, and to me the biggest obstacle to letting a larger F# community develop is Microsoft's messaging and attitude towards the language. This is their internal politics, but even that can't stop progress for long so I would bet that you will see a much larger F# community growing out as a result.