Hum... No.

We can conclude that Ocaml outperforms GHC on this edge case for the GC.

There's nothing to conclude here about a general case, and it may not even be possible to make general conclusions about GC.

> ... and it may not even be possible to make general conclusions about GC.

Exactly my experience of the Java JIT and GC where I worked on uh "optimizations" of related metrics in two or three projects.

I too find with Java (most of my career I worked with it) if you change hardware just slightly you can also get wildly different results making other users benchmark conclusions on GC and JIT not very helpful. Like your armpits the only benchmarks that don't stink are your own :)

OCaml is not yet multicore ready. Also, overloaded operators aren't available, which can be a bit of a pain if you're writing numerical code. Otherwise it's a great language.

...and a terrible ecosystem. I recently mucked around with getting set up in Ubuntu Linux with F#, Haskell, Ocaml, and others. Ocaml to me was the worst in terms of user friendliness. I never got it working, so I'm working in Haskell. I hope some day somebody spits out a truly good docker image of Ocaml Batteries Included.

Catches with OCaml? Mutable strings, unchecked integer arithmetic. It's got its fair share of ugly corners.

it seems to me that ocaml/(ocaml zealotry) > haskell/(haskell zealotry). This of course does not suggest that Ocaml>Haskell, only that one must probably apply some coefficients in favour of Ocaml given that it is extra-anglo-saxon domain and therefore probably suffers some marketing disadvantage.

Just a casual observation of the commento-sphere after a lay imperative programmer's cursory research of functional programming. This post, sample-of-one hugely notwithstanding, seems in the absence of counterpoints to suggest that, as potentially narrow as the benchmark may be, Ocaml has some very strong arguments against Haskell on the compiler implemenation front.

I can't help but wonder if this GC outperformance is the flipside of the coin of Ocaml's much maligned lack of multi-core capability.

Well said, and I feel exactly the same way (as an interested observer)

Mutable strings are on the way out though. 4.02 introduced -safe-string and 4.04 lets you build compilers and OPAM switches that mandate it.