Can Java.next include F#? Please?

Stuart Halloway coined the term "Essence vs. Ceremony" to describe the future of maintainable code in a post-Java world, and we're indebted to him for clearly and uniquely stating the problem with some of the most popular programming languages (historical note: it happened live at Code Freeze 2008 - hooray Minneapolis). Now he's back, this time describing the similarities in the new JVM languages gaining mindshare, a group of languages he's calling Java.next.

So I'll ask the question that is sure to be on the minds of JVM language users everywhere: "Is F# Java.next?" Let's consider it by comparing some Groovy and F# code...

Low-Ceremony Property Definitions - Java.next eases the burden of type, field, accessor, mutator, and constructor creation. F# Record Types fit the bill.

// F#
type Person = {
    firstName: string
   lastName: string }

let fred = { firstName="Fred"; lastName="Flinstone" }

// Groovy
class Person {
    def firstName
    def lastName
}

new Person(firstName: "Fred", lastName: "Flinstone")

Expressive Collections - Java.next offers simple, easy, concise syntax for lists and maps. F# does too. The following code finds all natural number odd squares under 100:

// F#
[ 1 .. 10 ]
   |> List.map (fun x -> x * x)
   |> List.filter (fun x -> x % 2 = 1)

// Groovy
(1..10).collect{ it * it }.findAll { it % 2 == 1} 

Functional programming - Java.next supports functional programming concepts like first class functions, closures, and higher order programming. F# is a functional language, it doesn't just support it. I'm not sure about Clojure, but I'd be willing to conjecture that F# has better FP support than Groovy or Ruby. This code creates a function that performs addition:

// F#
let sum a b = a + b

// Groovy
adder = { add -> { val -> val + add } }  

Overriding Operators - F# and Java.next support operator overloading. Groovy supports a limited number of predefined operators. In F# you're just redefining what certain symbols mean, so the options in F# should not be so limited. The motivating example is to produce a custom Rational number type that can be used like this:

balance + (balance * interest)

The syntax for this isn't that pretty in either language, but is a bit more intuitive, in my opinion, in F# than Groovy because there is no special syntax. You define a member of the class just like any other, while Groovy requires a named method and even C++ required an operator keyword.

// F#
type Rational (num:int,denom:int) =
    member x.num = num
    member x.denom = denom
    static member (+) (r1: Rational ,r2: Rational) =
       Rational((r1.num*r2.denom) + (r1.denom*r2.num), r1.denom*r2.denom)
    static member ( * ) (r1: Rational ,r2: Rational) =
       Rational(r1.num*r2.num, r1.denom*r2.denom)

// Groovy
class Rational {
    def num
    def denom

   Rational plus(Rational other) {
       new Rational(
           num: (this.num * other.denom) + (this.denom * other.num),
          denom: this.denom * other.denom)
   }

   Rational multiply(Rational other) {
       new Rational(
           num: this.num * other.num,
           denom: this.denom * other.denom)
   }
}

Maintainable Exception Handling - I love anyone willing to call checked exceptions a failed experiment. C# doesn't have checked exceptions and it doesn't seem F# does either. So far F# has 5 out of the 8 commonalities with Java.next... could it just be part of this group?

Adding Methods to Existing Types - Working with Groovy's metaprogramming system has been a real joy, with only a few exceptions. Venkat's chapters on the subject in his book are great, and there is always Groovy.mn's presentation. Opening types to add members in F# is possible but I was told it was "bad form". It can be done, but the following is only valid within the "compilation unit" not globally... maybe that's a good thing though. This code adds an isPositive method to our previous Rational type:

// F#
type Rational with
    member x.isPositive =
       if x.num > 0 && x.denom > 0 then true
       elif x.num < 0 && x.denom < 0 then true
       else false

// Groovy
Rational.metaClass.isPositive = {
   if (delegate.num > 0 && delegate.denom > 0) return true
   if (delegate.num < 0 && delegate.denom < 0) return true
   false
} 

Roll-Your-Own Constructs - I'm not 100% clear on what this means. In Java.next you can "create new constructs that work like core language features". But the example in Clojure just seems to define a function called most that has a calling syntax like other language keywords. My knowledge of F# starts to break down here, but OCaml has a preprocessor that would allow you to do anything (cite: Robert Fischer), and there is purportedly an OCaml library that changes the language to use a Scheme prefix-operator-and-parenthesis syntax. Seems like F# should be up to par in this area. Here's an implementation of a generic most function like the one on Stuart's blog, just for fun (doesn't exactly scale well to larger tuples, though).

// F#
let most (x, y, z) =
    match (x, y, z) with
   | Some(x), Some(y), Some(z) -> true
   | None, Some(y), Some(z) -> true
   | Some(x), None, Some(z) -> true
   | Some(x), Some(y), None -> true
   | _ -> false

Everything is an Object - Java.next languages don't have primitive types... everything is an object. This helps with DSL funness because you can write code like 5.days.from.now, producing a Date object representing 5 days in the future. Cool. But to quote a Yegge post: "Dude, not everything is an object."
F# seems focused on creating operations that work on types rather than adding operations to types. F# still has the .NET value types like int and float, which can't have operations added to them. Adding a method to System.Int32 seems out of the question... at least I can't figure out how, which is quite different from impossible! A preprocessor should make quick work of this, but on the surface it doesn't seem supported. More research on my part is needed here. Bummer, F# only got 7 out of 8 Java.next commonalities.

Conclusion - The only logical conclusion is that we should start work on a .NET implementation running on the JVM. Starting Google Code project in 3...2...1...
Seriously though, cool ideas aren't restricted to the JVM and I've had a great time playing with F# and putting this post together. It's always fun to compare languages, isn't it?
(and curses to blogger's mangling of escape characters and whitespace, I did my best)